Course Curriculum

Where we are in the journey

• ✓ 1. Classes & 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. Unit Testing & TDD
• ✓ 10. Design Patterns (2nd part)
• ✓ 11. Libraries & Frameworks
• 12. Recap & Consultation

How This Lecture Works

• 📚 We revisit each of the 9 core topics from the course
• 📝 A few key recap slides per topic — copied straight from the original lectures
• ❓ A short quiz after each topic to check your memory
• 🎯 ~33 quiz questions — many are direct from the exam pool, others are very similar
• 🧠 Treat this as your last revision before the exam

What Does a Class Define?

self.title = title
self.author = author
self.year = year

def display_info(self):
    print(f"{self.title}")

Creating Classes in Python

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

    def display_info(self):
        print(f"{self.title} by {self.author} ({self.year})")

Creating Objects (Instantiation)

object_name = ClassName(parameters)

book1 = Book("Clean Code", "Robert Martin", 2008)
book2 = Book("Refactoring", "Martin Fowler", 1999)

Key Takeaway: self

person1.introduce()

Person.introduce(person1)

Common Magic Methods

Four Pillars of OOP

The core characteristics of object-oriented programming

Encapsulation: Information Hiding

Access Control in Python

Python uses naming conventions, not strict enforcement

Access Control Comparison

The @property Decorator

Same thing, but Pythonic

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        if new_value >= 0:
            self._value = new_value

obj = MyClass(10)
print(obj.value)  # 10 (uses getter)
obj.value = 20    # uses setter

@property: Circle Example

import math

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

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value <= 0:
            raise ValueError("Radius must be positive")
        self._radius = value

    @property
    def area(self):
        return math.pi * self._radius ** 2

c = Circle(5)
print(c.area)  # 78.54 (computed property)

Terminology in Code

class Animal: # Parent class
    def eat(self):
        print("This animal is eating")

class Dog(Animal): # Child class
    def bark(self):
        print("The dog barks")

class Cat(Animal): # Child class
    def meow(self):
        print("The cat meows")

rex = Dog()
rex.eat()   # This animal is eating
rex.bark()  # The dog barks

__init__ in Inheritance

How constructors chain through the hierarchy

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

class Dog(Animal):
    def __init__(self, name, breed):
        self.breed = breed  # name is LOST!

rex = Dog("Rex", "Labrador")
print(rex.breed)  # Labrador
print(rex.name)   # AttributeError!

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

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

rex = Dog("Rex", "Labrador")
print(rex.name)   # Rex ✔
print(rex.breed)  # Labrador ✔

Understanding Method Overriding

A subclass provides a specific implementation for a method already defined in its superclass

The super() Function

Access superclass methods — ensures proper initialization

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

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

Understanding Polymorphism

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

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

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

Object Relationships

Two fundamental types

What Is Composition?

Composition in Python

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

    def start(self):
        return "Engine running"


class Car:
    def __init__(self, model):
        self.model = model
        self.engine = Engine(200)

    def drive(self):
        return self.engine.start()

# Usage
my_car = Car("Toyota")
print(my_car.drive())
# Engine running

What Is Aggregation?

Composition vs Aggregation

Composition over Inheritance

A principle suggesting classes should achieve polymorphism through composition rather than inheritance

What is Exception Handling?

Built-in Python Exceptions

try / except / finally

try:
    # Code that might raise an exception
except ExceptionType:
    # Code that runs if an exception occurs
finally:
    # Cleanup code that runs no matter what

Creating custom exceptions

class MyCustomError(Exception):
    pass

class ValidationError(Exception):
    def __init__(self, message, value):
        self.message = message
        self.value = value
        super().__init__(message)

Logging Levels

2023-04-01 09:15:30 - root - DEBUG    - This is a debug message
2023-04-02 10:20:45 - root - INFO     - This is an info message
2023-04-03 11:25:50 - root - WARNING  - This is a warning message
2023-04-04 12:30:55 - root - ERROR    - This is an error message
2023-04-05 13:35:00 - root - CRITICAL - This is a critical message

What SRP IS:

Liskov Substitution Principle (LSP)

Interface Segregation Principle

Three Categories

Singleton in Python

class DatabaseSingleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.connection = "Connected to DB"
        return cls._instance

    def query(self, sql):
        return f"Executing: {sql}"

Strategy — Real-world Analogy

Imagine you have to get to the airport. Different strategies:

• 🚌 Bus — cheapest, but slowest
• 🚕 Taxi — fast and comfortable, but expensive
• 🚲 Bicycle — free and healthy, but weather-dependent

Same goal (reach the airport), different strategies. You pick one depending on budget, time, or weather.

Decorator — Real-world Analogy

Wearing layers of clothing:

• 👕 You start with a t-shirt (base object)
• 🧣 Add a sweater when it's cold (decorator 1)
• 🧥 Put on a jacket for rain (decorator 2)
• 🌂 Add a raincoat for heavy rain (decorator 3)

Each layer wraps the previous one. You can add or remove layers without changing the t-shirt itself.

Factory: Solution

• 🔨 Centralize all creation logic in one place
• 🟢 Clients ask what they need — the factory picks which class
• 🔁 Adding a new product = one edit to the factory, zero changes to callers

Most useful when many inputs determine which class to instantiate — all that complexity lives in one place.

▶ The diagram on the right shows Factory Method (GoF) — a polymorphic variant with subclass overrides. In Python, the Simple Factory below (a single create() with if/else) is what you'll use 95% of the time.

In practice — many params → one of many classes:

class TransportFactory:
    @staticmethod
    def create(destination, weight, urgent):
        if destination == "overseas":
            return Ship(weight)
        if urgent and weight < 10:
            return Drone(weight)
        if weight > 1000:
            return Train(weight)
        return Truck(weight)

t = TransportFactory.create("overseas", 50, False)

Facade: Solution

Observer — Real-world Analogy

Think of a YouTube channel:

• 🎥 The channel (subject) publishes new videos
• 👤 Subscribers (observers) get notified automatically
• ❌ The channel doesn't care who subscribes or how many
• ✅ Subscribers can join or leave freely — no coupling to the channel's internals

One publisher, many subscribers. Loose coupling.

When to Use Which Pattern?

🧩 What is a "unit"?

📋 The AAA Pattern

Arrange — Act — Assert. Three lines, three responsibilities.

def test_rectangle_area():
    rect = Rectangle(10, 20)         # Arrange
    area = rect.area()               # Act
    assert area == 200               # Assert

Same Test, Two Styles

import unittest
from rectangle import Rectangle

class TestRectangle(unittest.TestCase):
    def test_area(self):
        rect = Rectangle(10, 20)
        self.assertEqual(rect.area(), 200)

from rectangle import Rectangle

def test_area():
    rect = Rectangle(10, 20)
    assert rect.area() == 200

F.I.R.S.T Principles

What is TDD?

The TDD Cycle

Three steps. Endless cycles.

Key Takeaways — The Whole Course

🎯 Exam Tips

📝 Exam Rules

📅 Exam Schedule

Consultation for all groups: 2026-05-15, 08:30, P2 153 · Exam venue: P2 203

Subject: Objektinis programavimas (su kursiniu darbu) · Code: FMSAB23201 · Type: E