Τα Design Patterns δεν είναι ακαδημαϊκά ασκήματα· είναι **αποδεδειγμένα σχέδια λύσης** για προβλήματα που αντιμετωπίζουμε καθημερινά. Εδώ παρουσιάζω τα 6 πιο απαραίτητα, με καθαρό, σύγχρονο Python κώδικα που μπορείτε να χρησιμοποιήσετε αύριο.
Πρόβλημα: Χρειάζεστε ακριβώς ένα αντικείμενο για έναν κοινό πόρο (DB Connection Pool, Config Manager, Logger).
Λύση: Έλεγχος instantiation στη `__new__`.
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
# Αρχικοποίηση εδώ (π.χ. DB connection)
return cls._instance
# Χρήση
logger1 = Singleton()
logger2 = Singleton()
assert logger1 is logger2 # True
⚠️ Προσοχή: Το thread-safe Singleton θέλει `threading.Lock` στη `__new__`. Αποφύγετε υπερβολική χρήση (global state = δύσκολο testing).
Πρόβλημα: Δημιουργείτε αντικείμενα διαφορετικού τύπου με βάση runtime δεδομένα (π.χ. `Button` για Windows vs HTML).
Λύση: Μεθοδός στο Factory που επιστρέφει το σωστό concrete product.
from abc import ABC, abstractmethod
class Button(ABC):
@abstractmethod
def render(self): pass
class HTMLButton(Button):
def render(self): return "<button>HTML</button>"
class WindowsButton(Button):
def render(self): return "[Windows Button]"
class ButtonFactory:
def create_button(self, btn_type: str) -> Button:
if btn_type == "html": return HTMLButton()
if btn_type == "windows": return WindowsButton()
raise ValueError(f"Unknown button: {btn_type}")
# Χρήση
factory = ButtonFactory()
btn = factory.create_button("html")
print(btn.render()) # <button>HTML</button>
✅ Open/Closed Principle: Προσθέτετε νέους τύπους χωρίς να χαλάτε το Factory.
Πρόβλημα: Έχετε πολλούς τρόπους να κάνετε το ίδιο πράγμα (Πληρωμή: Card, PayPal, Crypto; Sorting: Quick, Merge, Timsort).
Λύση: Interface για τη στρατηγική + Composition.
from abc import ABC, abstractmethod
class PaymentStrategy(ABC):
@abstractmethod
def pay(self, amount: float): pass
class CreditCard(PaymentStrategy):
def __init__(self, number): self.number = number
def pay(self, amount): print(f"Paid ${amount} via Card ending {self.number[-4:]}")
class PayPal(PaymentStrategy):
def __init__(self, email): self.email = email
def pay(self, amount): print(f"Paid ${amount} via PayPal ({self.email})")
class ShoppingCart:
def __init__(self, strategy: PaymentStrategy):
self.strategy = strategy
self.total = 0
def add(self, price): self.total += price
def checkout(self): self.strategy.pay(self.total)
# Χρήση - Runtime swap!
cart = ShoppingCart(CreditCard("1234567890123456"))
cart.add(100); cart.checkout() # Card
cart.strategy = PayPal("user@mail.com") # Αλλαγή στρατηγικής!
cart.checkout() # PayPal
✅ Το `ShoppingCart` δεν ξέρει τίποτα για μεθόδους πληρωμής. Μόνο για το `PaymentStrategy` interface.
Πρόβλημα: Ένα αντικείμενο (Subject) αλλάζει κατάσταση -> Πολλά άλλα (Observers) πρέπει να ενημερωθούν (UI updates, Logging, Notifications).
Λύση: Subject διατηρεί λίστα observers και καλεί `update()` σε όλους.
class Subject:
def __init__(self): self._observers = []
def attach(self, obs): self._observers.append(obs)
def detach(self, obs): self._observers.remove(obs)
def notify(self, msg):
for obs in self._observers: obs.update(msg)
class Observer(ABC):
@abstractmethod
def update(self, msg): pass
class Logger(Observer):
def update(self, msg): print(f"[LOG] {msg}")
class Alerter(Observer):
def update(self, msg): print(f"🚨 ALERT: {msg.upper()}")
# Χρήση
subject = Subject()
subject.attach(Logger())
subject.attach(Alerter())
subject.notify("Disk usage 90%")
# [LOG] Disk usage 90%
# 🚨 ALERT: DISK USAGE 90%
✅ **Loose Coupling:** Το Subject δεν ξέρει *ποιος* ή *πόσοι* είναι οι observers.
Πρόβλημα: Ο αλγόριθμος έχει σταθερή σειρά βημάτων, αλλά ορισμένα βήματα ποικίλλουν (π.χ. Data Pipeline: Read -> Validate -> Transform -> Save).
Λύση: Base class ορίζει το `process()` (final), subclasses υλοποιούν τα abstract steps.
from abc import ABC, abstractmethod
class DataProcessor(ABC):
def process(self): # Template Method (final)
self.read()
self.validate()
self.transform()
self.save()
print("Done.")
@abstractmethod
def read(self): pass
def validate(self): print("Default: Check nulls") # Hook με default
@abstractmethod
def transform(self): pass
@abstractmethod
def save(self): pass
class CSVProcessor(DataProcessor):
def read(self): print("Reading CSV...")
def transform(self): print("Transforming CSV...")
def save(self): print("Saving to DB...")
class JSONProcessor(DataProcessor):
def read(self): print("Reading JSON...")
def validate(self): print("Custom: Schema Validation") # Override hook
def transform(self): print("Transforming JSON...")
def save(self): print("Saving to File...")
CSVProcessor().process()
JSONProcessor().process()
✅ **Inversion of Control:** Η base class καλεί τα subclass methods (Hollywood Principle: "Don't call us, we'll call you").
Πρόβλημα: Θέλετε να προσθέσετε features σε ένα αντικείμενο (Logging, Caching, Auth, Retry) χωρίς να δημιουργείτε εκρηξη συνδυασμών υποκλάσεων (`CoffeeWithMilkAndSugarAndWhip...`).
Λύση: Wrapper objects που υλοποιούν το ίδιο interface.
class Coffee:
def cost(self): return 5
def desc(self): return "Coffee"
class CoffeeDecorator:
def __init__(self, coffee): self._coffee = coffee
def cost(self): return self._coffee.cost()
def desc(self): return self._coffee.desc()
class Milk(CoffeeDecorator):
def cost(self): return self._coffee.cost() + 2
def desc(self): return self._coffee.desc() + ", Milk"
class Sugar(CoffeeDecorator):
def cost(self): return self._coffee.cost() + 1
def desc(self): return self._coffee.desc() + ", Sugar"
# Χρήση - Composition at Runtime!
coffee = Coffee()
print(coffee.desc(), coffee.cost()) # Coffee 5
coffee = Milk(coffee)
print(coffee.desc(), coffee.cost()) # Coffee, Milk 7
coffee = Sugar(coffee)
print(coffee.desc(), coffee.cost()) # Coffee, Milk, Sugar 8
✅ **Single Responsibility:** Κάθε decorator κάνει ένα πράγμα. Συνδυάζονται άπειρα.
| Pattern | Trigger Phrase | Avoid If... |
|---|---|---|
| Singleton | "Χρειάζομαι **ένα** global instance" | Χρειάζεστε multiple instances / testing είναι critical |
| Factory | "Δημιουργώ objects **με βάση input/config**" | Η δημιουργία είναι απλή/σταθερή |
| Strategy | "Έχω **πολλούς τρόπους** για το ίδιο task" | Ο αλγόριθμος δεν αλλάζει ποτέ |
| Observer | "**Event** -> **Πολλά reactions**" | Είναι απλό 1-1 callback |
| Template Method | "**Σειρά βημάτων** σταθερή, **details** ποικίλλουν" | Δεν υπάρχει κοινή δομή |
| Decorator | "**Προσθέτω features** σε object **δυναμικά**" | Τα features είναι στατικά/ολιγά |
Τα patterns είναι **λέξη-κλειδί επικοινωνίας** μεταξύ developers ("Χρησιμοποίησα Strategy για την πληρωμή") και **εργαλεία καθαρού κώδικα**. Ξεκινήστε απλά. Refactor προς pattern όταν νιώσετε τον πόνο (duplication, rigidity, coupling). Και θυμηθείτε: **Το καλύτερο pattern είναι αυτό που κάνει τον κώδικα σας πιο κατανοητό και δοκιμασμένο.**
Πνευματικά δικαιώματα © Γνώση Υπολογιστών Όλα τα δικαιώματα διατηρούνται.