Week 10 [Mon, Mar 20th] - Programming Topics

• Object-Oriented Programing - Part III
  • Inheritance
• Unit Testing

Inheritance

You can make a class from another class. If you do, it is as if the already has all the attributes and methods of the .

Syntax:

class ChildClassName(ParentClassName):
  # statements of the class

    

    


    
    

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

  def print_info(self):
    print('My name is', self.name)

amy = Person('Amy')
amy.print_info()

    

    


    
    

My name is Amy

    

    


    
    

class Teacher(Person):

  def teach(self):
    print(self.name, 'is teaching')

dan = Teacher('Dan')
dan.print_info()
dan.teach()
print('the name is', dan.name)

    

    


    
    

My name is Dan
Dan is teaching
the name is Dan

    

    


    
    

class Animal:
  def __init__(self, name):
    self.name = name
    
  def info(self):
    print("I'm a", self.name)
    
# ADD YOUR CODE HERE
    
tuna = Fish('Tuna')
tuna.info()
tuna.move()
guppy = Fish('Guppy')
guppy.info()
guppy.move()

    

    


    
    

I'm a Tuna
I'm swimming
I'm a Guppy
I'm swimming

    

    


    
    

A child class can override a method defined in the parent class. That way, a child object can change a behavior defined in the parent class.

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

  def print_info(self):
    print(self.name, 'is a person')

    

    


    
    

adam = Person('Adam')
adam.print_info()
ben = Student('Ben')
ben.print_info()

    

    


    
    

class Student(Person):

  def print_info(self):
    print(self.name, 'is a student')

    

    


    
    

Adam is a person
Ben is a student

    

    


    
    

When overriding methods, you can reuse the parent's definition of the same method using the super(). prefix.

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

    

    


    
    

class Student(Person):
  def __init__(self, name, matric):
    self.name = name
    self.matric = matric

    

    


    
    

class Student(Person):
  def __init__(self, name, matric):
    super().__init__(name) # reuse parent's method
    self.matric = matric

    

    


    
    

class Animal:

  def __init__(self, name):
    self.name = name
    
  def info(self):
    print("I'm a", self.name)
    

class Bird(Animal):

  def move(self):
    print("I'm flying")
    
  def info(self):
    # CALL info() METHOD OF PARENT CLASS HERE 
    print("I have feathers")

# ADD FlightlessBird CLASS HERE

crow = Bird('Crow')
crow.info()
crow.move()
penguin = FlightlessBird('Penguin')
penguin.info()
penguin.move()

    

    


    
    

I'm a Crow
I have feathers
I'm flying
I'm a Penguin
I have feathers
I'm waddling

    

    


    
    

Note that all python classes automatically inherits from the built-in class object even if you did not specify it as the parent class. The object class has a __str__() method that you can ovrride in your classes to customize how the print function will print an object of your class.

class Book:
  def __init__(self, title):
    self.title = title

  def __str__(self):
    return 'Book title: ' + self.title

book = Book('Python for Beginners')
print(book)

    

    


    
    

Book title: Python for Beginners

    

    


    
    

class Person:
  
  def __init__(self, name, age):
    self.name = name
    self.age = age
  
  # OVERRIDE __str__ METHOD HERE
    
print(Person('Amy', 25))
print(Person('Ben', 26))

    

    


    
    

Amy (25years)
Ben (26years)

    

    


    
    

A class can inherit from multiple classes. If multiple parent classes have the same method, the one that is given first (in the order of inheritance) will be used.

elsie = TeachingAssistant('Elsie', 'A223344')
elsie.print_info()
elsie.teach()
elsie.learn()
elsie.grade()

    

    


    
    

Elsie is a teacher
Elsie is teaching
Elsie is learning
Elsie is grading

    

    


    
    

class Camera:
  
  def take_photo(self):
    print('taking photo')
    
class Phone:
  
  def make_call(self):
    print('making call')
    
# ADD SmartPhone CLASS HERE

iphone = SmartPhone('iPhone')
iphone.take_photo()
iphone.make_call()
iphone.play_game()

    

    


    
    

My model: iPhone
taking photo
making call
playing game

    

    


    
    

