Υλικό υπολογιστών

* Γνώση Υπολογιστών >> Υλικό υπολογιστών >  >> Προβολείς

6 Κλασικά Design Patterns που θα αλλάξουν τον τρόπο που γράφετε κώδικα (με Python παραδείγματα)

Τα Design Patterns δεν είναι ακαδημαϊκά ασκήματα· είναι **αποδεδειγμένα σχέδια λύσης** για προβλήματα που αντιμετωπίζουμε καθημερινά. Εδώ παρουσιάζω τα 6 πιο απαραίτητα, με καθαρό, σύγχρονο Python κώδικα που μπορείτε να χρησιμοποιήσετε αύριο.


1. Singleton: "Μια Μόνη Ινστάνς, Παντού"

Πρόβλημα: Χρειάζεστε ακριβώς ένα αντικείμενο για έναν κοινό πόρο (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).


2. Factory Method: "Αποκρύψτε τη Δημιουργία"

Πρόβλημα: Δημιουργείτε αντικείμενα διαφορετικού τύπου με βάση 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.


3. Strategy: "Αλγόριθμοι Hot-Swappable"

Πρόβλημα: Έχετε πολλούς τρόπους να κάνετε το ίδιο πράγμα (Πληρωμή: 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.


4. Observer: "Event-Driven Αρχιτεκτονική σε Micro-Scale"

Πρόβλημα: Ένα αντικείμενο (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.


5. Template Method: "Σκελετός Αλγορίθμου, Λεπτομέρειες στα Subclasses"

Πρόβλημα: Ο αλγόριθμος έχει σταθερή σειρά βημάτων, αλλά ορισμένα βήματα ποικίλλουν (π.χ. 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").


6. Decorator: "Προσθέστε Συμπεριφορά Δυναμικά, Χωρίς Υποκλάσεις"

Πρόβλημα: Θέλετε να προσθέσετε 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 κάνει ένα πράγμα. Συνδυάζονται άπειρα.


Checklist: Πότε να χρησιμοποιήσετε τι;

PatternTrigger PhraseAvoid 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 είναι αυτό που κάνει τον κώδικα σας πιο κατανοητό και δοκιμασμένο.**

Σχετικά άρθρα

Πνευματικά δικαιώματα © Γνώση Υπολογιστών Όλα τα δικαιώματα διατηρούνται.