Python Programming - VIII. Inheritance and Polymorphism

VIII. INHERITANCE AND POLYMORPHISM

PYTHON PROGRAMMING

Engr. RANEL O. PADON

PYTHON PROGRAMMING TOPICS
I

•Introduction to Python Programming

II

•Python Basics

III

•Controlling the Program Flow

IV

•Program Components: Functions, Classes, Packages, and Modules

V

•Sequences (List and Tuples), and Dictionaries

VI

•Object-Based Programming: Classes and Objects

VII

•Customizing Classes and Operator Overloading

VIII

•Object-Oriented Programming: Inheritance and Polymorphism

IX

•Randomization Algorithms

X

•Exception Handling and Assertions

XI

•String Manipulation and Regular Expressions

XII

•File Handling and Processing

XIII

•GUI Programming Using Tkinter

INHERITANCE Background

Object-Based Programming
 programming using objects

Object-Oriented Programming
 programming using objects & hierarchies

A family of classes is known as a class hierarchy.
As in a biological family, there are parent classes and child
classes.


 the parent class is usually called base class or superclass
 the child class is known as a derived class or subclass

Child classes can inherit data and methods from parent
classes, they can modify these data and methods, and they can
add their own data and methods.
The original class is still available and the separate child class is
small, since it does not need to repeat the code in the parent
class.


The magic of object-oriented programming is that other parts of
the code do not need to distinguish whether an object is the
parent or the child – all generations in a family tree can be
treated as a uniﬁed object.


In other words, one piece of code can work with all members
in a class family or hierarchy. This principle has revolutionized
the development of large computer systems.

INHERITANCE Reusing Attributes

INHERITANCE The Media Hierarchy

INHERITANCE Base and Derived Classes

INHERITANCE The CommunityMember Base Class

INHERITANCE The Shape Hierarchy

INHERITANCE Sample Implementation 1

Magulang

Anak

INHERITANCE Magulang Base Class

class Magulang:
def __init__(self, pangalan, kayamanan):
self.pangalan = pangalan
self.kayamanan = kayamanan

INHERITANCE Anak Derived Class

class Magulang:

class Anak(Magulang):
def __init__(self, pangalan = "Juan Tamad", kayamanan = 1000000):
Magulang.__init__(self, pangalan, kayamanan)

INHERITANCE Sample Execution
class Magulang:


gorio = Anak("Mang Gorio", 1000000)
print gorio.pangalan
print gorio.kayamanan

INHERITANCE Anak with Default Args

class Magulang:

print Anak().pangalan
print Anak().kayamanan

INHERITANCE Magulang with instance method
class Magulang:

def getKayamanan(self):
return self.kayamanan

print Anak().pangalan
print Anak().getKayamanan()

INHERITANCE Sample Implementation 2

Rectangle

Square

INHERITANCE Rectangle Base Class

class Rectangle():
def __init__(self, lapad, haba):
self.lapad = lapad
self.haba = haba
def getArea(self):
return self.lapad*self.haba

INHERITANCE Square Derived Class
class Rectangle():
self.lapad = lapad
self.haba = haba
def getArea(self):

class Square(Rectangle):
def __init__(self, lapad):
Rectangle.__init__(self, lapad, lapad)
def getArea(self):
return self.lapad**2

INHERITANCE Sample Execution
class Rectangle():
self.lapad = lapad
self.haba = haba

def getArea(self):
class Square(Rectangle):
def __init__(self, lapad):
Rectangle.__init__(self, lapad, lapad)
def getArea(self):
return self.lapad**2
print Square(3).getArea()

INHERITANCE Deadly Diamond of Death
What would be the version of bite() that will be used by Hybrid?
Dark Side
Forces
Villains
attack()

Vampire
Vampire
bite()

Werewolf
bite()

Hybrid

INHERITANCE Deadly Diamond of Death

Dark Side
Forces
Villains
attack()

Vampire
Vampire
bite()

