Low-Level Design: A Comprehensive Guide
Chapter 1: Introduction to Design Patterns
Theoretical Significance of Design Patterns in Software Engineering
Design patterns constitute a compendium of best practices that provide pre-established solutions to frequently encountered problems in software architecture. These patterns underpin the development of flexible, extensible, and maintainable systems by enabling robust abstractions and facilitating code reuse. A profound understanding of design patterns empowers developers to construct resilient systems that are both testable and scalable.
Design patterns address common software design challenges such as:
- Reducing tight coupling between components.
- Enhancing scalability and flexibility of systems.
- Improving code readability and maintainability.
For example, the Observer Pattern can be used in a stock market application to notify multiple clients of changes in stock prices.
Taxonomy of Design Patterns
Design patterns are systematically classified into three overarching categories:
- Creational Patterns: These deal with object creation mechanisms and abstract the instantiation process to make systems independent of the objects they create. Examples:
- Factory: Centralizes object creation logic.
- Singleton: Ensures only one instance of a class exists.
- Structural Patterns: These focus on composing classes and objects into larger structures while ensuring that the overall architecture remains flexible and efficient. Examples:
- Adapter: Makes incompatible interfaces work together.
- Composite: Models part-whole hierarchies using tree structures.
- Behavioral Patterns: These deal with communication and interaction between objects. Examples:
- Strategy: Defines interchangeable algorithms encapsulated within a class.
- Observer: Establishes a one-to-many dependency between objects.
Unified Modeling Language (UML) as a Visualization Tool
Unified Modeling Language (UML) diagrams are indispensable tools for visualizing, specifying, constructing, and documenting software systems. Key diagram types include:
- Class Diagrams: Represent the structure of a system by showing its classes, attributes, and relationships.
- Sequence Diagrams: Highlight object interactions over time. Example: A sequence diagram for user authentication.
- State Diagrams: Illustrate state transitions of an object in response to events. Example: The lifecycle of a TCP connection.
- Activity Diagrams: Describe workflows and the sequence of actions within a process.
Practical Example: Observer Pattern in Python
Imagine a stock market application where multiple clients (observers) need updates when stock prices change:
class Stock:
def __init__(self, symbol):
self.symbol = symbol
self.price = 0
self.observers = []
def add_observer(self, observer):
self.observers.append(observer)
def remove_observer(self, observer):
self.observers.remove(observer)
def set_price(self, price):
self.price = price
self.notify_observers()
def notify_observers(self):
for observer in self.observers:
observer.update(self)
class Investor:
def __init__(self, name):
self.name = name
def update(self, stock):
print(f"{self.name} notified of {stock.symbol} price change to {stock.price}")
# Example usage
apple = Stock("AAPL")
john = Investor("John")
mary = Investor("Mary")
apple.add_observer(john)
apple.add_observer(mary)
apple.set_price(150)
# Output:
# John notified of AAPL price change to 150
# Mary notified of AAPL price change to 150
This example demonstrates how the Observer Pattern decouples the stock from the investors, making the system more flexible and maintainable.
Chapter 2: Foundational Principles of Object-Oriented Design
Encapsulation
Encapsulation is the principle of bundling data (attributes) and methods (functions) that operate on the data into a single unit, typically a class. It restricts access to some of an object’s components, which is critical for protecting the integrity of the data and hiding implementation details. Encapsulation is achieved through access modifiers like private, protected, and public.
Example:
class BankAccount:
def __init__(self, account_number, balance):
self.__account_number = account_number # Private attribute
self.__balance = balance
def deposit(self, amount):
if amount > 0:
self.__balance += amount
print(f"Deposited {amount}. New balance is {self.__balance}.")
else:
print("Deposit amount must be positive.")
def withdraw(self, amount):
if 0 < amount <= self.__balance:
self.__balance -= amount
print(f"Withdrew {amount}. Remaining balance is {self.__balance}.")
else:
print("Invalid withdrawal amount.")
def get_balance(self):
return self.__balance
# Example usage
account = BankAccount("12345", 1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance()) # Output: 1300
In this example, encapsulation ensures that the __balance attribute cannot be directly accessed or modified, protecting the account’s integrity.
Inheritance
Inheritance allows a class (child) to inherit attributes and methods from another class (parent), promoting code reuse and hierarchical relationships. However, inheritance must be used judiciously to avoid excessive coupling.
Example:
class Vehicle:
def __init__(self, brand, model):
self.brand = brand
self.model = model
def start(self):
print(f"Starting {self.brand} {self.model}.")
class Car(Vehicle):
def __init__(self, brand, model, doors):
super().__init__(brand, model)
self.doors = doors
def honk(self):
print(f"{self.brand} {self.model} goes 'beep beep'!")
# Example usage
my_car = Car("Toyota", "Corolla", 4)
my_car.start()
my_car.honk()
Polymorphism
Polymorphism allows objects to be treated as instances of their parent class rather than their actual class. This enables the use of a single interface to represent different types.
Example:
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("Woof!")
class Cat(Animal):
def speak(self):
print("Meow!")
# Example usage
animals = [Dog(), Cat()]
for animal in animals:
animal.speak()
Abstraction
Abstraction focuses on exposing only essential details and hiding the implementation. It is typically achieved using abstract classes or interfaces.
Example:
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
@abstractmethod
def perimeter(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
def perimeter(self):
return 2 * (self.width + self.height)
# Example usage
rect = Rectangle(10, 5)
print("Area:", rect.area())
print("Perimeter:", rect.perimeter())
Chapter 3: Core Design Philosophies
Encapsulate What Varies
Encapsulating what varies involves identifying volatile components of a system and isolating them, enabling easier modification without impacting the stable parts. This philosophy lies at the heart of many design patterns, including Strategy and Observer.
Example: Using Strategy Pattern
class PaymentStrategy:
def pay(self, amount):
pass
class CreditCardPayment(PaymentStrategy):
def pay(self, amount):
print(f"Paid {amount} using Credit Card.")
class PayPalPayment(PaymentStrategy):
def pay(self, amount):
print(f"Paid {amount} using PayPal.")
class ShoppingCart:
def __init__(self):
self.items = []
def add_item(self, item):
self.items.append(item)
def calculate_total(self):
return sum(item['price'] for item in self.items)
def checkout(self, payment_strategy):
total = self.calculate_total()
payment_strategy.pay(total)
# Example usage
cart = ShoppingCart()
cart.add_item({'name': 'Laptop', 'price': 1000})
cart.add_item({'name': 'Mouse', 'price': 50})
cart.checkout(CreditCardPayment())
cart.checkout(PayPalPayment())
Program to an Interface, Not an Implementation
This principle ensures that code depends on abstractions rather than specific implementations, making it easier to extend and modify without affecting existing code.
Example:
from abc import ABC, abstractmethod
class NotificationService(ABC):
@abstractmethod
def send_notification(self, message):
pass
class EmailNotification(NotificationService):
def send_notification(self, message):
print(f"Sending Email: {message}")
class SMSNotification(NotificationService):
def send_notification(self, message):
print(f"Sending SMS: {message}")
class NotificationManager:
def __init__(self, service: NotificationService):
self.service = service
def notify(self, message):
self.service.send_notification(message)
# Example usage
email_service = EmailNotification()
sms_service = SMSNotification()
manager = NotificationManager(email_service)
manager.notify("Hello via Email!")
manager = NotificationManager(sms_service)
manager.notify("Hello via SMS!")
Favor Composition Over Inheritance
Favoring composition involves designing systems where objects are composed with behaviors rather than relying on deep inheritance hierarchies. This makes the system more modular and easier to modify.
Example:
class Engine:
def start(self):
print("Engine started.")
class Car:
def __init__(self, engine: Engine):
self.engine = engine
def start(self):
self.engine.start()
print("Car is ready to drive.")
# Example usage
engine = Engine()
car = Car(engine)
car.start()
Chapter 4: The SOLID Design Principles
Single Responsibility Principle (SRP)
A class must have only one responsibility, meaning it should encapsulate a singular concern. This reduces the likelihood of introducing errors when modifying the system. For example:
Example:
class Invoice:
def __init__(self, items, total):
self.items = items
self.total = total
class InvoicePrinter:
def print_invoice(self, invoice: Invoice):
print("Invoice Details:")
for item in invoice.items:
print(f"- {item}")
print(f"Total: {invoice.total}")
# Example usage
invoice = Invoice(["Item1", "Item2"], 100)
printer = InvoicePrinter()
printer.print_invoice(invoice)
Open/Closed Principle (OCP)
Classes should be open for extension but closed for modification. This ensures that new functionality can be added without altering existing code.
Example:
class Discount:
def apply(self, total):
return total
class SeasonalDiscount(Discount):
def apply(self, total):
return total * 0.9
class ClearanceDiscount(Discount):
def apply(self, total):
return total * 0.8
class Cart:
def __init__(self, total):
self.total = total
def apply_discount(self, discount: Discount):
self.total = discount.apply(self.total)
# Example usage
cart = Cart(100)
cart.apply_discount(SeasonalDiscount())
print(cart.total) # Output: 90
Liskov Substitution Principle (LSP)
Subtypes must be substitutable for their base types without altering the correctness of the program. This ensures that derived classes extend functionality without changing the expected behavior.
Example:
class Bird:
def fly(self):
print("This bird can fly.")
class Sparrow(Bird):
def fly(self):
print("Sparrow flying high.")
class Ostrich(Bird):
def fly(self):
raise Exception("Ostriches can't fly.")
# Correct implementation
class FlightlessBird(Bird):
def fly(self):
print("This bird doesn't fly.")
class Penguin(FlightlessBird):
pass
# Example usage
birds = [Sparrow(), Penguin()]
for bird in birds:
bird.fly()
Interface Segregation Principle (ISP)
Clients should not be forced to depend on methods they do not use. This can be achieved by creating smaller, more specific interfaces.
Example:
class Printer:
def print_document(self):
pass
class Scanner:
def scan_document(self):
pass
class AllInOnePrinter(Printer, Scanner):
def print_document(self):
print("Printing document...")
def scan_document(self):
print("Scanning document...")
# Example usage
printer = AllInOnePrinter()
printer.print_document()
printer.scan_document()
Dependency Inversion Principle (DIP)
High-level modules should not depend on low-level modules. Both should depend on abstractions.
Example:
from abc import ABC, abstractmethod
class NotificationService(ABC):
@abstractmethod
def send(self, message):
pass
class EmailService(NotificationService):
def send(self, message):
print(f"Sending Email: {message}")
class SMSService(NotificationService):
def send(self, message):
print(f"Sending SMS: {message}")
class NotificationManager:
def __init__(self, service: NotificationService):
self.service = service
def notify(self, message):
self.service.send(message)
# Example usage
email_service = EmailService()
manager = NotificationManager(email_service)
manager.notify("Hello World")
Chapter 5: Creational Design Patterns
Simple Factory
The Simple Factory pattern centralizes object creation logic, encapsulating the instantiation process within a single factory class. This pattern provides a convenient way to create objects without exposing the underlying instantiation logic to the client.
Example:
class Shape:
def draw(self):
pass
class Circle(Shape):
def draw(self):
print("Drawing a Circle")
class Square(Shape):
def draw(self):
print("Drawing a Square")
class ShapeFactory:
@staticmethod
def create_shape(shape_type):
if shape_type == "circle":
return Circle()
elif shape_type == "square":
return Square()
else:
raise ValueError("Unknown shape type")
# Example usage
shape = ShapeFactory.create_shape("circle")
shape.draw() # Output: Drawing a Circle
Singleton Pattern
The Singleton Pattern ensures that a class has only one instance and provides a global access point to that instance. It is commonly used for managing shared resources such as configuration settings or database connections.
Example:
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if not cls._instance:
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance
# Example usage
singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2) # Output: True
Factory Method Pattern
The Factory Method pattern defines an interface for creating objects but allows subclasses to alter the type of objects that will be created.
Example:
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def draw(self):
pass
class Circle(Shape):
def draw(self):
print("Drawing a Circle")
class Square(Shape):
def draw(self):
print("Drawing a Square")
class ShapeFactory(ABC):
@abstractmethod
def create_shape(self):
pass
class CircleFactory(ShapeFactory):
def create_shape(self):
return Circle()
class SquareFactory(ShapeFactory):
def create_shape(self):
return Square()
# Example usage
factory = CircleFactory()
shape = factory.create_shape()
shape.draw()
Abstract Factory Pattern
The Abstract Factory pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes. This pattern is useful when the client code needs to work with a group of related objects that are designed to work together.
Example:
from abc import ABC, abstractmethod
# Abstract product classes
class Chair(ABC):
@abstractmethod
def sit_on(self):
pass
class Table(ABC):
@abstractmethod
def use(self):
pass
# Concrete product classes
class ModernChair(Chair):
def sit_on(self):
print("Sitting on a modern chair.")
class ModernTable(Table):
def use(self):
print("Using a modern table.")
class VictorianChair(Chair):
def sit_on(self):
print("Sitting on a Victorian chair.")
class VictorianTable(Table):
def use(self):
print("Using a Victorian table.")
# Abstract factory
class FurnitureFactory(ABC):
@abstractmethod
def create_chair(self):
pass
@abstractmethod
def create_table(self):
pass
# Concrete factories
class ModernFurnitureFactory(FurnitureFactory):
def create_chair(self):
return ModernChair()
def create_table(self):
return ModernTable()
class VictorianFurnitureFactory(FurnitureFactory):
def create_chair(self):
return VictorianChair()
def create_table(self):
return VictorianTable()
# Example usage
def create_furniture(factory: FurnitureFactory):
chair = factory.create_chair()
table = factory.create_table()
chair.sit_on()
table.use()
modern_factory = ModernFurnitureFactory()
victorian_factory = VictorianFurnitureFactory()
create_furniture(modern_factory)
create_furniture(victorian_factory)
Builder Pattern
The Builder pattern separates the construction of a complex object from its representation so that the same construction process can create different representations. It is particularly useful when an object has many optional parts.
Example:
# Product class
class House:
def __init__(self):
self.wall_material = None
self.door_type = None
self.num_windows = 0
def __str__(self):
return f"House with {self.wall_material} walls, {self.door_type} door, and {self.num_windows} windows."
# Abstract builder
class HouseBuilder:
def set_wall_material(self, material):
pass
def set_door_type(self, door_type):
pass
def set_num_windows(self, count):
pass
def build(self):
pass
# Concrete builder
class ConcreteHouseBuilder(HouseBuilder):
def __init__(self):
self.house = House()
def set_wall_material(self, material):
self.house.wall_material = material
def set_door_type(self, door_type):
self.house.door_type = door_type
def set_num_windows(self, count):
self.house.num_windows = count
def build(self):
return self.house
# Director
class HouseDirector:
def __init__(self, builder: HouseBuilder):
self.builder = builder
def construct(self):
self.builder.set_wall_material("brick")
self.builder.set_door_type("wooden")
self.builder.set_num_windows(4)
return self.builder.build()
# Example usage
builder = ConcreteHouseBuilder()
director = HouseDirector(builder)
house = director.construct()
print(house) # Output: House with brick walls, wooden door, and 4 windows.
Chapter 6: Structural Design Patterns
Structural design patterns focus on how objects and classes are composed to form larger structures while keeping these structures flexible and efficient. These patterns streamline relationships between different entities, improving code readability and maintainability.
Adapter Pattern
The Adapter pattern bridges the gap between incompatible interfaces by converting one interface into another that a client expects. It is particularly useful when integrating old code with new systems.
Example:
class OldSystem:
def specific_request(self):
return "Old system functionality"
class Target:
def request(self):
pass
class Adapter(Target):
def __init__(self, adaptee):
self.adaptee = adaptee
def request(self):
return self.adaptee.specific_request()
# Example usage
old_system = OldSystem()
adapter = Adapter(old_system)
print(adapter.request()) # Output: Old system functionality
Bridge Pattern
The Bridge pattern decouples an abstraction from its implementation, allowing them to vary independently. This pattern is particularly helpful in scenarios where a class has multiple dimensions of variability.
Example:
class Renderer:
def render_circle(self, radius):
pass
class VectorRenderer(Renderer):
def render_circle(self, radius):
print(f"Drawing a circle with radius {radius} using vector rendering.")
class RasterRenderer(Renderer):
def render_circle(self, radius):
print(f"Drawing a circle with radius {radius} using raster rendering.")
class Shape:
def __init__(self, renderer):
self.renderer = renderer
def draw(self):
pass
class Circle(Shape):
def __init__(self, renderer, radius):
super().__init__(renderer)
self.radius = radius
def draw(self):
self.renderer.render_circle(self.radius)
# Example usage
vector_renderer = VectorRenderer()
raster_renderer = RasterRenderer()
circle = Circle(vector_renderer, 5)
circle.draw() # Output: Drawing a circle with radius 5 using vector rendering.
circle.renderer = raster_renderer
circle.draw() # Output: Drawing a circle with radius 5 using raster rendering.
Composite Pattern
The Composite pattern allows you to compose objects into tree structures to represent part-whole hierarchies. It enables clients to treat individual objects and compositions uniformly.
Example:
class Component:
def operation(self):
pass
class Leaf(Component):
def __init__(self, name):
self.name = name
def operation(self):
print(f"Leaf {self.name} operation.")
class Composite(Component):
def __init__(self):
self.children = []
def add(self, component):
self.children.append(component)
def remove(self, component):
self.children.remove(component)
def operation(self):
print("Composite operation begins.")
for child in self.children:
child.operation()
print("Composite operation ends.")
# Example usage
leaf1 = Leaf("A")
leaf2 = Leaf("B")
composite = Composite()
composite.add(leaf1)
composite.add(leaf2)
composite.operation()
Decorator Pattern
The Decorator pattern dynamically adds behavior or responsibilities to objects without modifying their code. This pattern is ideal for adhering to the Open/Closed Principle.
Example:
class Coffee:
def cost(self):
return 5
def description(self):
return "Plain coffee"
class MilkDecorator:
def __init__(self, coffee):
self.coffee = coffee
def cost(self):
return self.coffee.cost() + 2
def description(self):
return self.coffee.description() + ", Milk"
class SugarDecorator:
def __init__(self, coffee):
self.coffee = coffee
def cost(self):
return self.coffee.cost() + 1
def description(self):
return self.coffee.description() + ", Sugar"
# Example usage
coffee = Coffee()
milk_coffee = MilkDecorator(coffee)
sugar_milk_coffee = SugarDecorator(milk_coffee)
print(sugar_milk_coffee.description()) # Output: Plain coffee, Milk, Sugar
print(sugar_milk_coffee.cost()) # Output: 8
Facade Pattern
The Facade pattern provides a simplified interface to a complex subsystem, making it easier for clients to interact with the system.
Example:
class SubsystemA:
def operation_a(self):
print("Subsystem A operation.")
class SubsystemB:
def operation_b(self):
print("Subsystem B operation.")
class Facade:
def __init__(self):
self.subsystem_a = SubsystemA()
self.subsystem_b = SubsystemB()
def operation(self):
print("Facade simplifies subsystem operations.")
self.subsystem_a.operation_a()
self.subsystem_b.operation_b()
# Example usage
facade = Facade()
facade.operation()
Flyweight Pattern
The Flyweight pattern reduces memory usage by sharing common parts of object states rather than creating new objects for each state.
Example:
class Flyweight:
def __init__(self, shared_state):
self.shared_state = shared_state
def operation(self, unique_state):
print(f"Shared: {self.shared_state}, Unique: {unique_state}")
class FlyweightFactory:
def __init__(self):
self.flyweights = {}
def get_flyweight(self, shared_state):
if shared_state not in self.flyweights:
self.flyweights[shared_state] = Flyweight(shared_state)
return self.flyweights[shared_state]
# Example usage
factory = FlyweightFactory()
flyweight1 = factory.get_flyweight("State1")
flyweight2 = factory.get_flyweight("State1")
flyweight1.operation("Unique1")
flyweight2.operation("Unique2")
print(flyweight1 is flyweight2) # Output: True
Proxy Pattern
The Proxy pattern provides a surrogate or placeholder object to control access to another object. It is useful for adding security or caching functionality.
Example:
class RealSubject:
def request(self):
print("RealSubject: Handling request.")
class Proxy:
def __init__(self, real_subject):
self.real_subject = real_subject
def request(self):
print("Proxy: Checking access before forwarding the request.")
self.real_subject.request()
# Example usage
real_subject = RealSubject()
proxy = Proxy(real_subject)
proxy.request()
Chapter 7: Behavioral Design Patterns
Behavioral design patterns focus on communication between objects. They help define how objects interact, delegate responsibilities, and ensure flexibility in executing complex behaviors.
Chain of Responsibility Pattern
The Chain of Responsibility pattern decouples the sender and receiver of a request by passing the request along a chain of handlers. Each handler decides whether to process the request or pass it to the next handler.
Example:
class Handler:
def __init__(self, successor=None):
self.successor = successor
def handle_request(self, request):
if self.successor:
self.successor.handle_request(request)
class ConcreteHandlerA(Handler):
def handle_request(self, request):
if request == "A":
print("Handler A processed the request.")
elif self.successor:
self.successor.handle_request(request)
class ConcreteHandlerB(Handler):
def handle_request(self, request):
if request == "B":
print("Handler B processed the request.")
elif self.successor:
self.successor.handle_request(request)
# Example usage
handler_chain = ConcreteHandlerA(ConcreteHandlerB())
handler_chain.handle_request("A") # Output: Handler A processed the request.
handler_chain.handle_request("B") # Output: Handler B processed the request.
Command Pattern
The Command pattern encapsulates a request as an object, allowing clients to parameterize objects with different requests, delay execution, or queue requests.
Example:
class Command:
def execute(self):
pass
class Light:
def turn_on(self):
print("Light is ON")
def turn_off(self):
print("Light is OFF")
class TurnOnCommand(Command):
def __init__(self, light):
self.light = light
def execute(self):
self.light.turn_on()
class TurnOffCommand(Command):
def __init__(self, light):
self.light = light
def execute(self):
self.light.turn_off()
class RemoteControl:
def __init__(self):
self.command = None
def set_command(self, command):
self.command = command
def press_button(self):
self.command.execute()
# Example usage
light = Light()
turn_on = TurnOnCommand(light)
turn_off = TurnOffCommand(light)
remote = RemoteControl()
remote.set_command(turn_on)
remote.press_button() # Output: Light is ON
remote.set_command(turn_off)
remote.press_button() # Output: Light is OFF
Observer Pattern
The Observer pattern establishes a one-to-many dependency between objects so that when one object changes state, all its dependents are notified.
Example:
class Subject:
def __init__(self):
self.observers = []
def attach(self, observer):
self.observers.append(observer)
def detach(self, observer):
self.observers.remove(observer)
def notify(self):
for observer in self.observers:
observer.update()
class ConcreteObserver:
def __init__(self, name):
self.name = name
def update(self):
print(f"{self.name} received an update.")
# Example usage
subject = Subject()
observer1 = ConcreteObserver("Observer 1")
observer2 = ConcreteObserver("Observer 2")
subject.attach(observer1)
subject.attach(observer2)
subject.notify()
# Output:
# Observer 1 received an update.
# Observer 2 received an update.
Strategy Pattern
The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This pattern enables the algorithm to vary independently from the clients that use it.
Example:
class Strategy:
def execute(self):
pass
class ConcreteStrategyA(Strategy):
def execute(self):
print("Executing Strategy A")
class ConcreteStrategyB(Strategy):
def execute(self):
print("Executing Strategy B")
class Context:
def __init__(self, strategy):
self.strategy = strategy
def set_strategy(self, strategy):
self.strategy = strategy
def execute_strategy(self):
self.strategy.execute()
# Example usage
context = Context(ConcreteStrategyA())
context.execute_strategy() # Output: Executing Strategy A
context.set_strategy(ConcreteStrategyB())
context.execute_strategy() # Output: Executing Strategy B
State Pattern
The State pattern allows an object to alter its behavior when its internal state changes. The object appears to change its class.
Example:
class State:
def handle(self):
pass
class ConcreteStateA(State):
def handle(self):
print("Handling State A")
class ConcreteStateB(State):
def handle(self):
print("Handling State B")
class Context:
def __init__(self, state):
self.state = state
def set_state(self, state):
self.state = state
def request(self):
self.state.handle()
# Example usage
state_a = ConcreteStateA()
state_b = ConcreteStateB()
context = Context(state_a)
context.request() # Output: Handling State A
context.set_state(state_b)
context.request() # Output: Handling State B
Interpreter Pattern
The Interpreter pattern defines a grammar and provides a way to interpret sentences in that grammar. This is often used for parsing or evaluating expressions.
Example:
class Expression:
def interpret(self, context):
pass
class Number(Expression):
def __init__(self, value):
self.value = value
def interpret(self, context):
return self.value
class Add(Expression):
def __init__(self, left, right):
self.left = left
self.right = right
def interpret(self, context):
return self.left.interpret(context) + self.right.interpret(context)
class Subtract(Expression):
def __init__(self, left, right):
self.left = left
self.right = right
def interpret(self, context):
return self.left.interpret(context) - self.right.interpret(context)
# Example usage
context = {}
expression = Add(Number(5), Subtract(Number(10), Number(3)))
print(expression.interpret(context)) # Output: 12
Iterator Pattern
The Iterator pattern provides a way to access elements of a collection sequentially without exposing its underlying representation.
Example:
class Iterator:
def __init__(self, collection):
self.collection = collection
self.index = 0
def has_next(self):
return self.index < len(self.collection)
def next(self):
if self.has_next():
value = self.collection[self.index]
self.index += 1
return value
raise StopIteration
# Example usage
collection = [1, 2, 3, 4, 5]
iterator = Iterator(collection)
while iterator.has_next():
print(iterator.next())
Mediator Pattern
The Mediator pattern centralizes complex communication between objects, promoting loose coupling.
Example:
class Mediator:
def notify(self, sender, event):
pass
class ConcreteMediator(Mediator):
def __init__(self, component1, component2):
self.component1 = component1
self.component1.mediator = self
self.component2 = component2
self.component2.mediator = self
def notify(self, sender, event):
if event == "A":
print("Mediator reacts to event A and triggers component2.")
self.component2.do_c()
elif event == "B":
print("Mediator reacts to event B and triggers component1.")
self.component1.do_a()
class Component:
def __init__(self):
self.mediator = None
class Component1(Component):
def do_a(self):
print("Component1 does A.")
self.mediator.notify(self, "A")
class Component2(Component):
def do_c(self):
print("Component2 does C.")
# Example usage
component1 = Component1()
component2 = Component2()
mediator = ConcreteMediator(component1, component2)
component1.do_a()
Memento Pattern
The Memento pattern captures and restores an object’s internal state without violating encapsulation.
Example:
class Memento:
def __init__(self, state):
self.state = state
class Originator:
def __init__(self):
self.state = None
def set_state(self, state):
self.state = state
def save_to_memento(self):
return Memento(self.state)
def restore_from_memento(self, memento):
self.state = memento.state
class Caretaker:
def __init__(self):
self.mementos = []
def add_memento(self, memento):
self.mementos.append(memento)
def get_memento(self, index):
return self.mementos[index]
# Example usage
originator = Originator()
caretaker = Caretaker()
originator.set_state("State1")
caretaker.add_memento(originator.save_to_memento())
originator.set_state("State2")
caretaker.add_memento(originator.save_to_memento())
originator.restore_from_memento(caretaker.get_memento(0))
print(originator.state) # Output: State1
Template Method Pattern
The Template Method pattern defines the skeleton of an algorithm in a base class while allowing subclasses to redefine specific steps of the algorithm.
Example:
class AbstractClass:
def template_method(self):
self.step_one()
self.step_two()
self.step_three()
def step_one(self):
print("AbstractClass: Step One")
def step_two(self):
pass
def step_three(self):
print("AbstractClass: Step Three")
class ConcreteClassA(AbstractClass):
def step_two(self):
print("ConcreteClassA: Step Two")
class ConcreteClassB(AbstractClass):
def step_two(self):
print("ConcreteClassB: Step Two")
# Example usage
a = ConcreteClassA()
b = ConcreteClassB()
a.template_method()
# Output:
# AbstractClass: Step One
# ConcreteClassA: Step Two
# AbstractClass: Step Three
b.template_method()
# Output:
# AbstractClass: Step One
# ConcreteClassB: Step Two
# AbstractClass: Step Three
Visitor Pattern
The Visitor pattern allows you to add new operations to a class hierarchy without modifying the classes.
Example:
class Visitor:
def visit(self, element):
pass
class ConcreteVisitor(Visitor):
def visit(self, element):
print(f"Visiting {element.name}")
class Element:
def accept(self, visitor):
pass
class ConcreteElementA(Element):
def __init__(self):
self.name = "Element A"
def accept(self, visitor):
visitor.visit(self)
class ConcreteElementB(Element):
def __init__(self):
self.name = "Element B"
def accept(self, visitor):
visitor.visit(self)
# Example usage
elements = [ConcreteElementA(), ConcreteElementB()]
visitor = ConcreteVisitor()
for element in elements:
element.accept(visitor)
# Output:
# Visiting Element A
# Visiting Element B
Enjoy Reading This Article?
Here are some more articles you might like to read next: