Introduction
Design patterns are reusable solutions to common problems in software design. In this comprehensive guide, we'll explore 5 essential design patterns with visual representations, simple explanations, and Python implementations.
📋 Table of Contents
Design Patterns
├── 1. Singleton Pattern (Creational)
├── 2. Factory Pattern (Creational)
├── 3. Observer Pattern (Behavioral)
├── 4. Strategy Pattern (Behavioral)
└── 5. Decorator Pattern (Structural)
1. 🔒 Singleton Pattern
Mind Map
Singleton Pattern
|
+-----------------+-----------------+
| | |
Purpose Implementation Use Cases
| | |
One Instance Private Constructor Database
| Check if exists Connection
Global Access Return same obj Logger
Config Manager
What is it?
Ensures a class has only ONE instance and provides a global point of access to it.
Flow Diagram
┌─────────────────┐
│ Client Request │
└────────┬────────┘
│
▼
┌──────────────────┐
│ Instance exists? │
└────┬────────┬────┘
│ │
YES NO
│ │
│ ▼
│ ┌─────────────┐
│ │Create New │
│ │Instance │
│ └──────┬──────┘
│ │
└──────────┤
▼
┌──────────────────┐
│Return Instance │
└──────────────────┘
Python Implementation
class DatabaseConnection:
_instance = None
def __new__(cls):
if cls._instance is None:
print("Creating new database connection...")
cls._instance = super().__new__(cls)
cls._instance.connection = "Connected to DB"
return cls._instance
def query(self, sql):
return f"Executing: {sql}"
# Usage Example
if __name__ == "__main__":
# First call - creates instance
db1 = DatabaseConnection()
print(f"DB1: {db1.connection}")
# Second call - returns same instance
db2 = DatabaseConnection()
print(f"DB2: {db2.connection}")
# Verify they are the same
print(f"Same instance? {db1 is db2}") # Output: True
Output:
Creating new database connection...
DB1: Connected to DB
DB2: Connected to DB
Same instance? True
2. 🏭 Factory Pattern
Mind Map
Factory Pattern
|
+-----------------+-----------------+
| | |
Purpose Components Use Cases
| | |
Object Creation Factory Class Different DB
| Product Classes Connections
Decoupling Common Interface Payment Methods
Logic UI Components
What is it?
Creates objects without specifying the exact class to create. The factory decides which class to instantiate.
Flow Diagram
┌──────────────┐
│ Client │
└──────┬───────┘
│ requests("type")
▼
┌──────────────────┐
│ Factory │
│ create_object() │
└─────┬───────┬────┘
│ │
Type A Type B
│ │
▼ ▼
┌─────────┐ ┌─────────┐
│Product A│ │Product B│
└─────────┘ └─────────┘
Python Implementation
# https://docs.python.org/3/library/abc.html
from abc import ABC, abstractmethod
# Abstract Product
class Vehicle(ABC):
@abstractmethod
def drive(self):
pass
# Concrete Products
class Car(Vehicle):
def drive(self):
return "🚗 Driving a car on the road"
class Bike(Vehicle):
def drive(self):
return "🏍️ Riding a bike on the highway"
class Boat(Vehicle):
def drive(self):
return "🚤 Sailing a boat on water"
# Factory
class VehicleFactory:
@staticmethod
def create_vehicle(vehicle_type):
vehicles = {
"car": Car,
"bike": Bike,
"boat": Boat
}
vehicle_class = vehicles.get(vehicle_type.lower())
if vehicle_class:
return vehicle_class()
else:
raise ValueError(f"Unknown vehicle type: {vehicle_type}")
# Usage Example
if __name__ == "__main__":
factory = VehicleFactory()
# Create different vehicles
car = factory.create_vehicle("car")
bike = factory.create_vehicle("bike")
boat = factory.create_vehicle("boat")
print(car.drive())
print(bike.drive())
print(boat.drive())
Output:
🚗 Driving a car on the road
🏍️ Riding a bike on the highway
🚤 Sailing a boat on water
3. 👁️ Observer Pattern
Mind Map
Observer Pattern
|
+-----------------+-----------------+
| | |
Purpose Components Use Cases
| | |
Notify Changes Subject (Publisher) Event Systems
| Observers Newsletter
One-to-Many Update Method Stock Market
Relationship Notifications
Flow Diagram
┌────────────────┐
│ Subject │
│ (Publisher) │
└────┬───────────┘
│ maintains list
▼
┌─────────────────────┐
│ Observer List │
│ [Obs1, Obs2, Obs3] │
└──────┬──────────────┘
│ State Change
▼
notify()
│
────┼────────
│ │ │
▼ ▼ ▼
┌─────┐┌─────┐┌─────┐
│Obs1 ││Obs2 ││Obs3 │
│update│update│update│
└─────┘└─────┘└─────┘
Python Implementation
from abc import ABC, abstractmethod
# Observer Interface
class Observer(ABC):
@abstractmethod
def update(self, message):
pass
# Concrete Observers
class EmailSubscriber(Observer):
def __init__(self, name):
self.name = name
def update(self, message):
print(f"📧 {self.name} received email: {message}")
class SMSSubscriber(Observer):
def __init__(self, name):
self.name = name
def update(self, message):
print(f"📱 {self.name} received SMS: {message}")
# Subject (Publisher)
class NewsPublisher:
def __init__(self):
self._subscribers = []
def subscribe(self, observer):
self._subscribers.append(observer)
print(f"✅ {observer.name} subscribed")
def unsubscribe(self, observer):
self._subscribers.remove(observer)
print(f"❌ {observer.name} unsubscribed")
def notify(self, message):
print(f"\n📢 Broadcasting: {message}")
for subscriber in self._subscribers:
subscriber.update(message)
# Usage Example
if __name__ == "__main__":
# Create publisher
news = NewsPublisher()
# Create subscribers
alice = EmailSubscriber("Alice")
bob = SMSSubscriber("Bob")
charlie = EmailSubscriber("Charlie")
# Subscribe
news.subscribe(alice)
news.subscribe(bob)
news.subscribe(charlie)
# Publish news
news.notify("Breaking: Python 4.0 Released!")
# Unsubscribe Bob
news.unsubscribe(bob)
# Publish again
news.notify("New Design Patterns Tutorial Available!")
Output:
✅ Alice subscribed
✅ Bob subscribed
✅ Charlie subscribed
📢 Broadcasting: Breaking: Python 4.0 Released!
📧 Alice received email: Breaking: Python 4.0 Released!
📱 Bob received SMS: Breaking: Python 4.0 Released!
📧 Charlie received email: Breaking: Python 4.0 Released!
❌ Bob unsubscribed
📢 Broadcasting: New Design Patterns Tutorial Available!
📧 Alice received email: New Design Patterns Tutorial Available!
📧 Charlie received email: New Design Patterns Tutorial Available!
4. 🎯 Strategy Pattern
Mind Map
Strategy Pattern
|
+-----------------+-----------------+
| | |
Purpose Components Use Cases
| | |
Select Algorithm Context Class Payment Methods
| Strategy Interface Sorting Algos
At Runtime Concrete Strategies Compression
Interchangeable Navigation Routes
Flow Diagram
┌──────────────┐
│ Context │
│ │
│ - strategy │
└──────┬───────┘
│ uses
▼
┌────────────────────┐
│ Strategy Interface│
│ + execute() │
└─────┬──────────────┘
│
────┼────────────
│ │ │
▼ ▼ ▼
┌────────┐ ┌────────┐ ┌────────┐
│Strategy│ │Strategy│ │Strategy│
│ A │ │ B │ │ C │
└────────┘ └────────┘ └────────┘
Python Implementation
from abc import ABC, abstractmethod
# Strategy Interface
class PaymentStrategy(ABC):
@abstractmethod
def pay(self, amount):
pass
# Concrete Strategies
class CreditCardPayment(PaymentStrategy):
def __init__(self, card_number):
self.card_number = card_number
def pay(self, amount):
return f"💳 Paid ${amount} using Credit Card ending in {self.card_number[-4:]}"
class PayPalPayment(PaymentStrategy):
def __init__(self, email):
self.email = email
def pay(self, amount):
return f"🅿️ Paid ${amount} using PayPal account {self.email}"
class CryptoPayment(PaymentStrategy):
def __init__(self, wallet_address):
self.wallet_address = wallet_address
def pay(self, amount):
return f"₿ Paid ${amount} using Crypto wallet {self.wallet_address[:8]}..."
# Context
class ShoppingCart:
def __init__(self):
self.items = []
self.payment_strategy = None
def add_item(self, item, price):
self.items.append((item, price))
print(f"Added {item}: ${price}")
def set_payment_strategy(self, strategy):
self.payment_strategy = strategy
def checkout(self):
total = sum(price for _, price in self.items)
print(f"\n🛒 Total: ${total}")
if self.payment_strategy:
result = self.payment_strategy.pay(total)
print(result)
print("✅ Payment successful!")
else:
print("❌ No payment method selected")
# Usage Example
if __name__ == "__main__":
cart = ShoppingCart()
# Add items
cart.add_item("Laptop", 999)
cart.add_item("Mouse", 25)
cart.add_item("Keyboard", 75)
# Pay with Credit Card
print("\n--- Payment Method 1: Credit Card ---")
cart.set_payment_strategy(CreditCardPayment("1234-5678-9012-3456"))
cart.checkout()
# Change payment strategy to PayPal
print("\n--- Payment Method 2: PayPal ---")
cart.set_payment_strategy(PayPalPayment("user@example.com"))
cart.checkout()
# Change to Crypto
print("\n--- Payment Method 3: Crypto ---")
cart.set_payment_strategy(CryptoPayment("1A2B3C4D5E6F7G8H9I"))
cart.checkout()
Output:
Added Laptop: $999
Added Mouse: $25
Added Keyboard: $75
--- Payment Method 1: Credit Card ---
🛒 Total: $1099
💳 Paid $1099 using Credit Card ending in 3456
✅ Payment successful!
--- Payment Method 2: PayPal ---
🛒 Total: $1099
🅿️ Paid $1099 using PayPal account user@example.com
✅ Payment successful!
--- Payment Method 3: Crypto ---
🛒 Total: $1099
₿ Paid $1099 using Crypto wallet 1A2B3C4D...
✅ Payment successful!
5. 🎀 Decorator Pattern
Mind Map
Decorator Pattern
|
+-----------------+-----------------+
| | |
Purpose Components Use Cases
| | |
Add Features Component Interface Adding Features
| Concrete Component Text Formatting
Dynamically Decorators Coffee Orders
Without Subclass Wrap Objects Middleware
Flow Diagram
┌──────────────────┐
│ Component │
│ (Interface) │
└────────┬─────────┘
│
┌────┴────┐
│ │
▼ ▼
┌─────────┐ ┌──────────────┐
│Concrete │ │ Decorator │
│Component│ │ (wraps) │
└─────────┘ └──────┬───────┘
│
┌──────┴──────┐
│ │
▼ ▼
┌──────────┐ ┌──────────┐
│Decorator │ │Decorator │
│ A │ │ B │
└──────────┘ └──────────┘
Python Implementation
from abc import ABC, abstractmethod
# Component Interface
class Coffee(ABC):
@abstractmethod
def cost(self):
pass
@abstractmethod
def description(self):
pass
# Concrete Component
class SimpleCoffee(Coffee):
def cost(self):
return 5
def description(self):
return "Simple Coffee"
# Decorator Base
class CoffeeDecorator(Coffee):
def __init__(self, coffee):
self._coffee = coffee
def cost(self):
return self._coffee.cost()
def description(self):
return self._coffee.description()
# Concrete Decorators
class MilkDecorator(CoffeeDecorator):
def cost(self):
return self._coffee.cost() + 2
def description(self):
return f"{self._coffee.description()} + Milk"
class SugarDecorator(CoffeeDecorator):
def cost(self):
return self._coffee.cost() + 1
def description(self):
return f"{self._coffee.description()} + Sugar"
class VanillaDecorator(CoffeeDecorator):
def cost(self):
return self._coffee.cost() + 3
def description(self):
return f"{self._coffee.description()} + Vanilla"
class CaramelDecorator(CoffeeDecorator):
def cost(self):
return self._coffee.cost() + 2.5
def description(self):
return f"{self._coffee.description()} + Caramel"
# Usage Example
if __name__ == "__main__":
print("☕ COFFEE SHOP ORDERS\n")
# Order 1: Simple Coffee
coffee1 = SimpleCoffee()
print(f"Order 1: {coffee1.description()}")
print(f"Cost: ${coffee1.cost()}\n")
# Order 2: Coffee with Milk
coffee2 = MilkDecorator(SimpleCoffee())
print(f"Order 2: {coffee2.description()}")
print(f"Cost: ${coffee2.cost()}\n")
# Order 3: Coffee with Milk and Sugar
coffee3 = SugarDecorator(MilkDecorator(SimpleCoffee()))
print(f"Order 3: {coffee3.description()}")
print(f"Cost: ${coffee3.cost()}\n")
# Order 4: Fully Loaded Coffee
coffee4 = CaramelDecorator(
VanillaDecorator(
SugarDecorator(
MilkDecorator(SimpleCoffee())
)
)
)
print(f"Order 4: {coffee4.description()}")
print(f"Cost: ${coffee4.cost()}\n")
Output:
☕ COFFEE SHOP ORDERS
Order 1: Simple Coffee
Cost: $5
Order 2: Simple Coffee + Milk
Cost: $7
Order 3: Simple Coffee + Milk + Sugar
Cost: $8
Order 4: Simple Coffee + Milk + Sugar + Vanilla + Caramel
Cost: $13.5
📊 Design Patterns Comparison
┌─────────────────────────────────────────────────────────────────────┐
│ DESIGN PATTERN TYPES │
├─────────────────┬─────────────────┬─────────────────────────────────┤
│ CREATIONAL │ STRUCTURAL │ BEHAVIORAL │
│ (How created) │ (How composed)│ (How they interact) │
├─────────────────┼─────────────────┼─────────────────────────────────┤
│ • Singleton │ • Decorator │ • Observer │
│ • Factory │ • Adapter │ • Strategy │
│ • Builder │ • Facade │ • Command │
│ • Prototype │ • Proxy │ • State │
│ • Abstract │ • Bridge │ • Chain of Responsibility │
│ Factory │ • Composite │ • Template Method │
└─────────────────┴─────────────────┴─────────────────────────────────┘
🎯 When to Use Which Pattern?
Problem → Recommended Pattern
─────────────────────────────────────────────────────────────
Need only one instance → Singleton
Create objects without → Factory
specifying exact class
Need to notify multiple → Observer
objects of changes
Want to swap algorithms → Strategy
at runtime
Add features without → Decorator
modifying existing code
💡 Best Practices
- Don't Overuse: Not every problem needs a design pattern
- Keep It Simple: Start simple, add patterns when needed
- Understand the Problem: Choose patterns that fit your specific needs
- Combine Patterns: Patterns can work together (e.g., Singleton Factory)
- Document Your Choice: Explain why you chose a particular pattern
🚀 Conclusion
Design patterns are powerful tools that help you write:
- ✅ Maintainable code
- ✅ Scalable applications
- ✅ Reusable components
- ✅ Testable systems
Start with these 5 patterns, practice implementing them, and gradually explore more complex patterns as your needs grow!
📚 Further Reading
- Book: "Design Patterns: Elements of Reusable Object-Oriented Software" (Gang of Four)
- Online: refactoring.guru/design-patterns
- Practice: Try implementing these patterns in your next project!
Happy Coding! 🐍✨
Found this helpful? Share it with your fellow developers!
Top comments (0)