Design Patterns in Python

Introduction

Design patterns are reusable solutions to common software design problems. They are like templates that can be applied to solve specific problems in software architecture.

What Are Design Patterns?

Design patterns provide a standardized approach to software design, helping developers communicate more effectively and enhancing code maintainability.

Creational Patterns

Creational patterns deal with object creation mechanisms, aiming to create objects in a manner suitable to the situation.

Singleton Pattern

The Singleton pattern ensures a class has only one instance and provides a global point of access to it.

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

singleton1 = Singleton()
singleton2 = Singleton()

print(singleton1 is singleton2)  # Output: True
                

Structural Patterns

Structural patterns focus on how classes and objects are composed to form larger structures.

Adapter Pattern

The Adapter pattern allows incompatible interfaces to work together.

class EuropeanPlug:
    def connect(self):
        return "European plug connected."

class USAPowerSocket:
    def connect_to_us_socket(self):
        return "USA socket connected."

class Adapter(EuropeanPlug, USAPowerSocket):
    def connect(self):
        return self.connect_to_us_socket()

adapter = Adapter()
print(adapter.connect())  # Output: USA socket connected.
                

Behavioral Patterns

Behavioral patterns are concerned with algorithms and the assignment of responsibilities between objects.

Observer Pattern

The Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

class Subject:
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        self._observers.append(observer)

    def notify(self):
        for observer in self._observers:
            observer.update()

class Observer:
    def update(self):
        print("Observer has been notified.")

subject = Subject()
observer = Observer()
subject.attach(observer)
subject.notify()  # Output: Observer has been notified.
                

Best Practices

When implementing design patterns, consider the following best practices:

• Understand the problem domain before applying patterns.
• Don't overuse design patterns; use them when necessary.
• Document the intention behind using a pattern for future reference.
• Consider performance implications when implementing patterns.

FAQ