Python Architecture Skill
Design Patterns for Python
Creational Patterns
Factory Pattern
from abc import ABC, abstractmethod
class Animal(ABC):
@abstractmethod
def make_sound(self):
pass
class Dog(Animal):
def make_sound(self):
return "Woof!"
class AnimalFactory:
_animals = {"dog": Dog}
@classmethod
def create_animal(cls, animal_type: str) -> Animal:
if animal_class := cls._animals.get(animal_type):
return animal_class()
raise ValueError(f"Unknown animal type: {animal_type}")
Singleton Pattern (Modern Python)
class DatabaseConnection:
_instance = None
_connection = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
def get_connection(self):
if not self._connection:
self._connection = "database_connection_object"
return self._connection
Structural Patterns
Adapter Pattern
class LegacyPaymentSystem:
def make_payment(self, amount):
return f"Legacy payment: ${amount}"
class ModernPaymentInterface:
def process_payment(self, amount: float) -> str:
pass
class PaymentAdapter(ModernPaymentInterface):
def __init__(self, legacy_system: LegacyPaymentSystem):
self.legacy_system = legacy_system
def process_payment(self, amount: float) -> str:
return self.legacy_system.make_payment(amount)
Decorator Pattern
from functools import wraps
import time
def retry(max_attempts: int = 3, delay: float = 1.0):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for attempt in range(max_attempts):
try:
return func(*args, **kwargs)
except Exception as e:
if attempt == max_attempts - 1:
raise
time.sleep(delay)
return wrapper
return decorator
Behavioral Patterns
Observer Pattern
from typing import List, Protocol
class Observer(Protocol):
def update(self, data: any) -> None:
...
class Subject:
def __init__(self):
self._observers: List[Observer] = []
self._state = None
def attach(self, observer: Observer):
self._observers.append(observer)
def detach(self, observer: Observer):
self._observers.remove(observer)
def notify(self):
for observer in self._observers:
observer.update(self._state)
def set_state(self, state):
self._state = state
self.notify()
Strategy Pattern
from abc import ABC, abstractmethod
from typing import List
class SortStrategy(ABC):
@abstractmethod
def sort(self, data: List[int]) -> List[int]:
pass
class BubbleSort(SortStrategy):
def sort(self, data: List[int]) -> List[int]:
# Implementation here
return sorted(data) # Simplified
class QuickSort(SortStrategy):
def sort(self, data: List[int]) -> List[int]:
# Implementation here
return sorted(data) # Simplified
class Sorter:
def __init__(self, strategy: SortStrategy):
self._strategy = strategy
def set_strategy(self, strategy: SortStrategy):
self._strategy = strategy
def sort_data(self, data: List[int]) -> List[int]:
return self._strategy.sort(data)
Project Structure Patterns
Small to Medium Projects
project_name/
├── src/
│ └── project_name/
│ ├── __init__.py
│ ├── main.py
│ ├── config.py
│ ├── models/
│ │ ├── __init__.py
│ │ └── user.py
│ ├── services/
│ │ ├── __init__.py
│ │ └── user_service.py
│ └── utils/
│ ├── __init__.py
│ └── helpers.py
├── tests/
│ ├── __init__.py
│ ├── test_models/
│ └── test_services/
├── docs/
├── requirements.txt
├── pyproject.toml
└── README.md
Large Projects (Layered Architecture)
project_name/
├── src/
│ └── project_name/
│ ├── domain/ # Business logic
│ │ ├── models/
│ │ ├── services/
│ │ └── repositories/
│ ├── infrastructure/ # External concerns
│ │ ├── database/
│ │ ├── api/
│ │ └── messaging/
│ ├── application/ # Use cases
│ │ ├── commands/
│ │ ├── queries/
│ │ └── handlers/
│ └── presentation/ # Controllers, views
│ ├── api/
│ └── cli/
└── ...
SOLID Principles in Python
Single Responsibility Principle
# BAD: Multiple responsibilities
class User:
def __init__(self, name: str, email: str):
self.name = name
self.email = email
def save_to_database(self):
# Database logic
pass
def send_email(self):
# Email logic
pass
# GOOD: Single responsibility
class User:
def __init__(self, name: str, email: str):
self.name = name
self.email = email
class UserRepository:
def save(self, user: User):
# Database logic
pass
class EmailService:
def send_user_email(self, user: User):
# Email logic
pass
Dependency Inversion Principle
from abc import ABC, abstractmethod
# Bad: High-level depends on low-level
class EmailService:
def send_email(self, message: str):
# SMTP implementation
pass
class NotificationService:
def __init__(self):
self.email_service = EmailService() # Direct dependency
def notify(self, message: str):
self.email_service.send_email(message)
# Good: Both depend on abstraction
class MessageSender(ABC):
@abstractmethod
def send(self, message: str) -> bool:
pass
class EmailSender(MessageSender):
def send(self, message: str) -> bool:
# SMTP implementation
return True
class NotificationService:
def __init__(self, sender: MessageSender):
self._sender = sender
def notify(self, message: str) -> bool:
return self._sender.send(message)
Async Architecture Patterns
Producer-Consumer Pattern
import asyncio
from typing import Any
class AsyncQueue:
def __init__(self, maxsize: int = 0):
self._queue = asyncio.Queue(maxsize=maxsize)
async def produce(self, item: Any):
await self._queue.put(item)
async def consume(self) -> Any:
return await self._queue.get()
def task_done(self):
self._queue.task_done()
async def producer(queue: AsyncQueue, items: list):
for item in items:
await queue.produce(item)
await asyncio.sleep(0.1)
async def consumer(queue: AsyncQueue, name: str):
while True:
item = await queue.consume()
print(f"Consumer {name} processing {item}")
await asyncio.sleep(0.5)
queue.task_done()
Event-Driven Architecture
from typing import Dict, List, Callable
import asyncio
class EventBus:
def __init__(self):
self._handlers: Dict[str, List[Callable]] = {}
def subscribe(self, event_type: str, handler: Callable):
if event_type not in self._handlers:
self._handlers[event_type] = []
self._handlers[event_type].append(handler)
async def publish(self, event_type: str, data: any):
if handlers := self._handlers.get(event_type, []):
tasks = [handler(data) for handler in handlers]
await asyncio.gather(*tasks, return_exceptions=True)
# Usage
async def user_created_handler(user_data):
print(f"Sending welcome email to {user_data['email']}")
bus = EventBus()
bus.subscribe("user_created", user_created_handler)
await bus.publish("user_created", {"email": "user@example.com"})
API Design Guidelines
RESTful Resource Design
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
from typing import List, Optional
app = FastAPI()
class UserCreate(BaseModel):
name: str
email: str
class UserResponse(BaseModel):
id: int
name: str
email: str
class UserUpdate(BaseModel):
name: Optional[str] = None
email: Optional[str] = None
# RESTful endpoints
@app.post("/users", response_model=UserResponse, status_code=201)
async def create_user(user: UserCreate):
# Implementation
pass
@app.get("/users", response_model=List[UserResponse])
async def list_users(limit: int = 10, offset: int = 0):
# Implementation
pass
@app.get("/users/{user_id}", response_model=UserResponse)
async def get_user(user_id: int):
# Implementation
pass
@app.patch("/users/{user_id}", response_model=UserResponse)
async def update_user(user_id: int, user_update: UserUpdate):
# Implementation
pass
@app.delete("/users/{user_id}", status_code=204)
async def delete_user(user_id: int):
# Implementation
pass
These patterns provide a solid foundation for building maintainable, scalable Python applications. Choose patterns based on your specific use case and complexity requirements.