Python: Basic Inheritance

Basic Inheritance
Damian Gordon

Basic Inheritance
• We have mentioned before that software re-use is considered
one of the golden rules of object-orientated programming, and
that generally speaking we will prefer to eliminate duplicated
code whenever possible.
• One mechanism to achieve this is inheritance.

Basic Inheritance
• Technically all classes are a sub-class of a class called Object,
so they all inherit from that class.
• The class called Object doesn’t really have many attributes
or methods, but they give all other classes their structure.
• If a class doesn’t explicitly inherit from any other class it
implicitly inherits from Object.

Basic Inheritance
• We can explicitly call the Object class as follows:
class MySubClass(object):
pass
# End Class.

Basic Inheritance
• This is inheritance in action.
• We call the object class, the superclass, and the object that
inherits into, the subclass.
• Python is great, because all you need to do to inherit from a
superclass is to include that classes’ name in the calling classes’
declaration.

Basic Inheritance
• Now let’s look at an example in practice.
• Let’s say we have a simple address book program that keeps
track of names and e-mail addresses. We’ll call the class
Contact, and this class keeps the list of all contacts, and
initialises the names and addresses for new contacts:

Basic Inheritance
class Contact:
contacts_list = []
def _ _init_ _(self, name, email):
self.name = name
self.email = email
Contact.contacts_list.append(self)
# End Init
# End Class

Basic Inheritance
class Contact:
contacts_list = []
self.name = name
self.email = email
# End Init
# End Class
Because contacts_list is
declared here, there is only one
instance of this attribute , and it is
accessed as
Contacts.contact_list.

Basic Inheritance
class Contact:
contacts_list = []
self.name = name
self.email = email
# End Init
# End Class
Because contacts_list is
declared here, there is only one
instance of this attribute , and it is
accessed as
Contacts.contact_list.
Append the newly instantiated
Contact to the contacts_list.

Basic Inheritance
name
__init__( )
email
contacts_list[ ]

Basic Inheritance
• Now let’s say that the contact list is for our company, and some
of our contacts are suppliers and some others are other staff
members in the company.
• If we wanted to add an order method, so that we can order
supplies off our suppliers, we better do it in such a way as we
cannot try to accidently order supplies off other staff
members. Here’s how we do it:

Basic Inheritance
class Supplier(Contact):
def order(self, order):
print(“The order will send ”
“’{}’ order to ‘{}’”.format(order,self.name))
# End order.
# End Class

Basic Inheritance
# End order.
# End Class
Create a new class called Supplier,
that has all the methods and
attributes of the Contact class. Now
add a new method called order.

Basic Inheritance
# End order.
# End Class
Create a new class called Supplier,
that has all the methods and
attributes of the Contact class. Now
add a new method called order.
Print out what was ordered from what
supplier.

Basic Inheritance
name
__init__( )
email
contacts_list[ ]
order( )

Basic Inheritance
• Let’s run this, first we’ll declare some instances:
c1 = Contact("Tom StaffMember", "TomStaffMember@MyCompany.com")
c2 = Contact("Fred StaffMember", "FredStaffMember@MyCompany.com")
s1 = Supplier("Joe Supplier", "JoeSupplier@Supplies.com")
s2 = Supplier("John Supplier", "JohnSupplier@Supplies.com")

