设计模式-python版本：Python语言的常见设计模式

设计模式是一种在软件工程中常用的方式，可以解决一些常见的软件设计问题。在Python中，也有很多常见的设计模式。本文将介绍一些常用的Python设计模式，包括工厂模式、单例模式、装饰器模式等。

1. 工厂模式

工厂模式是一种常用的创建型模式，用于创建对象。在Python中，可以使用类方法或静态方法来实现工厂模式。

例如，下面是一个创建动物的工厂类：

```python
class AnimalFactory:
    @classmethod
    def create_animal(cls, animal_type):
        if animal_type == 'cat':
            return Cat()
        elif animal_type == 'dog':
            return Dog()
        else:
            raise ValueError('Invalid animal type')
```

使用工厂模式可以将创建对象的代码与主要逻辑分离，从而更好地维护和修改代码。

2. 单例模式

单例模式是一种创建型模式，用于确保一个类只有一个实例。在Python中，可以使用装饰器或元类来实现单例模式。

下面是一个使用装饰器实现单例模式的示例：

```python
def singleton(cls):
    instances = {}

    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return get_instance

@singleton
class MySingleton:
    pass
```

在上面的示例中，我们定义了一个装饰器函数`singleton`，该函数将类封装在闭包中，并通过`instances`字典来管理实例。装饰器函数返回`get_instance`函数，该函数在需要创建类实例时会自动检查实例是否已经存在，如果实例不存在，则创建一个新实例。这样可以确保每次只有一个类实例。

3. 装饰器模式

装饰器模式是一种结构型模式，用于在不修改原始对象代码的情况下，动态地添加额外的功能。

例如，我们可以使用装饰器模式来在不影响原始函数的情况下，动态地添加日志记录功能：

```python
def log(func):
    def wrapper(*args, **kwargs):
        print('Calling function:', func.__name__)
        return func(*args, **kwargs)
    return wrapper

@log
def my_function():
    print('Hello, world!')

my_function()
```

在上面的示例中，我们定义了一个装饰器函数`log`，该函数接收一个函数作为参数，并返回一个新的函数`wrapper`，该函数在调用原始函数之前打印一条日志。我们使用`@log`装饰器来修饰`my_function`函数，这样在调用`my_function`函数时，将自动添加日志记录功能。

4. 观察者模式

观察者模式是一种行为型模式，用于在对象之间建立一对多的依赖关系，每当一个对象发生变化时，所有依赖它的对象都将得到通知。

在Python中，可以使用内置的`Observable`类和`Observer`类来实现观察者模式。例如，下面是一个使用内置观察者模式实现的示例：

```python
from typing import List, Tuple
from abc import ABC, abstractmethod

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

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

    def detach(self, observer):
        self._observers.remove(observer)

    def notify_observers(self, *args, **kwargs):
        for observer in self._observers:
            observer.update(self, *args, **kwargs)

class Observer(ABC):
    @abstractmethod
    def update(self, observable, *args, **kwargs):
        pass

class TemperatureSensor(Observable):
    def __init__(self):
        super().__init__()
        self._temperature = 0

    @property
    def temperature(self):
        return self._temperature

    @temperature.setter
    def temperature(self, value):
        self._temperature = value
        self.notify_observers()

class TemperatureDisplay(Observer):
    def update(self, observable, *args, **kwargs):
        if isinstance(observable, TemperatureSensor):
            temperature = observable.temperature
            print(f'The temperature is {temperature} degrees Celsius.')

sensor = TemperatureSensor()
display1 = TemperatureDisplay()
display2 = TemperatureDisplay()

sensor.attach(display1)
sensor.attach(display2)

sensor.temperature = 25
```

在上面的示例中，我们定义了一个`Observable`类和一个`Observer`类，用于实现观察者模式。我们还定义了一个`TemperatureSensor`类，该类继承了`Observable`类，通过设置温度来通知所有依赖它的观察者。我们还定义了一个`TemperatureDisplay`类，该类继承了`Observer`类，用于打印温度。

在示例中，我们创建了一个`TemperatureSensor`实例和两个`TemperatureDisplay`实例，并将它们添加为`TemperatureSensor`的观察者。当`TemperatureSensor`的温度发生变化时，所有观察者都会收到通知，并打印温度。

以上是常用的几种Python设计模式，掌握这些设计模式可以更好地编写高效、可维护的Python代码。