Introduction to Python

davidbpython.com

Inheritance and Polymorphism

inheritance

Child classes inherit attributes from Parent classes.

class Parent:
    parv = 500

class Child(Parent):           # Child inherits from Parent
    chi_val = 1

    def __init__(self, iv):
        self.iv = iv


c = Child(88)

print(c.iv)           # 88     (retrieved from instance)

print(c.chi_val)      # 1      (retrieved from the Child class)

print(c.parv)         # 500    (retrieved from the Parent class)

• first, note that the Child class definition has Parent in its parentheses: Child inherits from Parent
• next, notice that in each of the three print() statements we are accessing an attribute from a different place
• attribute lookup looks first in the instance, then in the class, then in any parent classes
• class variables defined in a parent class are accessible to any child class or instances of a child class
• (these classes do not need to be named Parent and Child - they can have any names)

inheritance allows us to divide behavior into general, then specific

General behaviors can go in the parent, and more specific in the children.

class Animal:
    def __init__(self, name):
        self.name = name
    def eat(self, food):
        print(f'{self.name} eats the {food}.')

class Dog(Animal):
    def fetch(self, thing):
        print('{self.name} brings back the {thing}!')

class Cat(Animal):
    pass                 # means empty block

d = Dog('Rover')
c = Cat('Fluffly')

d.eat('dog food')        # Rover eats the dog food.
c.eat('cat food')        # Flffy eats the cat food.

d.fetch('stick')         # Rover brings back the stick!

• note that both Dog and Cat inherit from Animal
• through inheritance, both Dog and Cat can call Animal.eat()
• however Dog is also able to call .fetch(), as this is specific to Dog

methods may be specialized in an inheriting class

Child class behavior can build upon the general behavior in the parent.

class Animal:
    def __init__(self, name):
        self.name = name
    def eat(self, food):
        print(f'{self.name} eats {food}.')

class Dog(Animal):
    pass

class Cat(Animal):
    def eat(self, food):
        if food != 'sushi':
            print('snif - snif - nah!')
        else:
            super().eat(food)        # calls Animal.eat()

d = Dog('Rover')
c = Cat('Fluffly')

d.eat('dog food')        # Rover eats the dog food.
c.eat('cat food')        # snif - snif - nah!
c.eat('sushi')           # Fluffy eats the sushi.

• here we see that child class Cat has its own way of eating (it first checks to see whether the food is desirable, then eats)
• if approed, it eats by calling Animal.eat()
• the super() function fetches the parent class so methods can be called there without actually naming the parent

conceptually similar methods can be unified through polymorphism

Same-named methods in two different classes can share a conceptual similarity.

class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def speak(self):
        print(f'{self.name}:  Bark! Bark!')

class Cat(Animal):
    def speak(self):
        print(f'{self.name}:  Meow!')


pet_list = [Dog('Rover'), Cat('Fluffy'), Cat('Precious'), Dog('Rex')]

for pet in pet_list:
    pet.speak()

                   # Rover:  Bark!  Bark!
                   # Fluffy:  Meow!
                   # Precious:  Meow!
                   # Rex:  Bark!  Bark!

• "polymorphism" means "many shapes"
• this refers to an arrangement in which different class instances do different things, but using the same named method
• if we group similar behaviors under the same method name, it doesn't matter which Animal we're working with, and so we don't have to check
• we can simply get instances of any class that inherits from Animal, and call the same method on each one
• we can do this, confident that the instance will do the right thing

Study Glossary for OOP, Part II

These are OOP terms we introduced in this session.