Python Design Patterns: Writing Cleaner and More Maintainable Code

Design patterns are reusable solutions to common software design problems. This guide covers essential Python patterns.

## Singleton
```python
class Singleton:
   _instance = None
   def __new__(cls):
       if cls._instance is None:
           cls._instance = super().__new__(cls)
       return cls._instance
```

## Factory
```python
class Dog:
   def speak(self): return "Woof!"

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

def create_pet(pet_type):
   pets = {"dog": Dog, "cat": Cat}
   return pets.get(pet_type)()
```

## Observer
```python
class EventEmitter:
   def __init__(self):
       self._listeners = {}
   def on(self, event, callback):
       self._listeners.setdefault(event, []).append(callback)
   def emit(self, event, *args):
       for cb in self._listeners.get(event, []):
           cb(*args)
```

## Decorator Pattern
```python
import functools
import time

def timer(func):
   @functools.wraps(func)
   def wrapper(*args, **kwargs):
       start = time.time()
       result = func(*args, **kwargs)
       print(f"{func.__name__}: {time.time()-start:.2f}s")
       return result
   return wrapper

@timer
def slow_function():
   time.sleep(1)
```

## Strategy
```python
class SortStrategy:
   def sort(self, data): pass

class BubbleSort(SortStrategy):
   def sort(self, data): return sorted(data)

class Context:
   def __init__(self, strategy):
       self._strategy = strategy
   def execute(self, data):
       return self._strategy.sort(data)
```

## Conclusion

Patterns improve code organization. Use them when they solve real problems, not just for the sake of using them.