Design patterns are proven solutions to common problems in software development. They provide a reusable template for solving design problems, thereby improving the maintainability and flexibility of the code.

But with so many design patterns available, how do you know which one to implement in Python for a given problem? In this article, we'll explore the steps for choosing the right design pattern and provide examples of each to help you understand and apply them effectively.

1. Understand the problem

The first step in choosing a design pattern is to clearly understand the problem you are trying to solve. Ask yourself the following questions:

What is the expected behavior?
What are the constraints of the system?
What are the possible points of extension or variation?

2. Categorize the design pattern

Design patterns are generally classified into three categories:

Creational: Concerns the creation of objects.
Structural: Concerns the composition of objects.
Behavioral: Concerns interactions between objects.
Identifying the category that matches your issue can help narrow down the number of relevant patterns.

3. Choose the appropriate design pattern

After understanding the problem and its category, review the design patterns in that category to find the one that best fits your situation. Consider the following:

Flexibility: Does the pattern offer the necessary flexibility?
Complexity: Doesn’t it introduce unnecessary complexity?
Extensibility: Does it make future extensions easier?

1. Examples of design patterns in Python Singleton When to use it? When you need to ensure that a class has only one instance and provide a global access point to that instance.

Example in Python:
`class SingletonMeta(type):
_instance = {}

def __call__(cls, *args, **kwargs):
    if cls not in cls._instance:
        cls._instance[cls] = super().__call__(*args, **kwargs)
    return cls._instance[cls]

class Logger(metaclass=SingletonMeta):
def log(self, message):
print(f"[LOG]: {message}")

Use

logger1 = Logger()
logger2 = Logger()

print(logger1 is logger2) # Output: True

logger1.log("Singleton pattern in action.")
`
Why does it work?
The SingletonMeta is a metaclass that controls the creation of Logger instances. If an instance already exists, it is returned, ensuring that there is only one instance.

Factory
When to use it?
When you have a parent class with multiple child classes and based on the input data you need to return one of the child classes.

Example in Python:
`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.")

def shape_factory(shape_type):
if shape_type == "circle":
return Circle()
elif shape_type == "square":
return Square()
else:
raise ValueError("Unknown shape type.")

Use

shape = shape_factory("circle")
shape.draw() # Output: Drawing a circle.
`
Why does it work?
The factory encapsulates the object creation logic, allowing instances to be created without exposing the underlying logic.

Observe
When to use it?
When you have one object (the subject) that needs to notify multiple other objects (observers) when a state change occurs.

Example in Python:
`class Subject:
def init(self):
self._observers = []

def __call__(cls, *args, **kwargs):
    if cls not in cls._instance:
        cls._instance[cls] = super().__call__(*args, **kwargs)
    return cls._instance[cls]

class Observer:
def update(self, message):
pass

class EmailObserver(Observer):
def update(self, message):
print(f"Email notification: {message}")

class SMSObserver(Observer):
def update(self, message):
print(f"SMS notification: {message}")

Use

subject = Subject()
subject.attach(EmailObserver())
subject.attach(SMSObserver())

subject.notify("Observer pattern implemented.")
`
Why does it work?
The subject maintains a list of observers and notifies them of changes, allowing decoupled communication.
Strategy
When to use it?
When you have multiple algorithms to perform a task and you want to interchange them dynamically.

Example in Python:
`import types

class TextProcessor:
def init(self, formatter):
self.formatter = types.MethodType(formatter, self)

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

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

def uppercase_formatter(self, text):
return text.upper()

def lowercase_formatter(self, text):
return text.lower()

Use

processor = TextProcessor(uppercase_formatter)
print(processor.process("Hello World")) # Output: HELLO WORLD

processor.formatter = types.MethodType(lowercase_formatter, processor)
print(processor.process("Hello World")) # Output: hello world
`
Why does it work?
The Strategy pattern allows you to change the algorithm used by an object on the fly, by assigning a new function to format.

Decorator
When to use it?
When you want to dynamically add new functionality to an object without changing its structure.

Example in Python:
`def bold_decorator(func):
def wrapper():
return "" func() ""
return wrapper

def italic_decorator(func):
def wrapper():
return "" func() ""
return wrapper

@bold_decorator
@italic_decorator
def say_hello():
return "Hello"

Use

print(say_hello()) # Output: Hello
`

Why does it work?
Decorators allow you to wrap a function to add functionality, such as formatting here, without modifying the original function.

Adapt
When to use it?
When you need to use an existing class but its interface doesn't match your needs.

Example in Python:
`class EuropeanSocketInterface:
def voltage(self): pass
def live(self): pass
def neutral(self): pass

class EuropeanSocket(EuropeanSocketInterface):
def voltage(self):
return 230

def __call__(cls, *args, **kwargs):
    if cls not in cls._instance:
        cls._instance[cls] = super().__call__(*args, **kwargs)
    return cls._instance[cls]

class USASocketInterface:
def voltage(self): pass
def live(self): pass
def neutral(self): pass

class Adapter(USASocketInterface):
def init(self, european_socket):
self.european_socket = european_socket

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

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

Use

euro_socket = EuropeanSocket()
adapter = Adapter(euro_socket)
print(f"Voltage: {adapter.voltage()}V") # Output: Voltage: 110V
`
adapter translates the interface of a class into another interface that the client expects, allowing compatibility between incompatible interfaces.

Command
When to use it?
When you want to encapsulate a request as an object, allowing you to configure clients with different requests, queues or logging.

Example in Python:
`class Command:
def execute(self):
pass

class LightOnCommand(Command):
def init(self, light):
self.light = light

def process(self, text):
    return self.formatter(text)

class LightOffCommand(Command):
def init(self, light):
self.light = light

def live(self):
    return 1

def neutral(self):
    return -1

class Light:
def turn_on(self):
print("Light turned ON")

def voltage(self):
    return 110

def live(self):
    return self.european_socket.live()

def neutral(self):
    return self.european_socket.neutral()

class RemoteControl:
def submit(self, command):
command.execute()

Use

light = Light()
on_command = LightOnCommand(light)
off_command = LightOffCommand(light)

remote = RemoteControl()
remote.submit(on_command) # Output: Light turned ON
remote.submit(off_command) # Output: Light turned OFF
`
Why does it work?
The Command pattern transforms an operation into an object, allowing actions to be configured, queued or canceled.

5. Conclusion

Choosing the right design pattern in Python requires a clear understanding of the problem to be solved and the patterns available. By categorizing the problem and analyzing the benefits of each pattern, you can select the one that offers the most effective solution.

Remember that design patterns are tools to improve your code, not strict rules to follow. Use them wisely to write clean, maintainable, and scalable Python code.

6. Additional Resources

Books:
Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma et al.
Head First Design Patterns by Eric Freeman and Elisabeth Robson.
Websites:
Refactoring.Guru
Dive Into Design Patterns
Thanks for reading! Feel free to share your experiences with Python design patterns in the comments.

The above is the detailed content of How to choose the right design pattern in Python, with examples. For more information, please follow other related articles on the PHP Chinese website!