阶段二：进阶知识(掌握Python的常用设计模式)

本文介绍: Python中常用的设计模式包括工厂方法模式。工厂方法模式是一种创建型模式，它提供了一种创建对象的接口，但具体创建的对象类型可以在运行时决定。这种模式使得创建对象的行为延迟到其子类中，使得代码更加灵活、可扩展和维护性更高。在Python中，实现工厂方法模式的关键是将创建对象的代码转移到子类中，通过让子类实现一个工厂方法来返回特定类型的对象。在上面的示例中，我们定义了一个抽象的Anim al类和一个抽象的类，它们分别表示动物和动物工厂。我们还定义了两个具体的子类Dog和Cat，它们分别实现了Anim al。

Python中常用的设计模式包括工厂方法模式。

工厂方法模式是一种创建型模式，它提供了一种创建对象的接口，但具体创建的对象类型可以在运行时决定。这种模式使得创建对象的行为延迟到其子类中，使得代码更加灵活、可扩展和维护性更高。

在Python中，实现工厂方法模式的关键是将创建对象的代码转移到子类中，通过让子类实现一个工厂方法来返回特定类型的对象。下面是一个简单的Python示例，展示了如何使用工厂方法模式：

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class AnimalFactory(ABC):
    @abstractmethod
    def create_animal(self):
        pass

class DogFactory(AnimalFactory):
    def create_animal(self):
        return Dog()

class CatFactory(AnimalFactory):
    def create_animal(self):
        return Cat()

if __name__ == "__main__":
    animal_factory = DogFactory()
    dog = animal_factory.create_animal()
    print(dog.speak()) # Output: Woof!

在上面的示例中，我们定义了一个抽象的Animal类和一个抽象的AnimalFactory类，它们分别表示动物和动物工厂。我们还定义了两个具体的子类Dog和Cat，它们分别实现了Animal类的speak()方法来返回狗和猫的声音。接下来，我们定义了两个具体的工厂类DogFactory和CatFactory，它们分别实现了AnimalFactory类的create_animal()方法来创建狗和猫的对象。最后，我们使用DogFactory来创建一个狗对象，并调用其speak()方法来输出狗的声音。

通过使用工厂方法模式，我们可以将创建对象的代码集中到一个工厂类中，使得代码更加清晰、易于维护和扩展。同时，由于具体创建的对象类型在运行时决定，我们可以灵活地创建不同的对象，从而实现更加灵活和可复用的代码。

当然，除了工厂方法模式，Python中还有许多其他常用的设计模式。接下来我将介绍其中一些：

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

class Observable:
    def __init__(self):
        self._observers = []
        
    def subscribe(self, observer):
        self._observers.append(observer)
        
    def unsubscribe(self, observer):
        self._observers.remove(observer)
        
    def notify(self, *args, **kwargs):
        for observer in self._observers:
            observer.update(*args, **kwargs)
            
class Observer:
    def update(self, *args, **kwargs):
        pass

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
    return wrapper

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"