13.3 Methods

Learning objectives

By the end of this section you should be able to

Write overridden methods to change behavior of inherited methods.
Use super to access superclass methods.
Identify applications of polymorphism in method and function use.

Overriding methods

Sometimes a programmer wants to change the functions a subclass inherits. Mint is a subclass that has the same functionality as Plant, except for one function. A subclass can override a superclass method by defining a method with the same name as the superclass method.

super

super is a special method that provides a temporary superclass object instance for a subclass to use. super is commonly used to call superclass methods from a subclass. super is commonly used in a subclass's __init__ to assign inherited instance attributes. Ex: super.__init__.

Note

Using super

Consider the following program.

class Polygon:
  def __init__(self, num_sides=3):
    self.num_sides = num_sides

class Rectangle(Polygon):
  def __init__(self, ln=1, wd=1):
    super().__init__(4)
    self.length = ln
    self.width = wd

class Square(Rectangle):
  def __init__(self, side=1):
    super().__init__(side, side)
    self.side = side

sq_1 = Square(5)
print(sq_1.num_sides)

Polymorphism

Polymorphism is the concept of having many forms. In programming, a single name can be used for multiple functionalities. Within inheritance, polymorphism is the basis of method overriding, as multiple methods have the same name.

Example 1 Polymorphism and inheritance

The name display maps to multiple methods. The class type of the calling object determines which display method is executed.

class Plant:
  def display(self):
    print("I'm a plant")

class Mint(Plant):
  def display(self):
    print("I'm a mint")

class Lavender(Mint):
  def display(self):
    print("I'm a lavender")

mint_1 = Mint()
mint_1.display()

lavender_1 = Lavender()
lavender_1.display()

The code's output is:


    I'm a mint
    I'm a lavender

Polymorphism can also be used with methods of unrelated classes. The class type of the calling object determines the method executed.

Example 2 Polymorphism and methods

Tax and ContractTax are unrelated classes that each define calc_tax. calc_tax isn't overridden as ContractTax isn't inherited from Tax.

class Tax:
  def __init__(self, value):
    self.value = value

  def calc_tax(self):
    print("Calculating tax")
    total = 0.10 * self.value  # To replace with calculation
    return total

class ContractTax:
  def __init__(self, value):
    self.value = value

  def calc_tax(self):
      print("Calculating contracts tax")
      total = 0.15 * self.value  # To replace with calculation
      return total

my_tax = ContractTax(value=1000)  # Replace 1000 with any value
result = my_tax.calc_tax()
print(f"Total tax: ${result}")

The code's output is:


    Calculating contracts tax
    Total tax: $150.00

Polymorphism allows methods to be called with different parameter types. Many built-in operators and functions have this utility.

Example 3 Polymorphism and functions

len can be called with multiple types, including lists and strings.

tree_list = ["ash", "hazel", "oak", "yew"]
tree_1 = tree_list[0]
print(len(tree_list))
print(len(tree_1))

The code's output is:


    4
    3

Note

Overriding methods

Given the Pet class, create a Bird class inherited from Pet and a Finch class inherited from Bird. Override the display method in Bird and Finch such that the program output is:


    Pet type: Bird
    Bird type: Finch

class Pet():
    def display(self):
        print("Clinic patient: Pet")

# Define Bird class

# Define Finch class

bird_1 = Bird()
bird_1.display()
finch_1 = Finch()
finch_1.display()

Note

Using super

Given the Employee class, create a Developer class inherited from Employee with methods __init__ and print_info such that:

__init__

Uses super to call Employee's __init__ to initialize e_id and hire_year.
Assigns lang_xp with list parameter lang_xp.

print_info

Uses super to print e_id and hire_year.
Prints "Language(s):" followed by lang_xp.

class Employee():
    count = 0    
    def __init__(self):
        Employee.count += 1
        self.e_id = Employee.count
        self.hire_year = 2023

    def print_info(self):
        print("Employee", self.e_id, "was hired in", self.hire_year)

# Define Developer class

python_dev = Developer()
python_dev.print_info()