Basic Inheritance
• Now let’s check if that has been declared correctly:
print("Our Staff Members are:“, c1.name, " ", c2.name)
print("Their email addresses are:“, c1.email, " ", c2.email)
print("Our Suppliers are:“, s1.name, " ", s2.name)
print("Their email addresses are:“, s1.email, " ", s2.email)

Basic Inheritance
• We can order from suppliers:
s1.order("Bag of sweets")
s2.order("Boiled eggs")

Basic Inheritance
• We can order from suppliers:
The order will send our 'Bag of sweets' order to 'Joe Supplier'
The order will send our 'Boiled eggs' order to 'John Supplier'

Basic Inheritance
• But we can’t order from staff members (they don’t have the
contact method:
c1.order("Bag of sweets")
c2.order("Boiled eggs")

Basic Inheritance
• But we can’t order from staff members (they don’t have the
contact method:
c2.order("Boiled eggs")
Traceback (most recent call last):
File "C:/Users/damian.gordon/AppData/Local/Programs/Python/Python35-
32/Inheritance.py", line 64, in <module>
AttributeError: 'Contact' object has no attribute 'order'

name
__init__( )
email
contacts_list[ ]
name
__init__( )
email
contacts_list[ ]
order( )

Extending Built-Ins
• Let’s say we needed to add a new method that searches the
contacts_list for a particular name, where would we put
that method?
• It seems like something that might be better associated with
the list itself, so how would we do that?

Extending Built-Ins
class ContactList(list):
def search(self, name):
“Return any search hits”
matching_contacts = [ ]
for contact in self:
if name in contact.name:
matching_contacts.append(contact)
# Endif;
# Endfor;
return matching_contacts
# End Search
# End Class

Extending Built-Ins
# Endif;
# Endfor;
# End Search
# End Class
This is a new class that
builds on the list type.

Extending Built-Ins
# Endif;
# Endfor;
# End Search
# End Class
This is a new class that
builds on the list type.
Create a new list of
matching names.

Extending Built-Ins
class Contact(list):
contacts_list = ContactList()
self.name = name
self.email = email
self.contacts_list.append(self)
# End Init
# End Class

Extending Built-Ins
class Contact(list):
contacts_list = ContactList()
self.name = name
self.email = email
self.contacts_list.append(self)
# End Init
# End Class
Instead of declaring
contacts_list as a list we
declare it as a class that
inherits from list.

Extending Built-Ins
• Let’s run this, first we’ll declare some instances, and then do a
search:
c3 = Contact("Anne StaffMember", "AnneStaffMember@MyCompany.com")
SearchName = input("Who would you like to search for?n")
print([c.name for c in Contact.contacts_list.search(SearchName)])

Extending Built-Ins
• Let’s run this, first we’ll declare some instances, and then do a
search:
c3 = Contact("Anne StaffMember", "AnneStaffMember@MyCompany.com")
SearchName = input("Who would you like to search for?n")
print([c.name for c in Contact.contacts_list.search(SearchName)])
>>> Who would you like to search for?
Staff
['Tom StaffMember', 'Fred StaffMember', 'Anne StaffMember']

Overriding and super
• So inheritance is used to add new behaviours, but what if we
want to change behaviours?
• Let’s look at the Supplier class again, and we want to
change how the order method works.

• Here’s what we have so far:
print("The order will send our "
"'{}' order to '{}'".format(order,self.name))
# End order.
# End Class

• Here’s a new version:
class SupplierCheck(Supplier):
def order(self, order, balance):
if balance < 0:
# THEN
print("This customer is in debt.")
else:
# End order.
# End Class

if balance < 0:
# THEN
else:
# End order.
# End Class
The new class inherits from
the Supplier class. It is
therefore a subclass of it.

if balance < 0:
# THEN
else:
# End order.
# End Class
The new class inherits from
the Supplier class. It is
therefore a subclass of it.
And it overrides the order
method to now explore the
new balance attribute.

• We declare objects as follows:
s1 = Supplier("Joe Supplier", "JoeSupplier@Supplies.com")
s2 = Supplier("John Supplier", "JohnSupplier@Supplies.com")
s3 = SupplierCheck("Anne Supplier", "AnneSupplier@Supplies.com")
s4 = SupplierCheck("Mary Supplier", "MarySupplier@Supplies.com")

• And when we call the new order method:
s3.order("Coffee", 23)
s4.order("Corn Flakes", -12)

• And when we call the new order method:
s3.order("Coffee", 23)
s4.order("Corn Flakes", -12)
The order will send our 'Bag of sweets' order to 'Joe Supplier'
The order will send our 'Boiled eggs' order to 'John Supplier'
The order will send our 'Coffee' order to 'Anne Supplier'
This customer is in debt.

• The only problem with this approach is that the superclass and
the subclass both have similar code in them concerning the
order method.
• So if at some point in the future we have to change that
common part of the method, we have to remember to change
it in two places.
• It is better if we can just have the similar code in one place.

• We can do this using the super( ) class.
• The super( ) class calls the superclass method from the
subclass.
• Let’s look at how we had it:

• Here’s overridng:
if balance < 0:
# THEN
else:
# End order.
# End Class

• Here’s super:
if balance < 0:
# THEN
else:
super().order(order)
# End order.
# End Class

• Here’s super:
if balance < 0:
# THEN
else:
super().order(order)
# End order.
# End Class
Call the order method in the
superclass of
SupplierCheck, so call
Supplier.order(order).

Python: Basic Inheritance

Recommended

More Related Content

What's hot (20)

Viewers also liked (12)

Similar to Python: Basic Inheritance (20)

More from Damian T. Gordon (20)

Recently uploaded (20)

Python: Basic Inheritance