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.

class Tax:
  def calc_tax(self):
    print('Calculating tax')

class ContractTax(Tax):
  def calc_tax(self):
    print('Calculating contract tax')

class ContractTaxDE(ContractTax):
  def calc_tax():
    print('Calculating German contract tax')

my_tax = ContractTaxDE()
my_tax.calc_tax()

class Tax:
  def calc_tax(self):
    print('Calculating tax')
    total = 0 # To replace with calculation
    return total

class ContractTax:
  def calc_tax(self):
    print('Calculating contract tax')
    total = 0 # To replace with calculation
    return total

my_tax = ContractTax()
my_tax.calc_tax()

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__().

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.

    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()

    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.

    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}")

    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.

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

    4
    3

class Polygon:
  def print_type(self):
    print("Polygon type")

class Rectangle(Polygon):
  def print_type(self):
    print("Rectangle type")

class Square(Rectangle):
  def print_type(self):
    print("Square type")

sq_1 = Square()
sq_1.print_type()