This lesson satisfied the requirement object-oriented programming using class(es) and objects defined by the student for the NCEA module "AS91906 Use complex programming techniques to develop a computer
program"
On completion of this lesson you will know:
Here we are entering on a new phase of programming: object oriented programming or OOP for short. Although the word 'object' is used generally when referring to this style of programming what we will be actually coding will be classes. Once we have finished with the coding of a class, then we can start creating objects from the same class.
Gemini has provided me with this analogy of a class that I was able to expand on.
Imagine you're building with LEGOs. Instead of having a jumbled pile of bricks, you want to create something specific, like a car.
- What parts you need These are like the attributes in a class. They describe the car's features, like its color, number of doors, and wheel size. In programming, these would be variables that hold information about the object.
- How to put them together These are like the methods in a class. They define what the car can do, like driving forward, reversing, or honking the horn. In programming, these would be functions that perform actions.
Once you have the instructions for the car, you can build as many cars as you want, each with its own unique color, number of doors, and wheel size.
In the same way, a class in programming lets you create many different objects, each with its own unique data, but all based on the same set of instructions.
This makes your code organized and reusable, just like a LEGO instruction booklet!
We shall take Gemini's analogy further and apply it to our own case. Here we shall be building an application for processing employees' payroll.
As we are dealing with paying employees here we must keep the Inland Revenue informed. For this reason we must have values for the company's name and their EIN number. This means that we end up with two sets of variables:
What parts do we need?: we need the values for the:
How do we put them together?
The values for the employee's name, the hours worked and the hourly rate will be provided by the user once the program starts running.
Once this is provided the values for the gross, tax and net will be calculated as shown below:
Just like we could apply the Lego instructions to build any number of toy cars we can equally apply the parts and the instructions in the class to produce any number of objects from our class, each object having its own unique employee name and and pay details.
Time now to look at our class!
Go to topThe code below is based on the examples of Lego blocks and the payroll discussions that evolved out of it.
class Employee:
companyName = "Python Software Inc."
EIN_Number = "12-345678"
def __init__(self, emp, hrs, rte):
self.Employee = emp;
self.Hours = hrs;
self.Rate = rte;
self.Gross = self.Hours * self.Rate;
self.Tax = self.Gross * 0.25;
self.Net = self.Gross - self.Tax
def toString(self):
self.strOutput = f"""
{Employee.companyName}
EIN number: {Employee.EIN_Number}
Pay data for {self.Employee}
Hours worked: {self.Hours}
Hourly rate: {self.Rate}
Gross pay: {self.Gross}
Tax: {self.Tax}
Net pay: {self.Net}
"""
return(self.strOutput)
def main():
worker = Employee("Tom Thumb", 40, 30)
print(worker.toString())
worker1 = Employee("Dick Dixon", 30, 30)
print(worker1.toString())
worker2 = Employee("Harry Potter", 40, 40)
print(worker2.toString())
if __name__ == "__main__":
main()
So far in this lesson we have been discussing the topic of class and finally you are looking at an actual class. In listing 1 above it spans lines 1 - 36. At line 1 the class is named Employee
Within the class at lines 2 and 3 two class variables are declared: companyName and EIN_number. The first of those is easily explained - the employer that pays the employees. The second is Employer Identification Number, which identifies the employer to the Inland Revenue Department.
Maintaining our link with the lego blocks we associate What parts do we need? we can add the above variables as two of the items we need to process the employees' data. Below we shall look at more variables to add.
Most programming languages that support OOP have a constructor. It is a special method that runs automatically once we create an object of the class. In Python it has a very unusual name __init__(). The two underscores that comes before and after 'init' are actually part of the name.
Like all of the functions that you are familiar with, __init__() has parameters. In our case they are self, emp, hrs, and rte.
We shall explain self later on, but for now we shall concentrate on emp, hrs, and rte. These are abbreviations for 'employee', 'hours' and 'rate'.
Now let us look at how those data items are processed.
At lines 6, 7 and 8 the values of emp, hrs, and rte are copied into self.Employee, self.Hours and self.Rate.
Next lines 9, 10 and 11 use the above values to calculate the values of self.Gross, self.Tax and self.Net. By now we have all of the parts needed for assembling the details of the payroll for presentation. They are:
toString() uses a formatted string to display the values of the payroll data with appropriate labels. This complies with our analogy of assembling our Lego components.
The class Employee can't do anything on its own: an object of it has to be created first. You can see this happening at line 28 of listing 1 where this line is executed:worker = Employee("Tom Thumb", 40, 30)
At this point the system selects an empty space in memory whose starting location is stored in variable worker. This memory block is referred to as an object or more specifically as an object of the class Employee. In the same block spaces are reserved for the parameters emp, hrs and rte. It is here that the values "Tom Thumb", 40 and 30 are copied.
Here again the code in lines 6 - 11 are used to store the values of emp, hrs and rte in the attributes self.Employee, self.Hours and self.Rate. The values of the attributes self.Gross, self.Tax and self.Net are calculated and stored in the appropriate attributes.
This is all done in a separate part of memory. This memory block however can be accessed by the system due to the memory address of that block being stored in the variable worker. This occurs at line 29 where the system is told to go to the block of memory pointed to by worker. Here the function toString() is run to give us a labelled set of values of the payroll calculation.
Line 30 creates another object where the details of "Dick Dixon" are processed and then sent by line 31 to toString() where they are again displayed.
The same comments apply to lines 32 and 33.
Going back to listing 1 again we see that in lines 2 and 3 two variables are defined: companyName and EIN_Number. They are declared in the same way as if they were part of a procedural program.
They are referred to as class variables. Their unique feature is that they are usually treated as constants and the constructor never updates their values.
In our case the code will be processing payroll data for a number of employees for the same company. Obviously the data for each employee will be different but the name of the company and its EIN number will always be constant.
When the constructor is run the values of the parameters emp, hrs and rte are copied into the instance variables self.Employee, self.Hours and self.Rate. The values of the instance variables self.Gross, self.Tax and self.Net are calculated and stored in the appropriate instance variables.
From this we can determine that the values of the class variables will usually remain constant in the objects that we create but that the instance variables, i.e. those preceded by the self keyword, will be unique to each object
This is shown diagrammatically in Fig 2 below.
For a video presentation that describes the relationship between classes and objects click on the option below.
Go to topUp to now we have displayed the data stored within an object using a formatted string. This was a very convenient way to quickly check out of the code was working properly. The problem is that most of our output was numeric data and outputting it as a part of a string makes it unavailable to us for any mathematical analysis of the data itself. As an example we could not calculate the cumulative values of the gross, tax or net.
In order to do this we need to output our numeric data as numbers. This is what Listing 2 below is about.
#class definition
class Employee:
companyName = "Python Software Inc."
EIN_Number = "12-345678"
def __init__(self, emp, hrs, rte):
self.Employee = emp;
self.Hours = hrs;
self.Rate = rte;
self.Gross = self.Hours * self.Rate;
self.Tax = self.Gross * 0.25;
self.Net = self.Gross - self.Tax
def employeeName(self):
return(self.Employee)
def hoursWorked(self):
return(self.Hours)
def hourlyRate(self):
return(self.Rate)
def grossPay(self):
return(self.Gross)
def taxPaid(self):
return(self.Tax)
def netPay(self):
return(self.Net)
#list to hold the objects
Salaries = []
#Data Entry
empName= input("Enter employee name: ")
while empName != "":
empHours = int(input("Enter hours worked: "))
empRate = float(input("Enter hourly rate: "))
Salaries.append(Employee(empName, empHours, empRate))
empName = input("Enter employee name: ")
#Data Output
for i in Salaries:
print(i.employeeName())
print(i.hoursWorked())
print(i.hourlyRate())
print(i.grossPay())
print(i.taxPaid())
print(i.netPay())
print("\n")
Listing 2 is a modification of Listing 1. The main difference is that the toString() method has been replaced by six methods: employeeName(), hoursWorked(), hourlyRate(), grossPay(), taxPaid() and netPay(). Each of these methods returns the value of the corresponding attribute.
You can see that the values of the three accumulated are the sums of the three equivalent values from the two objects.
Go to topWhat is the difference between a variable and an attribute?
Variables are used to store data within a function or program, while attributes are used to describe the state or behavior of an object in object-oriented programming.
Go to topClasses are a way of grouping together data and the functions that operate on that data. The data is stored in attributes and the functions are stored in methods. The attributes and methods are accessed through objects of the class. The class is a template for the objects. The objects are created in the main() function.
Classes are a way of organising code. They are used to group together data and the functions that operate on that data. The data is stored in attributes and the functions are stored in methods. The attributes and methods are accessed through objects of the class. The class is a template for the objects. The objects are created in the main() function.
Go to topCreate a class called Rectangle with attributes length and width. Include a method called area() that calculates the area of the rectangle.
Create a class called Circle with attribute radius. Include a method called area() that calculates the area of the circle.
Create a class called Triangle with attributes base and height. Include a method called area() that calculates the area of the triangle.