You need to use inheritance when you create user-defined exceptions because all such exceptions need to inherit from a built-in Exception class.

class EmptyCommandError(Exception):
    """Indicates a task has expired."""
    pass


class InvalidCommandError(Exception):
    """Indicates that the user entered an invalid command"""

    def __init__(self, command, explanation):
        self.command = command
        self.explanation = explanation


def execute_command(command):
    if command == '':
        raise EmptyCommandError()
    elif len(command) < 4:
        raise InvalidCommandError(command, "command too short")


def process(command):
    try:
        execute_command(command)
    except EmptyCommandError:
        print('empty command')
    except InvalidCommandError as e:
        print('invalid command:', e.command, '->', e.explanation)


process('')
process('HA')

    

    


    
    

empty command
invalid command: HA -> command too short

    

    


    
    

Appendix D: Unit Testing

The built-in module unittest supports automation of unit testing in an object-oriented way.

Let's assume you have a file called search.py which has the following two functions.

def get_first_name(name):
  """Return the first part of the parameter 'name'"""
  return name.split()[0]


def is_same_person(person, keyword):
  """Return True if the parameter 'person' (type: dictionary)
  contains a key 'name' whose value contains the 
  parameter 'keyword' (type: string)
  e.g., 
  * is_same_person({'name': 'jackie'}, 'jack') returns True
  * is_same_person({'name': 'jackie'}, 'jackie-chan') returns False
  """
  return keyword in person['name']

    

    


    
    

This is how we can write some unit tests for the two functions.

import search, unittest

class TestSearch(unittest.TestCase):

  def test_is_same_person(self):
    jack = {'name':'jack'}
    self.assertTrue(search.is_same_person(jack, 'jack'))
    self.assertTrue(search.is_same_person(jack, 'ack'))
    self.assertTrue(search.is_same_person(jack, 'ac'))
    self.assertTrue(search.is_same_person(jack, 'j'))
    self.assertTrue(search.is_same_person(jack, 'k'))
    self.assertFalse(search.is_same_person(jack, 'jackie'))
    self.assertFalse(search.is_same_person(jack, 'blackjack'))
    self.assertFalse(search.is_same_person({'name': 'x', 'other': 'jack'}, 'jack'))
    with self.assertRaises(KeyError):
      search.is_same_person({}, 'jack')
  
  def test_get_first_name(self):
    self.assertEqual(search.get_first_name('Amy'), 'Amy')
    self.assertEqual(search.get_first_name('Amy Bernice'), 'Amy')
    self.assertEqual(search.get_first_name('Amy-Bernice'), 'Amy-Bernice')
    with self.assertRaises(IndexError):
      search.get_first_name('')

# activate the test runner
if __name__ == '__main__':
    unittest.main()

    

    


    
    

When you run the above code, each method in the test class will be executed by a built-in test runner and the result will be reported. An example is given below:

...
----------------------------------------------------------------------
Ran 2 tests in 0.019s

OK

    

    


    
    

Things to note:

• A class containing unit tests should inherit from unittest.TestCase
• Names of functions containing test code should start with test e.g., test_is_same_person()
• These methods (inherited from the parent class) can be used to compare actual with the expected value:
  • assertTrue(actual) : test passes if actual == True
  • assertFalse(actual) : test passes if actual == False
  • assertEquals(actual, expected) : test passes if actual == expected
  • with self.assertRaises(Exception): passes if the code block it contains raises the specified exception.

If the expected value is not as same as the actual, the test runner will report the test failure. For example, if we were to insert this statement into test_get_first_name method,

self.assertEqual(search.get_first_name('Amy Foo'), 'Foo')

    

    


    
    

the output will be something like this:

F.
======================================================================
FAIL: test_get_first_name (__main__.TestSearch)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 19, in test_get_first_name
    self.assertEqual(search.get_first_name('Amy Foo'), 'Foo')
AssertionError: 'Amy' != 'Foo'
- Amy
+ Foo


----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

    

    


    
    

📎 Resources:

• More on unit testing: https://docs.python.org/3/library/unittest.html
• Unit testing in the PyCharm IDE: https://www.youtube.com/watch?v=-VzJvNLooj4