Course Curriculum

Where we are in the journey

• 0. Introduction to the course
• 1. Classes vs. Objects
• 2. Encapsulation & Access Control
• 3. Inheritance
• 4. Polymorphism & PEP 8
• 5. Composition & Aggregation
• 6. Exception Handling & Logging
• 7. SOLID Principles
• 8. UML & Design Patterns
• 9. Design Patterns (2nd part)
• 10. Testing & TDD
• 11. Libraries & Frameworks
• 12. Recap & Consultation

The self Parameter

A way for an object to refer to itself

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

    def compare_age(self, other):
        if self.age > other.age:
            print(f"{self.name} is older")

person1 = Person("Alice", 30)
person2 = Person("Bob", 25)
person1.compare_age(person2)
# Alice is older

Recap: Lecture 02

Access Control

self.engine_status = "Off"

def start_engine(self):
    self.engine_status = "On"

self._fuel_level = 50

def _check_fuel(self):
    return self._fuel_level > 0

self.__owner = "John"

def __display_owner(self):
    print(self.__owner)

Recap: Lecture 02

Encapsulation: Getters & Setters

class BankAccount:
    def __init__(self, balance):
        self._balance = balance

    def get_balance(self):
        return self._balance

    def deposit(self, amount):
        if amount > 0:
            self._balance += amount

Recap: Lecture 03

How super() Works

Call super() to access the superclass's methods that have been overridden

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

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

Recap: Lecture 03

Method Resolution Order (MRO)

print(C.mro())
# [C, B, A, object]

The 4 Characteristics of OOP

Agenda for Today

Understanding Polymorphism

Why Polymorphism Matters

Polymorphism You Already Use

Python's built-in functions are polymorphic!

len("Hello")       # 5
len([1, 2, 3])    # 3
len({"a": 1})      # 1

5 + 3              # 8 (addition)
"Hi" + " there"    # "Hi there" (concat)
[1] + [2]          # [1, 2] (merge)

print(42)           # "42"
print("text")       # "text"
print([1, 2])      # "[1, 2]"

Polymorphism Visual

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

Polymorphism Code

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

animals = [Dog(), Cat(), Dog(), Cat()]

for animal in animals:
    print(animal.speak())

Static vs Dynamic Polymorphism

Method Overloading vs Overriding

Method Overloading — Java Example

In languages like Java, you can have multiple methods with the same name but different parameters

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }

    double add(double a, double b) {
        return a + b;
    }
}

Method Overloading in Python

Python doesn't support traditional overloading — but we can use *args

class Calculator:
    def add(self, *args):
        return sum(args)

calc = Calculator()
print(calc.add(2, 3))         # 5
print(calc.add(2, 3, 4))      # 9
print(calc.add(1.5, 2.5))    # 4.0

Method Overriding in Python

A subclass provides its own implementation of a parent's method

class Animal:
    def speak(self):
        return "..."

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

print(Animal().speak())   # ...
print(Dog().speak())      # Woof!
print(Cat().speak())      # Meow!

Method Overriding Rules

class Parent:
    def greet(self):
        ...

class Child(Parent):
    def greet(self):
        ...

# If parent has public
# method, child should
# keep it public or
# more accessible

class Child(Parent):
    def greet(self):
        super().greet()
        print("Hi!")

Duck Typing Principle

class Duck:
    def quack(self):
        print("Quack!")

class Person:
    def quack(self):
        print("I can quack too!")

def make_it_quack(thing):
    thing.quack()

make_it_quack(Duck())
make_it_quack(Person())

Polymorphism + Encapsulation

class PaymentProcessor:
    def pay(self, amount):
        raise NotImplementedError

class CreditCardProcessor(PaymentProcessor):
    def __init__(self, card_number):
        self.__card = card_number

    def pay(self, amount):
        print(f"Charging ${amount} to card ending {self.__card[-4:]}")

class PayPalProcessor(PaymentProcessor):
    def __init__(self, email):
        self.__email = email

    def pay(self, amount):
        print(f"Sending ${amount} via PayPal to {self.__email}")

def checkout(processor, amount):
    processor.pay(amount)

# Usage — same function, different processors
checkout(CreditCardProcessor("4242-4242-4242-4242"), 99.99)
checkout(PayPalProcessor("user@email.com"), 49.99)

Abstract Classes Intro

ABC + @abstractmethod

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

    def perimeter(self):
        return 2 * 3.14159 * self.radius

