Design Patterns in Python

# 1. Singleton — only one instance
class Database:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.connection = "Connected"
        return cls._instance

db1 = Database()
db2 = Database()
print(f"Same instance: {db1 is db2}")  # True

# 2. Factory — create objects without specifying class
class Dog:
    def speak(self): return "Woof!"

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

def animal_factory(animal_type):
    animals = {"dog": Dog, "cat": Cat}
    return animals.get(animal_type.lower(), Dog)()

pet = animal_factory("cat")
print(pet.speak())  # Meow!

# 3. Observer — notify on changes
class EventEmitter:
    def __init__(self):
        self._listeners = {}
    
    def on(self, event, callback):
        self._listeners.setdefault(event, []).append(callback)
    
    def emit(self, event, data=None):
        for callback in self._listeners.get(event, []):
            callback(data)

# Usage
emitter = EventEmitter()
emitter.on("login", lambda user: print(f"  Welcome, {user}!"))
emitter.on("login", lambda user: print(f"  Logging: {user} logged in"))
emitter.emit("login", "Alice")

# 4. Strategy — swap algorithms
class SortStrategy:
    @staticmethod
    def bubble(data): return sorted(data)
    
    @staticmethod
    def reverse(data): return sorted(data, reverse=True)

class Sorter:
    def __init__(self, strategy):
        self.strategy = strategy
    
    def sort(self, data):
        return self.strategy(data)

sorter = Sorter(SortStrategy.reverse)
print(f"\nSorted: {sorter.sort([3, 1, 4, 1, 5])}")