Python编程高手通常熟练运用各种设计模式，这些设计模式有助于提高代码的可维护性、可扩展性和重用性。

以下是一些Python编程高手常用的设计模式：

1.单例模式（Singleton Pattern）

确保一个类只有一个实例，并提供全局访问点。适用于需要共享资源或控制特定资源访问的情景。

class Singleton(object):_instance = Nonedef __new__(cls):if not cls._instance:cls._instance = super().__new__(cls)return cls._instances1 = Singleton()
s2 = Singleton()
print(id(s1))
print(id(s2)) # s1和s2的ID应该是一样的，表明这是同一个对象

其他实现单例模式的方法。

1.1 使用模块级别的变量实现单例模式

# singleton_module.pyclass Singleton:def __init__(self):self.value = Nonedef set_value(self, value):self.value = valuedef get_value(self):return self.valuesingleton_instance = Singleton()

Python模块在程序中只会被导入一次，因此模块级别的变量可以实现单例模式。

在其他文件中，可以通过导入singleton_module模块来获取单例对象：

# main.pyfrom singleton_module import singleton_instance# 使用单例对象
singleton_instance.set_value(42)
print(singleton_instance.get_value())

1.2 使用类装饰器实现单例模式

可以使用装饰器来确保类只有一个实例，并通过装饰器在需要时创建实例。

# singleton_decorator.pydef 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 Singleton:def __init__(self):self.value = Nonedef set_value(self, value):self.value = valuedef get_value(self):return self.value

在这种方式下，可以直接使用@singleton装饰器标记一个类为单例，然后通过类的实例获取单例对象：

# main.pyfrom singleton_decorator import Singleton# 使用单例对象
singleton_instance = Singleton()
singleton_instance.set_value(42)
print(singleton_instance.get_value())

2. 工厂模式（Factory Pattern）

1.  定义一个接口，但由子类决定实例化哪个类。工厂方法模式将类的实例化延迟到子类。

   
   class Product(ABC):@abstractmethoddef create_product(self):passclass ConcreteProductA(Product):def create_product(self):return "Product A"class ConcreteProductB(Product):def create_product(self):return "Product B"

   3.观察者模式（Observer Pattern）

from abc import ABC, abstractmethodclass Observer(ABC):@abstractmethoddef update(self, message):passclass ConcreteObserver(Observer):def update(self, message):print(f"Received message: {message}")class Subject:_observers = []def add_observer(self, observer):self._observers.append(observer)def remove_observer(self, observer):self._observers.remove(observer)def notify_observers(self, message):for observer in self._observers:observer.update(message)

​​​​​​4. 策略模式（Strategy Pattern）

1. 定义一系列算法，将每个算法封装起来，并使它们可以互换。策略模式可以使算法独立于客户端而变化。

   from abc import ABC, abstractmethodclass Strategy(ABC):@abstractmethoddef execute(self):passclass ConcreteStrategyA(Strategy):def execute(self):return "Strategy A"class ConcreteStrategyB(Strategy):def execute(self):return "Strategy B"class Context:def __init__(self, strategy):self._strategy = strategydef execute_strategy(self):return self._strategy.execute()

5.装饰器模式（Decorator Pattern）

1.  动态地给一个对象添加一些额外的职责，装饰模式比继承更加灵活。

   from abc import ABC, abstractmethodclass Component(ABC):@abstractmethoddef operation(self):passclass ConcreteComponent(Component):def operation(self):return "Concrete Component"class Decorator(Component):_component = Nonedef __init__(self, component):self._component = componentdef operation(self):return self._component.operation()class ConcreteDecorator(Decorator):def operation(self):return f"{super().operation()}, Decorated"