In all the programs we wrote till now, we have designed our program around functions i.e. blocks of statements which manipulate data. This is called the procedure-oriented way of programming. There is another way of organizing your program which is to combine data and functionality and wrap it inside something called an object. This is called the object oriented programming paradigm. Most of the time you can use procedural programming, but when writing large programs or have a problem that is better suited to this method, you can use object oriented programming techniques.
Classes and objects are the two main aspects of object oriented
programming. A class creates a new type where objects are
instances of the class. An analogy is that you can have variables of
type int
which translates to saying that variables that store
integers are variables which are instances (objects) of the int
class.
Note for Static Language Programmers
: Note that even integers are treated as objects (of the int
class). This is unlike C++ and Java (before version 1.5) where
integers are primitive native types.
See `help(int)` for more details on the class.
C# and Java 1.5 programmers will find this similar to the *boxing
and unboxing* concept.
Objects can store data using ordinary variables that belong to the object. Variables that belong to an object or class are referred to as fields. Objects can also have functionality by using functions that belong to a class. Such functions are called methods of the class. This terminology is important because it helps us to differentiate between functions and variables which are independent and those which belong to a class or object. Collectively, the fields and methods can be referred to as the attributes of that class.
Fields are of two types - they can belong to each instance/object of the class or they can belong to the class itself. They are called instance variables and class variables respectively.
A class is created using the class
keyword. The fields and methods
of the class are listed in an indented block.
Class methods have only one specific difference from ordinary
functions - they must have an extra first name that has to be added to
the beginning of the parameter list, but you do not give a value
for this parameter when you call the method, Python will provide
it. This particular variable refers to the object itself, and by
convention, it is given the name self
.
Although, you can give any name for this parameter, it is strongly
recommended that you use the name self
- any other name is
definitely frowned upon. There are many advantages to using a standard
name - any reader of your program will immediately recognize it and
even specialized IDEs (Integrated Development Environments) can help
you if you use self
.
Note for C++/Java/C# Programmers
: The self
in Python is equivalent to the this
pointer in C++
and the `this` reference in Java and C#.
You must be wondering how Python gives the value for self
and why
you don't need to give a value for it. An example will make this
clear. Say you have a class called MyClass
and an instance of this
class called myobject
. When you call a method of this object as
myobject.method(arg1, arg2)
, this is automatically converted by
Python into MyClass.method(myobject, arg1, arg2)
- this is all the
special self
is about.
This also means that if you have a method which takes no arguments,
then you still have to have one argument - the self
.
The simplest class possible is shown in the following example (save as
simplestclass.py
).
class Person:
pass # An empty block
p = Person()
print(p)
Output:
$ python3 simplestclass.py
<__main__.Person object at 0x019F85F0>
How It Works:
We create a new class using the class
statement and the name of the
class. This is followed by an indented block of statements which form
the body of the class. In this case, we have an empty block which is
indicated using the pass
statement.
Next, we create an object/instance of this class using the name of the
class followed by a pair of parentheses. (We will learn
more about instantiation in the next section). For
our verification, we confirm the type of the variable by simply
printing it. It tells us that we have an instance of the Person
class in the __main__
module.
Notice that the address of the computer memory where your object is stored is also printed. The address will have a different value on your computer since Python can store the object wherever it finds space.
We have already discussed that classes/objects can have methods just
like functions except that we have an extra self
variable. We will
now see an example (save as method.py
).
class Person:
def sayHi(self):
print('Hello, how are you?')
p = Person()
p.sayHi()
# This short example can also be written as Person().sayHi() #
Output:
$ python3 method.py
Hello, how are you?
How It Works:
Here we see the self
in action. Notice that the sayHi
method takes
no parameters but still has the self
in the function definition.
There are many method names which have special significance in Python
classes. We will see the significance of the __init__
method now.
The __init__
method is run as soon as an object of a class is
instantiated. The method is useful to do any initialization you want
to do with your object. Notice the double underscores both at the
beginning and at the end of the name.
Example (save as class_init.py
):
class Person:
def __init__(self, name):
self.name = name
def sayHi(self):
print('Hello, my name is', self.name)
p = Person('Swaroop')
p.sayHi()
# This short example can also be written as Person('Swaroop').sayHi() #
Output:
$ python3 class_init.py
Hello, my name is Swaroop
How It Works:
Here, we define the __init__
method as taking a parameter name
(along with the usual self
). Here, we just create a new field also
called name
. Notice these are two different variables even though
they are both called 'name'. There is no problem because the dotted
notation self.name
means that there is something called "name" that
is part of the object called "self" and the other name
is a local
variable. Since we explicitly indicate which name we are referring to,
there is no confusion.
Most importantly, notice that we do not explicitly call the __init__
method but pass the arguments in the parentheses following the class
name when creating a new instance of the class. This is the special
significance of this method.
Now, we are able to use the self.name
field in our methods which is
demonstrated in the sayHi
method.
We have already discussed the functionality part of classes and objects (i.e. methods), now let us learn about the data part. The data part, i.e. fields, are nothing but ordinary variables that are bound to the namespaces of the classes and objects. This means that these names are valid within the context of these classes and objects only. That's why they are called name spaces.
There are two types of fields - class variables and object variables which are classified depending on whether the class or the object owns the variables respectively.
Class variables are shared - they can be accessed by all instances of that class. There is only one copy of the class variable and when any one object makes a change to a class variable, that change will be seen by all the other instances.
Object variables are owned by each individual object/instance of the
class. In this case, each object has its own copy of the field
i.e. they are not shared and are not related in any way to the field
by the same name in a different instance. An example will make this
easy to understand (save as objvar.py
):
class Robot:
'''Represents a robot, with a name.'''
# A class variable, counting the number of robots
population = 0
def __init__(self, name):
'''Initializes the data.'''
self.name = name
print('(Initializing {0})'.format(self.name))
# When this person is created, the robot
# adds to the population
Robot.population += 1
def __del__(self):
'''I am dying.'''
print('{0} is being destroyed!'.format(self.name))
Robot.population -= 1
if Robot.population == 0:
print('{0} was the last one.'.format(self.name))
else:
print('There are still {0:d} robots working.'.format(Robot.population))
def sayHi(self):
'''Greeting by the robot.
Yeah, they can do that.'''
print('Greetings, my masters call me {0}.'.format(self.name))
def howMany():
'''Prints the current population.'''
print('We have {0:d} robots.'.format(Robot.population))
howMany = staticmethod(howMany)
droid1 = Robot('R2-D2')
droid1.sayHi()
Robot.howMany()
droid2 = Robot('C-3PO')
droid2.sayHi()
Robot.howMany()
print("\nRobots can do some work here.\n")
print("Robots have finished their work. So let's destroy them.")
del droid1
del droid2
Robot.howMany()
Output:
$ python3 objvar.py
(Initializing R2-D2)
Greetings, my masters call me R2-D2.
We have 1 robots.
(Initializing C-3PO)
Greetings, my masters call me C-3PO.
We have 2 robots.
Robots can do some work here.
Robots have finished their work. So let's destroy them.
R2-D2 is being destroyed!
There are still 1 robots working.
C-3PO is being destroyed!
C-3PO was the last one.
We have 0 robots.
How It Works:
This is a long example but helps demonstrate the nature of class and
object variables. Here, population
belongs to theRobot
class and
hence is a class variable. The name
variable belongs to the object
(it is assigned using self
) and hence is an object variable.
Thus, we refer to the population
class variable as
Robot.population
and not as self.population
. We refer to the
object variable name
using self.name
notation in the methods of
that object. Remember this simple difference between class and object
variables. Also note that an object variable with the same name as a
class variable will hide the class variable!
The howMany
is actually a method that belongs to the class and not
to the object. This means we can define it as either a classmethod
or a staticmethod
depending on whether we need to know which class
we are part of. Since we don't need such information, we will go for
staticmethod
.
We could have also achieved the same using decorators:
@staticmethod
def howMany():
'''Prints the current population.'''
print('We have {0:d} robots.'.format(Robot.population))
Decorators can be imagined to be a shortcut to calling an explicit statement, as we have seen in this example.
Observe that the __init__
method is used to initialize the Robot
instance with a name. In this method, we increase the population
count by 1 since we have one more robot being added. Also observe that
the values of self.name
is specific to each object which indicates
the nature of object variables.
Remember, that you must refer to the variables and methods of the same
object using the self
only. This is called an attribute
reference.
In this program, we also see the use of docstrings for classes as
well as methods. We can access the class docstring at runtime using
Robot.__doc__
and the method docstring as Robot.sayHi.__doc__
Just like the __init__
method, there is another special method
__del__
which is called when an object is going to die i.e. it is no
longer being used and is being returned to the computer system for
reusing that piece of memory. In this method, we simply decrease the
Robot.population
count by 1.
The __del__
method is run when the object is no longer in use and
there is no guarantee when that method will be run. If you want to
explicitly see it in action, we have to use the del
statement which
is what we have done here.
All class members are public. One exception: If you use data members
with names using the double underscore prefix such as
__privatevar
, Python uses name-mangling to effectively make it a
private variable.
Thus, the convention followed is that any variable that is to be used only within the class or object should begin with an underscore and all other names are public and can be used by other classes/objects. Remember that this is only a convention and is not enforced by Python (except for the double underscore prefix).
Note for C++/Java/C# Programmers
: All class members (including the data members) are public and
all the methods are *virtual* in Python.
One of the major benefits of object oriented programming is reuse of code and one of the ways this is achieved is through the inheritance mechanism. Inheritance can be best imagined as implementing a type and subtype relationship between classes.
Suppose you want to write a program which has to keep track of the teachers and students in a college. They have some common characteristics such as name, age and address. They also have specific characteristics such as salary, courses and leaves for teachers and, marks and fees for students.
You can create two independent classes for each type and process them but adding a new common characteristic would mean adding to both of these independent classes. This quickly becomes unwieldy.
A better way would be to create a common class called SchoolMember
and then have the teacher and student classes inherit from this
class i.e. they will become sub-types of this type (class) and then we
can add specific characteristics to these sub-types.
There are many advantages to this approach. If we add/change any
functionality in SchoolMember
, this is automatically reflected in
the subtypes as well. For example, you can add a new ID card field for
both teachers and students by simply adding it to the SchoolMember
class. However, changes in the subtypes do not affect other
subtypes. Another advantage is that if you can refer to a teacher or
student object as a SchoolMember
object which could be useful in
some situations such as counting of the number of school members. This
is called polymorphism where a sub-type can be substituted in any
situation where a parent type is expected i.e. the object can be
treated as an instance of the parent class.
Also observe that we reuse the code of the parent class and we do not need to repeat it in the different classes as we would have had to in case we had used independent classes.
The SchoolMember
class in this situation is known as the base
class or the superclass. The Teacher
and Student
classes are
called the derived classes or subclasses.
We will now see this example as a program (save as inherit.py
):
class SchoolMember:
'''Represents any school member.'''
def __init__(self, name, age):
self.name = name
self.age = age
print('(Initialized SchoolMember: {0})'.format(self.name))
def tell(self):
'''Tell my details.'''
print('Name:"{0}" Age:"{1}"'.format(self.name, self.age), end=" ")
class Teacher(SchoolMember):
'''Represents a teacher.'''
def __init__(self, name, age, salary):
SchoolMember.__init__(self, name, age)
self.salary = salary
print('(Initialized Teacher: {0})'.format(self.name))
def tell(self):
SchoolMember.tell(self)
print('Salary: "{0:d}"'.format(self.salary))
class Student(SchoolMember):
'''Represents a student.'''
def __init__(self, name, age, marks):
SchoolMember.__init__(self, name, age)
self.marks = marks
print('(Initialized Student: {0})'.format(self.name))
def tell(self):
SchoolMember.tell(self)
print('Marks: "{0:d}"'.format(self.marks))
t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 25, 75)
print() # prints a blank line
members = [t, s]
for member in members:
member.tell() # works for both Teachers and Students
Output:
$ python3 inherit.py
(Initialized SchoolMember: Mrs. Shrividya)
(Initialized Teacher: Mrs. Shrividya)
(Initialized SchoolMember: Swaroop)
(Initialized Student: Swaroop)
Name:"Mrs. Shrividya" Age:"40" Salary: "30000"
Name:"Swaroop" Age:"25" Marks: "75"
How It Works:
To use inheritance, we specify the base class names in a tuple
following the class name in the class definition. Next, we observe
that the __init__
method of the base class is explicitly called
using the self
variable so that we can initialize the base class
part of the object. This is very important to remember - Python does
not automatically call the constructor of the base class, you have to
explicitly call it yourself.
We also observe that we can call methods of the base class by
prefixing the class name to the method call and then pass in the
self
variable along with any arguments.
Notice that we can treat instances of Teacher
or Student
as just
instances of the SchoolMember
when we use the tell
method of the
SchoolMember
class.
Also, observe that the tell
method of the subtype is called and not
the tell
method of the SchoolMember
class. One way to understand
this is that Python always starts looking for methods in the actual
type, which in this case it does. If it could not find the method, it
starts looking at the methods belonging to its base classes one by one
in the order they are specified in the tuple in the class definition.
A note on terminology - if more than one class is listed in the inheritance tuple, then it is called multiple inheritance.
The end
parameter is used in the tell()
method to change a new
line to be started at the end of the print()
call to printing
spaces.
We have now explored the various aspects of classes and objects as well as the various terminologies associated with it. We have also seen the benefits and pitfalls of object-oriented programming. Python is highly object-oriented and understanding these concepts carefully will help you a lot in the long run.
Next, we will learn how to deal with input/output and how to access files in Python.