Python编程高手通常熟练运用各种设计模式，这些设计模式有助于提高代码的可维护性、可扩展性和重用性。
以下是一些Python编程高手常用的设计模式：
1.单例模式（Singleton Pattern）
确保一个类只有一个实例，并提供全局访问点。适用于需要共享资源或控制特定资源访问的情景。
class Singleton(object):
_instance = None
def __new__(cls):
if not cls._instance:
cls._instance = super().__new__(cls)
return cls._instance
s1 = Singleton()
s2 = Singleton()
print(id(s1))
print(id(s2)) # s1和s2的ID应该是一样的，表明这是同一个对象
其他实现单例模式的方法。
1.1 使用模块级别的变量实现单例模式
# singleton_module.py
class Singleton:
def __init__(self):
self.value = None
def set_value(self, value):
self.value = value
def get_value(self):
return self.value
singleton_instance = Singleton()
Python模块在程序中只会被导入一次，因此模块级别的变量可以实现单例模式。
在其他文件中，可以通过导入singleton_module模块来获取单例对象：
# main.py
from singleton_module import singleton_instance
# 使用单例对象
singleton_instance.set_value(42)
print(singleton_instance.get_value())
1.2 使用类装饰器实现单例模式
可以使用装饰器来确保类只有一个实例，并通过装饰器在需要时创建实例。
# singleton_decorator.py
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 Singleton:
def __init__(self):
self.value = None
def set_value(self, value):
self.value = value
def get_value(self):
return self.value
在这种方式下，可以直接使用@singleton装饰器标记一个类为单例，然后通过类的实例获取单例对象：
# main.py
from singleton_decorator import Singleton
# 使用单例对象
singleton_instance = Singleton()
singleton_instance.set_value(42)
print(singleton_instance.get_value())
2. 工厂模式（Factory Pattern）
-
定义一个接口，但由子类决定实例化哪个类。工厂方法模式将类的实例化延迟到子类。
class Product(ABC): @abstractmethod def create_product(self): pass class 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, abstractmethod
class Observer(ABC):
@abstractmethod
def update(self, message):
pass
class 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）
-
定义一系列算法，将每个算法封装起来，并使它们可以互换。策略模式可以使算法独立于客户端而变化。
from abc import ABC, abstractmethod class Strategy(ABC): @abstractmethod def execute(self): pass class 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 = strategy def execute_strategy(self): return self._strategy.execute()
5.装饰器模式（Decorator Pattern）
-
动态地给一个对象添加一些额外的职责，装饰模式比继承更加灵活。
from abc import ABC, abstractmethod class Component(ABC): @abstractmethod def operation(self): pass class ConcreteComponent(Component): def operation(self): return "Concrete Component" class Decorator(Component): _component = None def __init__(self, component): self._component = component def operation(self): return self._component.operation() class ConcreteDecorator(Decorator): def operation(self): return f"{super().operation()}, Decorated"
