Python中常用的设计模式用法介绍

设计模式是软件开发中常用的一种解决问题的方案，它是对一类相似问题的解决方案的抽象。

一、工厂模式

工厂模式是一种创建型设计模式，用于创建对象的接口，但是具体创建哪个类的对象由工厂类决定。

1、简单工厂模式

class Car:
    def __init__(self, name):
        self.name = name
    
    def move(self):
        print(f"{self.name} is moving.")

class CarFactory:
    def create_car(self, name):
        return Car(name)

factory = CarFactory()
car = factory.create_car("BMW")
car.move()

2、工厂方法模式

from abc import ABC, abstractmethod

class Car(ABC):
    @abstractmethod
    def move(self):
        pass

class BMW(Car):
    def move(self):
        print("BMW is moving.")

class Benz(Car):
    def move(self):
        print("Benz is moving.")

class CarFactory(ABC):
    @abstractmethod
    def create_car(self):
        pass

class BMWFactory(CarFactory):
    def create_car(self):
        return BMW()

class BenzFactory(CarFactory):
    def create_car(self):
        return Benz()

bmw_factory = BMWFactory()
benz_factory = BenzFactory()
bmw = bmw_factory.create_car()
benz = benz_factory.create_car()

bmw.move()
benz.move()

二、单例模式

单例模式是一种创建型设计模式，用于确保类只有一个实例，并且提供一个全局访问点。

1、简单单例模式

class Singleton:
    _instance = None

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

    def __init__(self, name):
        self.name = name

singleton1 = Singleton("Singleton 1")
singleton2 = Singleton("Singleton 2")

print(singleton1.name)  # 输出：Singleton 1
print(singleton2.name)  # 输出：Singleton 1

2、线程安全的单例模式

import threading

class Singleton:
    _instance = None
    _lock = threading.Lock()

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

    def __init__(self, name):
        self.name = name

singleton1 = Singleton("Singleton 1")
singleton2 = Singleton("Singleton 2")

print(singleton1.name)  # 输出：Singleton 1
print(singleton2.name)  # 输出：Singleton 1

三、观察者模式

观察者模式是一种行为型设计模式，用于对象间的一对多依赖关系，当一个对象状态发生变化时，所有依赖它的对象都会收到通知。

1、简单观察者模式

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

    def add_observer(self, observer):
        self.observers.append(observer)

    def remove_observer(self, observer):
        self.observers.remove(observer)

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

class Observer:
    def update(self, message):
        print(f"Received message: {message}")

observable = Observable()
observer1 = Observer()
observer2 = Observer()

observable.add_observer(observer1)
observable.add_observer(observer2)

observable.notify("Hello, observers!")

2、内置观察者模式

from abc import ABC, abstractmethod
from typing import List

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

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

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

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

class Observer(ABC):
    @abstractmethod
    def update(self, message):
        pass

class ConcreteObservable(Observable):
    def notify(self, message):
        print("ConcreteObservable: Notifying observers...")
        super().notify(message)

class ConcreteObserver1(Observer):
    def update(self, message):
        print(f"ConcreteObserver1: Received message - {message}")

class ConcreteObserver2(Observer):
    def update(self, message):
        print(f"ConcreteObserver2: Received message - {message}")

observable = ConcreteObservable()
observer1 = ConcreteObserver1()
observer2 = ConcreteObserver2()

observable.add_observer(observer1)
observable.add_observer(observer2)

observable.notify("Hello, observers!")

四、策略模式

策略模式是一种行为型设计模式，将一组算法封装成一系列对象，使得这些算法可以互相替换，而不影响客户端的使用。

1、简单策略模式

class Strategy:
    def execute(self):
        pass

class ConcreteStrategyA(Strategy):
    def execute(self):
        print("Executing strategy A...")

class ConcreteStrategyB(Strategy):
    def execute(self):
        print("Executing strategy B...")

class Context:
    def __init__(self, strategy):
        self.strategy = strategy

    def execute_strategy(self):
        self.strategy.execute()

context = Context(ConcreteStrategyA())
context.execute_strategy()

context.strategy = ConcreteStrategyB()
context.execute_strategy()

2、使用函数实现策略模式

def strategy_a():
    print("Executing strategy A...")

def strategy_b():
    print("Executing strategy B...")

class Context:
    def __init__(self, strategy):
        self.strategy = strategy

    def execute_strategy(self):
        self.strategy()

context = Context(strategy_a)
context.execute_strategy()

context.strategy = strategy_b
context.execute_strategy()

以上是Python中常用的几种设计模式，它们在不同的场景中具有不同的作用，能够有效地解决一些常见的问题。