Python allow a limited form of multiple
inheritance hence care must be
observed to avoid name collisions or
ambiguity.
Werewolf

bite()

Hybrid

Other languages, like Java, do not allow
multiple inheritance.

INHERITANCE Polymorphism
Polymorphism is a consequence of inheritance. It is concept
wherein a name may denote instances of many different classes as
long as they are related by some common superclass.
It is the ability of one object, to appear as and be used like another
object.
In real life, a male person could behave polymorphically:
he could be a teacher, father, husband, son, etc depending on the
context of the situation or the persons he is interacting with.

Polymorphism is also applicable to systems with same base/core
components or systems interacting via unified interfaces.
 USB plug and play devices
 “.exe” files

 Linux kernel as used in various distributions
(Ubuntu, Fedora, Mint, Arch)
 Linux filesystems (in Linux everything is a file)
The beauty of it is that you could make small code changes
but it could be utilized by all objects inheriting or
interacting with it.


Hugis

Tatsulok

Bilog


class Hugis():
def __init__(self, pangalan):

class Hugis():
class Tatsulok(Hugis):
def __init__(self, pangalan, pundasyon, taas):
Hugis.__init__(self, pangalan)
self.pundasyon = pundasyon
self.taas = taas
def getArea(self):
return 0.5*self.pundasyon*self.taas
print Tatsulok("Tatsulok sa Talipapa", 3, 4).getArea()

class Hugis():
class Bilog(Hugis):
def __init__(self, pangalan, radyus):
Hugis.__init__(self, pangalan)
self.radyus = radyus
def getArea(self):
return 3.1416*self.radyus**2
print Bilog("Bilugang Mundo", 2).getArea()

class Hugis():

class Tatsulok(Hugis):
def __init__(self, pangalan, pundasyon, taas):
def getArea(self):
class Bilog(Hugis):
def __init__(self, pangalan, radyus):
def getArea(self):
koleksyonNgHugis = []
koleksyonNgHugis += [Tatsulok("Tatsulok sa Talipapa", 3, 4)]
koleksyonNgHugis += [Bilog("Bilugang Mundo", 2)]
for i in range(len(koleksyonNgHugis)):
print koleksyonNgHugis[i].getArea()

POLYMORPHISM

Polymorphism is not the same as method overloading or
method overriding.
Polymorphism is only concerned with the application of
specific implementations to an interface or a more generic
base class.
Method overloading refers to methods that have the same
name but different signatures inside the same class.
Method overriding is where a subclass replaces the
implementation of one or more of its parent's methods.
Neither method overloading nor method overriding are by
themselves implementations of polymorphism.
http://www.princeton.edu/~achaney/tmve/wiki100k/docs/Polymorphism_in_object-oriented_programming.html

INHERITANCE Abstract Class

 there are cases in which we define classes but we don’t
want to create any objects
 they are merely used as a base or model class
 abstract base classes are too generic to define real objects,
that is, they are abstract or no physical manifestation (it’s
like the idea of knowing how a dog looks like but not
knowing how an ‘animal’ looks like, and in this case,
‘animal’ is an abstract concept)


 Abstract class is a powerful idea since you only have to
communicate with the parent (abstract class), and all
classes implementing that parent class will follow
accordingly. It’s also related to the Polymorphism.


 ‘Shape’ is an abstract class. We don’t know how a ‘shape’
looks like, but we know that at a minimum it must have a
dimension or descriptor (name, length, width, height, radius,
color, rotation, etc). And these descriptors could be reused
or extended by its children.


 Abstract classes lay down the foundation/framework on
which their children could further extend.

INHERITANCE The Gaming Metaphor

Gameplay

MgaTauhan
KamponNgKadiliman

Manananggal

HalimawSaBanga

…

Menu Options

…

Maps

Tagapagligtas

Panday

MangJose

Abstract Classes
MgaTauhan

KamponNgKadiliman

