Normally an older model of a certain product with a basic functionality gets upgraded to an advanced model with additional features and improvements to functionality of basic model. The diagram below illustrates this point. The basic phone we used nearly a decade and half ago is today upgraded to smartphone. The smart phone, while retaining capabilities of the feature phone added some new features. In object oriented parlance, it would be said that smartphone inherits the basic feature phone.
Almost every object oriented programming language supports extending capability of an existing class to build new class instead of building from scratch. In OOP terminology, this characteristic is called inheritance, which is the cornerstone of theory of object oriented programming paradigm.
Inheritance comes into picture when new class possesses 'IS A' relationship with existing class. After all, smartphone 'IS A' mobile phone! Similarly dog IS an animal. Cat also IS an animal. Hence, animal is base class while dog and cat are inherited classes.
Look at the figure below. It shows a triangle which has three sides. The equilateral triangle IS a triangle. An isosceles triangle also IS a triangle.
Triangle is a base class (also called parent class), equilateral and isosceles triangles are the inherited classes – also called child classes.
Data definitions and methods of parent class are inherited by child class; thereby features that are already available can be reused.
Child class may define additional functionality or modify a base class method. This bottom-up approach helps in building class system having hierarchical structure.
In order to indicate that a class is inherited from other, latter's name ids put in parentheses in front of the name of child class. Resources of parent class will be inherited by the object of child class.
class parent: statement1 statement2 . . class child(parent): statement1 statement2 . .
Defined below is 'triangle' class with three sides as instance attributes and area() method.
def __init__(self, a, b, c): self.a=a self.b=b self.c=c def area(self): s=(self.a+self.b+self.c)/2 area=math.sqrt(s*(s-self.a)*(s-self.b)*(s-self.c)) return area if __name__=='__main__': t1=triangle(4,13,15) print ('area = ',t1.area())
area = 24.0
Area of a triangle is calculated by using well known Heron's formula:
where s is the semi-perimeter of triangle (a+b+c)/2. Above script is save as 'tiangle.py'.
Let us now develop class for equilateral triangle using above 'Triangle' class as parent class. Instance variables and area() method from base class should be automatically inherited by it without redefining it.
Since all sides of equilateral triangle are equal, we have to provide only one value – length of side – to the constructor. Hence other two parameters required by constructor of base class are first computed. The __init__() method of Triangle class is invoked by referring to it with super() function. New class has inherited area() method.
from triangle import Triangle
def __init__(self, a): b=a c=a super().__init__(a,b,c) t2=EquiTriangle(10) print ('area = ',t2.area())
area = 43.30127018922193
In above example, we see that attributes and methods of base class have been reused in inherited class. The inherited class can define new attributes or methods in addition to inherited ones.
There are two possibilities while reusing any inherited method. It may be used as defined in base class, or the child class may modify its functionality if required. So when object of child class calls such method, the modified version is executed and not the original one in parent class. This behaviour is called inheritance.
Overriding is a feature of object-oriented language, that allows a child class to provide alternate implementation of a method that is already defined in parent class. The implementation in the child class overrides (replaces) the implementation in the parent class. The child class method should have same name, same parameters or signature, and same return type as the method in the parent class.
The EquiTriangle class is modified by providing overridden area() method as follows:
from triangle import Triangle
class EquiTriangle(Triangle): def __init__(self, a): b=a c=a super().__init__(a,b,c) def area(self): area=math.sqrt(3)*pow(self.a,2)/4 return area t2=EquiTriangle(10) print ('area = ',t2.area())
Output (is the same):
area = 43.30127018922193
The area() method uses following formula for calculation of area of equilateral triangle:
Python allows a class to inherit properties from more than one classes. Names of parent classes are mentioned in comma separated manner as below:
class base1: #statements pass class base2: #statements pass class child(base1,base2): #statements pass
In following example, two classes ('theory' and 'practical') have two instance attributes each. They are used as base for third class named 'marks'. It's __init__() method receives four parameters. They are in turn passed to constructors of respective classes.
def __init__(self, x,y): self.t1=x self.t2=y
def __init__(self, m1,m2): self.p1=m1 self.p2=m2
class marks(theory, practical):
def __init__(self,a,b,c,d): theory.__init__(self,a,b) practical.__init__(self,c,d) def percent(self): t=(self.t1+self.t2+self.p1+self.p2)*100/300 return t s1=marks(70,80,40,45) print ('percent: ',s1.percent())
As mentioned earlier, Python doesn't impose restrictions on access of any class resource outside it. Python doesn't have keywords such as public, private or protected as in C++ or Java. So in a way, all members in a Python class behave as if they have a public access.
Python however, does prescribe a convention of prefixing name of variable/method with single or double underscore. Python’s convention to make an instance variable protected is to prefix _ (single underscore) to it. It is expected that protected attribute be accessed only within its sub class. Following class has a normal, a 'private' (with double underscore prefix) and a 'protected' (with single underscore prefix) attribute.
>>> class A: def __init__(self): self.x=10 self.__y=20 self._z=30
Its child class method can access protected attribute of the parent.
>>> class B(A): def disp(self): print ('protected member:',self._z)
The access to protected data outside the class is not expected to be done, but it's not illegal. You can still do so if you wish.
>>> b=B() >>> b._z 30 >>> b._z=50 >>> b._z 50
Hence it is left to the wisdom of responsible programmer expecting him to refrain from accessing 'protected' instance attribute from outside its class.