Design Patterns (Part 2)

from abc import ABC, abstractmethod

class RouteStrategy(ABC):
    @abstractmethod
    def calculate_route(self, origin, destination):
        pass

class WalkingStrategy(RouteStrategy):
    def calculate_route(self, origin, destination):
        return f"Walking from {origin} to {destination} via parks"

class RoadStrategy(RouteStrategy):
    def calculate_route(self, origin, destination):
        return f"Driving from {origin} to {destination} via highway"

class PublicTransportStrategy(RouteStrategy):
    def calculate_route(self, origin, destination):
        return f"Taking bus from {origin} to {destination}"

class Navigator:
    def __init__(self, strategy: RouteStrategy):
        self.strategy = strategy

    def navigate(self, origin, destination):
        return self.strategy.calculate_route(origin, destination)

nav = Navigator(WalkingStrategy())
print(nav.navigate("Home", "Airport"))

nav.strategy = RoadStrategy()  # swap at runtime!
print(nav.navigate("Home", "Airport"))

from abc import ABC, abstractmethod

class Text(ABC):
    @abstractmethod
    def render(self):
        pass

class PlainText(Text):
    def __init__(self, content):
        self.content = content

    def render(self):
        return self.content

class TextDecorator(Text):
    def __init__(self, wrapped: Text):
        self.wrapped = wrapped

class BoldText(TextDecorator):
    def render(self):
        return f"<b>{self.wrapped.render()}</b>"

class ItalicText(TextDecorator):
    def render(self):
        return f"<i>{self.wrapped.render()}</i>"

text = PlainText("Hello")
bold = BoldText(text)
bold_italic = ItalicText(bold)
print(bold_italic.render())  # <i><b>Hello</b></i>

Python has built-in decorator syntax using @:

import time

def time_logger(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@time_logger
def process_data(data):
    time.sleep(0.5)
    return f"Processed {len(data)} items"

process_data([1, 2, 3])
# process_data took 0.5012s

Guard a function so only authenticated users can call it:

def auth_required(func):
    def wrapper(user, *args, **kwargs):
        if not user.is_authenticated:
            raise PermissionError("Login required")
        return func(user, *args, **kwargs)
    return wrapper

@auth_required
def view_profile(user):
    return f"Welcome, {user.name}"

view_profile(alice)   # Welcome, Alice
view_profile(guest)   # PermissionError: Login required

from abc import ABC, abstractmethod

class Transport(ABC):
    @abstractmethod
    def deliver(self):
        pass

class Truck(Transport):
    def deliver(self):
        return "Delivering by land in a box"

class Ship(Transport):
    def deliver(self):
        return "Delivering by sea in a container"

class TransportFactory:
    @staticmethod
    def create_transport(transport_type: str) -> Transport:
        factories = {
            "truck": Truck,
            "ship": Ship,
        }
        return factories[transport_type]()

transport = TransportFactory.create_transport("ship")
print(transport.deliver())
# "Delivering by sea in a container"

class VideoFile:
    def __init__(self, filename):
        self.filename = filename

class CodecFactory:
    def extract(self, file):
        return f"codec for {file.filename}"

class BitrateReader:
    def read(self, file, codec):
        return f"reading {file.filename}"

class AudioMixer:
    def fix(self, result):
        return f"fixing audio: {result}"

class VideoConverter:
    def convert(self, filename, format):
        file = VideoFile(filename)
        codec = CodecFactory().extract(file)
        result = BitrateReader().read(file, codec)
        result = AudioMixer().fix(result)
        return f"{filename} converted to {format}"

converter = VideoConverter()
print(converter.convert("funny_cats.ogg", "mp4"))
# "funny_cats.ogg converted to mp4"

A full generator in 4 lines:

def countdown(n):
    while n > 0:
        yield n
        n -= 1

for i in countdown(3):
    print(i)  # 3, 2, 1

How it works — each yield pauses and resumes:

• ✅ Calling countdown(3) returns a generator object, an iterator for free
• 🎯 yield n pauses execution and hands n to the caller
• 🔁 Next iteration resumes right after the yield with local state intact
• ✅ When the function ends, StopIteration is raised automatically

Also: generator expressions — one-liners:

squares = (x * x for x in range(10))
print(next(squares))  # 0
print(next(squares))  # 1
print(sum(squares))   # 4+9+16+...+81 = 280

The Subject keeps a list of observers:

class Order:
    def __init__(self):
        self._observers = []
        self._status = "new"

    def subscribe(self, observer):
        self._observers.append(observer)

    def set_status(self, status):
        self._status = status
        for obs in self._observers:
            obs.update(self)

Observers implement a simple interface:

class EmailNotifier:
    def update(self, order):
        print(f"Email: order is now {order._status}")

class Logger:
    def update(self, order):
        print(f"[LOG] {order._status}")

Usage:

order = Order()
order.subscribe(EmailNotifier())
order.subscribe(Logger())

order.set_status("shipped")
# Email: order is now shipped
# [LOG] shipped

• 🔎 Understand the problem fully before picking a pattern
• 💯 KISS — keep it simple, don't over-engineer

• 🛠️ Follow SOLID principles — patterns naturally emerge
• 🔄 Refactor to patterns when the need becomes clear, not upfront

• ⚖️ Understand trade-offs — every pattern has pros and cons
• 📚 Spot patterns in frameworks you already use: Flask @app.route is a Decorator, Django signals are an Observer, open() is a Factory

What about April 27 at 09:00?

❌ Now you're just being optimistic.

What about April 27 at 00:30?

❌ Still after.  Time is linear.

Is April 27 at 00:00:01 after the deadline?

❌ Yes.  It is. Sorry.

Is April 26 at 23:59:59 OK?

⚠️ Technically.  Pure adrenaline. Don't.

Is April 26 at 23:58 OK?

✅ Yes.  Responsible adult behavior.

What if I'm in a different time zone?

🌏 23:59 Vilnius time. Set your watch.

My laptop crashed at 23:58.

Should've submitted at 23:00. 🤷

Can I email the file instead?

❌ No. Use GitHub and Moodle.

My cat walked on the keyboard and deleted my project.

🐈 Use git. git push = cat-proof.

Can I get an extension?

❌ No.  Unless you have a really good reason.

Real one from 2 years ago: "My neighbor's room caught on fire, I had to evacuate. By the time I got back it was 4 am. Can I have a second chance to defend my course work?"  ✅ That worked.

When should I actually start?

Right now.  Check the countdown — it only goes one way.