Manananggal

HalimawSaBanga

Tagapagligtas

Panday

MangJose

class MgaTauhan():
def __init__(self, pangalan, buhay):
if self.__class__ == MgaTauhan:
raise NotImplementedError, "abstract class po ito!"
self.buhay = buhay
def draw(self):
raise NotImplementedError, "kelangang i-draw ito"

class KamponNgKadiliman(MgaTauhan):
bilang = 0
MgaTauhan.__init__(self, pangalan, 50)
if self.__class__ == KamponNgKadiliman:
raise NotImplementedError, "abstract class lang po ito!"
KamponNgKadiliman.bilang += 1

def attack(self):
return 5
def __del__(self):
KamponNgKadiliman.bilang -= 1
self.isOutNumbered()
def isOutNumbered(self):
if KamponNgKadiliman.bilang == 1:
print “umatras ang mga HungHang"

class Tagapagligtas(MgaTauhan):
bilang = 0
MgaTauhan.__init__(self, pangalan, 100)
if self.__class__ == Tagapagligtas:
raise NotImplementedError, "abstract class lang po ito!"
Tagapagligtas.bilang += 1

def attack(self):
return 10
def __del__(self):
Tagapagligtas.bilang -= 1
self.isOutNumbered()
def isOutNumbered(self):
if Tagapagligtas.bilang == 1:
“umatras ang ating Tagapagligtas"

class Manananggal(KamponNgKadiliman):
KamponNgKadiliman.__init__(self, pangalan)
def draw(self):
return "loading Mananaggal.jpg.."

def kapangyarihan(self):
return "mystical na dila"

class HalimawSaBanga(KamponNgKadiliman):
KamponNgKadiliman.__init__(self, pangalan)
def draw(self):
return "loading HalimawSaBanga.jpg.."

return "kagat at heavy-armored na banga"

class Panday(Tagapagligtas):
Tagapagligtas.__init__(self, pangalan)

def draw(self):
return "loading Panday.jpg.."
return "titanium na espada, galvanized pa!"

class MangJose(Tagapagligtas):
Tagapagligtas.__init__(self, pangalan)
def draw(self):
return "loading MangJose.jpg.."

return "CD-R King gadgets"

creatures
creatures
creatures
creatures
creatures
creatures

= []
+= [Manananggal("Taga-Caloocan")]
+= [HalimawSaBanga("Taga-Siquijor")]
+= [MangJose("Taga-KrusNaLigas")]
+= [MangJose("Taga-Cotabato")]
+= [Panday("Taga-Cubao Ilalim")]

for i in range(len(creatures)):
print creatures[i].draw()

print KamponNgKadiliman.bilang
print Tagapagligtas.bilang
del creatures[0]

loading Manananggal.jpg..
loading HalimawSaBanga.jpg..
loading MangJose.jpg..
loading MangJose.jpg..
loading Panday.jpg..
2
3
atras ang mga Hunghang!

This simple line is so powerful,
since it makes the current Creature
draw itself regardless of what
Creature it is!

INHERITANCE Flexibility and Power

Re-use, Improve, Extend

REFERENCES

 Deitel, Deitel, Liperi, and Wiedermann - Python: How to Program (2001).

 Disclaimer: Most of the images/information used here have no proper source citation, and I do
not claim ownership of these either. I don’t want to reinvent the wheel, and I just want to reuse
and reintegrate materials that I think are useful or cool, then present them in another light,
form, or perspective. Moreover, the images/information here are mainly used for
illustration/educational purposes only, in the spirit of openness of data, spreading light, and
empowering people with knowledge. 

Python Programming - VIII. Inheritance and Polymorphism

Recommended

More Related Content

What's hot (20)

Viewers also liked (11)

Similar to Python Programming - VIII. Inheritance and Polymorphism (20)

More from Ranel Padon (9)

Recently uploaded (20)

Python Programming - VIII. Inheritance and Polymorphism