python架构师必懂的五种设计模式

Python语言中常见的五种设计模式包括：单例模式、工厂模式、观察者模式、策略模式和装饰器模式。以下是给出每个设计模式对应的main函数和完整代码示例：

1. 单例模式：

class Singleton:
    __instance = None
    
    @staticmethod
    def getInstance():
        if Singleton.__instance is None:
            Singleton()
        return Singleton.__instance
    
    def __init__(self):
        if Singleton.__instance is not None:
            raise Exception("This class is a singleton class!")
        else:
            Singleton.__instance = self

    def showMessage(self):
        print("Hello, I am a Singleton.")

# 在main函数中测试单例模式
def main():
    singleton = Singleton.getInstance()
    singleton.showMessage()

if __name__ == "__main__":
    main()

2. 工厂模式：

class Product:
    def showMessage(self):
        pass

class ConcreteProductA(Product):
    def showMessage(self):
        print("Hello, I am Product A.")

class ConcreteProductB(Product):
    def showMessage(self):
        print("Hello, I am Product B.")

class Factory:
    def createProduct(self, productType):
        if productType == 1:
            return ConcreteProductA()
        elif productType == 2:
            return ConcreteProductB()
        else:
            return None

# 在main函数中测试工厂模式
def main():
    factory = Factory()

    productA = factory.createProduct(1)
    productA.showMessage()

    productB = factory.createProduct(2)
    prductB.showMessage()

if __name__ == "__main__":
    main()

3. 观察者模式：

class Observer:
    def update(self, data):
        pass

class ConcreteObserverA(Observer):
    def update(self, data):
        print(f"Observer A: {data}")

class ConcreteObserverB(Observer):
    def update(self, data):
        print(f"Observer B: {data}")

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

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

    def setData(self, value):
        for observer in self.observers:
            observer.update(value)

# 在main函数中测试观察者模式
def main():
    subject = Subject()
    observerA = ConcreteObserverA()
    observerB = ConcreteObserverB()

    subject.attach(observerA)
    subject.attach(observerB)

    subject.setData(10)

if __name__ == "__main__":
    main()

4. 策略模式：

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):
        self.strategy = None

    def setStrategy(self, strategy):
        self.strategy = strategy

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

# 在main函数中测试策略模式
def main():
    context = Context()
    strategyA = ConcreteStrategyA()
    strategyB = ConcreteStrategyB()

    context.setStrategy(strategyA)
    context.executeStrategy()

    context.setStrategy(strategyB)
    context.executeStrategy()

if __name__ == "__main__":
    main()

5. 装饰器模式：

class Component:
    def showMessage(self):
        pass

class ConcreteComponent(Component):
    def showMessage(self):
        print("Hello, I am a Concrete Component.")

class Decorator(Component):
    def __init__(self, component):
        self.component = component

    def showMessage(self):
        self.component.showMessage()

class ConcreteDecoratorA(Decorator):
    def showMessage(self):
        super().showMessage()
        print("Additional functionality A.")

class ConcreteDecoratorB(Decorator):
    def showMessage(self):
        super().showMessage()
        print("Additional functionality B.")

# 在main函数中测试装饰器模式
def main():
    component = ConcreteComponent()
    decoratorA = ConcreteDecoratorA(component)
    decoratorB = ConcreteDecoratorB(decoratorA)

    decoratorB.showMessage()

if __name__ == "__main__":
    main()