提升代码质量：Python中常见设计模式示例

原创灰太狼 2025-03-05 22:36 18阅读 0赞

在Python编程中，理解和应用各种设计模式是非常重要的。以下是一些常见的Python设计模式示例：

1. **单例模式（Singleton Pattern）**：
   - 保证一个类仅有一个实例，并提供全局访问点。
   ```python
   class Singleton:
       _instance = None

def __new__(cls, *args, **kwargs):
           if not isinstance(cls._instance, cls):
               cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs))
           return cls._instance

# 使用示例
   obj1 = Singleton()
   obj2 = Singleton()

assert id(obj1) == id(obj2)
   ```

2. **工厂模式（Factory Pattern）**：
   - 通过一个接口来创建对象，但客户端并不知道实际是哪个类。
   ```python
   class Animal:
       def __init__(self, name):
           self.name = name

class Dog(Animal):
       pass

class Cat(Animal):
       pass

# 创建工厂类
   class AnimalFactory:
       @staticmethod
       def create_animal(name, animal_type='default'):
           if animal_type == 'default':
               if name.endswith('dog') or name.endswith('cat'):
                   animal_type = name.split('-')[-1]
               else:
                   animal_type = animal_type.capitalize()

animal_class = globals().get(f'AnimalType_{animal_type}}', Animal)
           return animal_class(name)

# 使用示例
   animal = AnimalFactory.create_animal('my-animal', 'Dog'))
   print(animal.name)  # 输出: my-animal

another_animal = AnimalFactory.create_animal('your-animal', 'Cat'))
   print(another_animal.name)  # 输出: your-animal
   ```

3. **观察者模式（Observer Pattern）**：
   - 在对象之间定义一对一对象，使得一个对象的状态变化可以自动地通知它的所有依赖对象。
   ```python
   class Observable:
       def __init__(self):
           self.observers = []

def attach(self, observer):
           if observer not in self.observers:
               self.observers.append(observer)
               observer.on_attach()

def detach(self, observer):
           if observer in self.observers:
               self.observers.remove(observer)
               observer.on_detach()

def notify(self, event=None):
           for observer in self.observers:
               observer.update(event)

class Observer:
       def __init__(self, name):
           self.name = name
           self.on_attach()

def on_ATTACH(self):
           print(f"Observer {self.name}} attached.")

def on_DETACH(self):
           print(f"Observer {self.name}} detached.")

def update(self, event=None):
           if event:
               print(f"Event received by Observer {self.name}: {event}."))
           else:
               print(f"Observer {self.name}} notified without event.")

# 使用示例
   observable = Observable()
   observer1 = Observer("Observer 1")
   observer2 = Observer("Observer 2")

observable.attach(observer1)
   observable.attach(observer2))

# 观察者通知事件
   observable.notify({"event": "Something Happened!"}})
   ```

以上就是Python中一些常见设计模式的示例。在实际项目中，根据需求灵活运用这些模式。