Object-Oriented Programming in
Python: inheritance
● The four major principles of object orientation are:
○ Encapsulation
○ Inheritance
○ Data Abstraction
○ Polymorphism
● Inheritance is a powerful feature in object oriented programming
● It refers to defining a new class with little or no modification to an existing
class.
● The new class is called derived (or child) class and the one from which it
inherits is called the base (or parent) class.
● Derived class inherits features from the base class, adding new features to it.
● This results into re-usability of code.
class BaseClassName:
pass
class DerivedClassName(BaseClassName):
pass
class Robot:
def init (self, name):
[Link] = name
def say_hi(self):
print("Hi, I am " + [Link])
class PhysicianRobot(Robot):
pass
x = Robot("Marvin")
y = PhysicianRobot("James")
print(x, type(x))
print(y, type(y))
y.say_hi()
class Robot:
def init (self, name):
[Link] = name
def say_hi(self):
print("Hi, I am " + [Link])
class PhysicianRobot(Robot):
pass
x = Robot("Marvin")
y = PhysicianRobot("James")
print(x, type(x))
print(y, type(y))
y.say_hi()
class Robot:
def init (self, name):
[Link] = name
def say_hi(self):
print("Hi, I am " + [Link])
class PhysicianRobot(Robot):
pass
x = Robot("Marvin")
y = PhysicianRobot("James")
print(x, type(x))
print(y, type(y))
y.say_hi()
class Robot:
def init (self, name):
[Link] = name
def say_hi(self):
print("Hi, I am " + [Link])
class PhysicianRobot(Robot):
pass
x = Robot("Marvin")
y = PhysicianRobot("James")
print(x, type(x))
print(y, type(y))
y.say_hi()
● People frequently ask where the difference between checking the type via
the type function or the function isinstance is located.
● Clarification:
● the type function returns the class type of the argument(object) passed
as parameter.
● the isinstance function returns a boolean value (i.e. True or False) after
checking that the first argument passed as actual parameter is an object
typed with class corresponding to the second argument passed as actual
parameter
x = Robot("Marvin")
y = PhysicianRobot("James")
print(isinstance(x, Robot), isinstance(y, Robot))
print(isinstance(x, PhysicianRobot))
print(isinstance(y, PhysicianRobot))
print(type(y), type(y) == PhysicianRobot)
x = Robot("Marvin")
y = PhysicianRobot("James")
print(isinstance(x, Robot), isinstance(y, Robot))
print(isinstance(x, PhysicianRobot))
print(isinstance(y, PhysicianRobot))
print(type(y), type(y) == PhysicianRobot)
True True
False
True
<class ' main .PhysicianRobot'> True
Question on inheritance
class A:
pass
class B(A):
pass
class C(B):
pass
x = C()
print(isinstance(x, A))
class A:
pass
class B(A):
pass
class C(B):
pass
x = C()
print(isinstance(x, A))
True
● Overriding is OOP feature that allows a subclass or child class to provide a
specific implementation of a method that is already provided by one of
its superclasses or parent classes.
● The implementation in the subclass overrides (replaces) the implementation
in the superclass by providing a method that has same name,
same parameters or signature, and same return type as the method in the
parent class.
● The version of a method that is executed will be determined by the object that
is used to invoke it.
class Robot:
def init (self, name):
[Link] = name
def say_hi(self):
print("Hi, I am " + [Link])
class PhysicianRobot(Robot):
def say_hi(self):
print("Everything will be okay! ")
print([Link] + " takes care of you!")
y = PhysicianRobot("James")
y.say_hi()
class Robot:
def init (self, name):
[Link] = name
def say_hi(self):
print("Hi, I am " + [Link])
class PhysicianRobot(Robot):
def say_hi(self):
print("Everything will be okay! ")
print([Link] + " takes care of you!")
y = PhysicianRobot("James")
y.say_hi()
Everything will be okay!
James takes care of you!
● Question: can we access the original method defined in a superclass from
one of its derived class that overrides such a method?
● Question: can we access the original method defined in a superclass from
one of its derived class that overrides such a method?
● Answer: Yes, if a method is overridden in a class, the original method can
still be accessed.
● Question: can we access the original method defined in a superclass from
one of its derived class that overrides such a method?
● Answer: Yes, if a method is overridden in a class, the original method can
still be accessed.
● How: The original method defined in a superclass can be accessed from the
derived class by calling the method directly with the class name,
e.g. Robot.say_hi(y).
y = PhysicianRobot("Doc James")
y.say_hi()
print("... and now the 'traditional' robot way of saying hi :-)")
Robot.say_hi(y)
y = PhysicianRobot("Doc James")
y.say_hi()
print("... and now the 'traditional' robot way of saying hi :-)")
Robot.say_hi(y)
Everything will be okay!
Doc James takes care of you!
... and now the 'traditional' robot way of saying hi :-)
Hi, I am Doc James
● Question: can we access the original method defined in a superclass from
one of its derived class that overrides such a method?
● Question: can we access the original method defined in a superclass from
one of its derived class that overrides such a method?
● Answer: Yes, if a method is overridden in a class, the original method can
still be accessed.
● Question: can we access the original method defined in a superclass from
one of its derived class that overrides such a method?
● Answer: Yes, if a method is overridden in a class, the original method can
still be accessed.
● How: The original method defined in a superclass can be accessed from the
derived class by calling the method directly with the class name,
e.g. Robot.say_hi(y).
Overwriting, Overloading and Overriding
● Overwriting is the process of replacing old information with new information
● If we overwrite a function, the original function will be gone. The function will
be redefined.
● This process has nothing to do with object orientation or inheritance.
● Overwriting is the process of replacing old information with new information
● If we overwrite a function, the original function will be gone. The function will
be redefined.
● This process has nothing to do with object orientation or inheritance.
def f(x):
return x + 42
print(f(3))
# f will be overwritten (or redefined) in the following:
def f(x):
return x + 43
print(f(3))
● Overloading is the ability to define a function with the same name multiple
times.
● The definitions are different concerning the number of parameters and types of
the parameters.
● It's the ability of one function to perform different tasks, depending on the
number of parameters or the types of the parameters.
● We cannot overload functions like this in Python, but it is not necessary neither.
● OOP languages like Java or C++ implement overloading.
● We have covered inheritance, or more specific "single inheritance". As
we have seen, a class inherits in this case from one class.
● Multiple inheritance on the other hand is a feature in which a class can inherit
attributes and methods from more than one parent class.
● The critics point out that multiple inheritance comes along with a high level of
complexity and ambiguity in situations such as the diamond problem
class Robot:
def init (self, name):
[Link] = name
def say_hi(self):
print("Hi, I am " + [Link])
class Pysician:
def init (self, specialization):
[Link] = specialization
def print_specialization(self):
print("My specialization is " + [Link])
class PhysicianRobot(Robot, Pysician):
def init (self, name, specialization):
Robot. init (self, name)
Pysician. init (self, specialization)
def say_hi(self):
print("Everything will be okay! ")
print([Link] + " takes care of you!")
y = PhysicianRobot("James", "Cardiovascular medicine")
y.say_hi()
y.print_specialization()
Everything will be okay!
James takes care of you!
My specialization is Cardiovascular medicine
● The "diamond problem" (sometimes referred to as the "deadly diamond of
death") is the generally used term for an ambiguity that arises when two
classes B and C inherit from a superclass A, and another class D inherits
from both B and C.
● If there is a method "m" in A that B or C (or even both of them) )has
overridden, and furthermore, if does not override this method, then the
question is which version of the method does D inherit?
class A:
def m(self):
print("m of A called")
class B(A):
def m(self):
print("m of B called")
class C(A):
def m(self):
print("m of C called")
class D(B,C):
pass