Refactoring: Before

Identify Conditional Statements Based on Object Type

def process_animals(animals):
    for animal in animals:
        if isinstance(animal, Dog):
            print("Woof!")
        elif isinstance(animal, Cat):
            print("Meow!")
        elif isinstance(animal, Duck):
            print("Quack!")
        elif isinstance(animal, Cow):
            print("Moo!")

Refactoring: After

Clean polymorphic version

for animal in animals:
    if isinstance(animal, Dog):
        print("Woof!")
    elif isinstance(animal, Cat):
        print("Meow!")
    elif isinstance(animal, Duck):
        print("Quack!")
    elif isinstance(animal, Cow):
        print("Moo!")

animals = [Dog(), Cat(), Duck(), Cow()]

for animal in animals:
    animal.make_sound()

What is PEP 8?

• Python Enhancement Proposal 8
• The official style guide for Python code
• Improves readability and consistency
• Conventions, not strict rules — but widely adopted
• Written by Guido van Rossum (Python creator) and others

Why Code Style Matters

Indentation & Line Length

def greet(name):
    if name:
        print(f"Hello, {name}")
    else:
        print("Hello, World")

total = (first_variable
         + second_variable
         - third_variable)

Blank Lines & Imports

Blank Lines & Imports Examples

import os, sys, json
import requests
import my_module
class MyClass:
    def method_a(self):
        pass
    def method_b(self):
        pass
def helper():
    pass

import json
import os
import sys

import requests

import my_module


class MyClass:
    def method_a(self):
        pass

    def method_b(self):
        pass


def helper():
    pass

Naming Conventions

Naming Conventions Code

MAX_SIZE = 100
DEFAULT_COLOR = "blue"


class UserProfile:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    def get_full_name(self):
        return f"{self.first_name} {self.last_name}"


user = UserProfile("John", "Doe")
display_name = user.get_full_name()

Whitespace in Expressions

• Spaces around assignment operators: x = 5
• Spaces around comparison operators: x == 5
• Spaces around arithmetic operators: x = y + 1
• Spaces after commas: my_list = [1, 2, 3]
• No space before colon in slicing: my_list[1:3]
• No space inside brackets: my_dict["key"]

Whitespace Examples

x=y+1
my_list=[1,2,3]
my_dict ['key'] = value
result = x *2+ y *3
print( x )
foo (1)

x = y + 1
my_list = [1, 2, 3]
my_dict['key'] = value
result = x * 2 + y * 3
print(x)
foo(1)

Type Hints

Python 3.5+ supports type annotations for better documentation and tooling

def add(x: int, y: int) -> int:
    return x + y

def greet(name: str) -> str:
    return f"Hello, {name}"

class Student:
    def __init__(self, name: str, grade: float) -> None:
        self.name: str = name
        self.grade: float = grade

PEP 8 and OOP

class BankAccount:
    ...

class HttpResponseParser:
    ...

def get_balance(self):
    ...

def calculate_interest(self):
    ...

def __init__(self):
    ...

def __str__(self):
    ...

PEP 8 Tools

Steps to Complete

Select a Topic

Topic Registration

• Register through Moodle
• Confirm with lecturer
• Must be unique within your group

Requirements: Git & GitHub

• Upload program + report to one GitHub repository
• Both must be on GitHub before the deadline
• Use meaningful commit messages
• Structure your project with clear folders

Requirements: 4 OOP Pillars

Your code must demonstrate all four:

Requirements: Design Pattern + Composition

Choose 1 design pattern to implement:

Requirements: File I/O + Testing + Code Style

Report Structure

Markdown format • English or Lithuanian

Report Example

Your README.md should look something like this:

# Library Management System

## 1. Introduction
A command-line library system built with Python.
Supports adding books, borrowing, returning, and searching.

### How to run
```bash
python main.py
```

## 2. Body / Analysis

### OOP Pillars
- **Encapsulation**: Book._isbn is private, accessed via property
- **Inheritance**: EBook(Book), AudioBook(Book)
- **Polymorphism**: each type overrides .display_info()
- **Abstraction**: MediaItem ABC defines the interface

### Design Pattern
Observer pattern — notifies users when a book is available.

## 3. Results
Implemented 8 classes across 4 modules. All 15 unit tests pass.

## 4. Conclusions
Learned to apply SOLID principles in practice. Would add a GUI next.

Evaluation System