Design Patterns in Python

Certain design problems repeatedly appear when building software: object creation, behaviour delegation, and component decoupling.

Design patterns: time-tested, reusable solutions that offer clarity, structure, and scalability.

I'm a software engineer who's helped teams ship reliable, maintainable systems at scale. In this guide, I'll walk you through core design patterns structured for Python developers with zero fluff—just value.

Understanding these patterns will sharpen your design thinking and improve your architecture, whether you're developing microservices, Apis, or platforms.

What Are Design Patterns?

Design patterns are general, proven, reusable solutions to common software design problems.

They were introduced in the book Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma and three other authors in 1994—collectively known as the Gang of Four (GoF).

These patterns are independent of programming language but are widely applicable in any object-oriented system, including Python.

The Gamma Categorization of Design Patterns

The 3 categories are based on:-

Purpose
Structure

Creational Design Patterns

Handle the mechanisms of object creation. i.e. abstracting the instantiation process leading to code that is:

- more decoupled &
- more flexible.

Builder – Constructs complex objects step-by-step.
Factory Method – Allows subclasses to decide which object to instantiate.
Abstract Factory – Creates families of related objects without specifying their classes.
Prototype – Clones existing objects instead of creating new ones from scratch.
Singleton – Ensures a class has only one instance globally.

Structural Patterns

Define how classes and objects are composed to form larger structures.

Adapter – Transforms one interface into another, as expected by clients.
Bridge – Separates abstraction from its implementation so they can vary independently.
Composite – Composes objects into tree structures to represent part-whole hierarchies.
Decorator – Adds responsibilities to objects dynamically without altering their structure.
Facade – Provides a simplified interface to a complex subsystem.
Flyweight – Reduces memory usage by sharing common object data.
Proxy – Controls access to another object, adding a level of indirection.

Behavioural Patterns

Focus on how objects interact and share responsibilities, i.e., communication between objects.

Chain of Responsibility – Pass requests along a chain of handlers until one handles it.
Command – Encapsulates a request as an object, allowing for parameterization and queuing.
Interpreter – Defines the grammar of a language and interprets sentences in that language.
Iterator – Provides a way to access elements of a collection sequentially without exposing its structure.
Mediator – Centralizes communication between objects, promoting loose coupling.
Memento – Captures an object's internal state so it can be restored later without violating encapsulation.
Observer – Notifies multiple objects about state changes in a subject.
State – Allows an object to alter its behaviour when its internal state changes.
Strategy – Enables selecting an algorithm at runtime by encapsulating interchangeable behaviours.
Template Method – Defines the program skeleton in a base class but lets subclasses override specific steps.
Visitor – Adds operations to objects without changing their classes.

SOLID Principles: The Foundation of Clean Design

Before we explore patterns, let's look at the SOLID principles, introduced by Robert C.

Design patterns become easier to apply when your architecture follows SOLID principles, a set of five design rules that make code easier to understand and maintain.

Single Responsibility Principle (SRP)

Each class should have only one reason to change.

class InvoicePrinter:
    def print(self, invoice):
        print(f"Printing invoice #{invoice.id}")

This class only handles invoice printing, so there is no saving or emailing.

Open/Closed Principle (OCP)

Classes are open for extension but closed for modification.

class Shape:
    def area(self):
        pass

class Circle(Shape):

    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

You can extend functionality (e.g. add new shapes) without altering existing code.

Liskov Substitution Principle (LSP)

Any Subclasses substitutes their base classes without breaking functionality.

def get_area(shape: Shape):
    return shape.area()

All subclasses must honour the contract of the base class. For example, all subclasses of Shape must correctly implement area().

Interface Segregation Principle (ISP)

Avoid forcing clients to depend on interfaces they don't use -avoid fat interfaces. Instead, split them into smaller, specific ones.

class Printer:
    def print(self):
        pass

class Scanner:
    def scan(self):
        pass

Dependency Inversion Principle (DIP)

Depends on abstractions, not concrete implementations.

class NotificationService:
    def __init__(self, messenger):
        self.messenger = messenger

    def notify(self, message):
        self.messenger.send(message)

It improves flexibility and allows for easy substitution or mocking in tests.

What pattern do you need?

Practice identifying problems and patterns that solve them effectively.

When to use design patterns?

Designing scalable architectures
Refactoring legacy code
Writing cleaner interfaces
Communicating ideas across teams

Where to Go from Here: Build Pattern Awareness

Pick a category—Creational, Structural, or Behavioral—and study 2–3 patterns.
Try applying one to your next project module or microservice.
Read and refactor: Identify patterns in open-source projects or popular frameworks.

Design patterns are a practical way to improve your software design. Want to explore them further? Explore our Design Pattern Repository for real-world use cases and examples.

Let's keep writing better software—one pattern at a time!

Design Patterns