常见设计模式的python写法

以下是 20 种常见设计模式的简单示例代码：

```python
# 单例模式
class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# 工厂模式
class Product:
    def do_something(self):
        pass

class Factory:
    def create_product(self):
        return Product()

# 抽象工厂模式
class AbstractProductA:
    def do_something_a(self):
        pass

class AbstractProductB:
    def do_something_b(self):
        pass

class ConcreteFactory1:
    def create_product_a(self):
        return ConcreteProductA1()

    def create_product_b(self):
        return ConcreteProductB1()

class ConcreteProductA1(AbstractProductA):
    def do_something_a(self):
        print("ConcreteProductA1")

class ConcreteProductB1(AbstractProductB):
    def do_something_b(self):
        print("ConcreteProductB1")

# 建造者模式
class ProductBuilder:
    def build_part1(self):
        pass

    def build_part2(self):
        pass

    def get_result(self):
        pass

class ConcreteBuilder(ProductBuilder):
    def __init__(self):
        self.product = None

    def build_part1(self):
        self.product = "Part1"

    def build_part2(self):
        self.product += " Part2"

    def get_result(self):
        return self.product

# 原型模式
import copy

class Prototype:
    def __init__(self):
        self.name = "Prototype"

    def clone(self):
        return copy.deepcopy(self)

# 适配器模式
class Target:
    def request(self):
        pass

class Adaptee:
    def specific_request(self):
        print("Adaptee's specific request")

class Adapter(Target):
    def __init__(self, adaptee):
        self.adaptee = adaptee

    def request(self):
        self.adaptee.specific_request()

# 桥接模式
class Abstraction:
    def __init__(self, implementation):
        self.implementation = implementation

    def operation(self):
        self.implementation.implementation_operation()

class Implementation:
    def implementation_operation(self):
        pass

class ConcreteImplementationA(Implementation):
    def implementation_operation(self):
        print("ConcreteImplementationA")

class ConcreteImplementationB(Implementation):
    def implementation_operation(self):
        print("ConcreteImplementationB")

# 组合模式
class Component:
    def operation(self):
        pass

class Leaf(Component):
    def operation(self):
        print("Leaf operation")

class Composite(Component):
    def __init__(self):
        self.children = []

    def add(self, component):
        self.children.append(component)

    def operation(self):
        print("Composite operation")
        for child in self.children:
            child.operation()

# 装饰器模式
class Component:
    def operation(self):
        print("Component operation")

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

    def operation(self):
        self.component.operation()
        print("Decorator operation")

# 外观模式
class SubsystemA:
    def operation_a(self):
        print("SubsystemA operation")

class SubsystemB:
    def operation_b(self):
        print("SubsystemB operation")

class Facade:
    def __init__(self):
        self.subsystem_a = SubsystemA()
        self.subsystem_b = SubsystemB()

    def operation(self):
        self.subsystem_a.operation_a()
        self.subsystem_b.operation_b()

# 享元模式
class Flyweight:
    def __init__(self, intrinsic_state):
        self.intrinsic_state = intrinsic_state

    def operation(self, extrinsic_state):
        print(f"Intrinsic: {self.intrinsic_state}, Extrinsic: {extrinsic_state}")

class FlyweightFactory:
    def __init__(self):
        self.flyweights = {}

    def get_flyweight(self, key):
        if key not in self.flyweights:
            self.flyweights[key] = Flyweight(key)
        return self.flyweights[key]

# 代理模式
class Subject:
    def request(self):
        pass

class RealSubject(Subject):
    def request(self):
        print("RealSubject request")

class Proxy(Subject):
    def __init__(self, real_subject):
        self.real_subject = real_subject

    def request(self):
        print("Proxy request")
        self.real_subject.request()

# 责任链模式
class Handler:
    def __init__(self):
        self.successor = None

    def set_successor(self, successor):
        self.successor = successor

    def handle_request(self, request):
        pass

class ConcreteHandler1(Handler):
    def handle_request(self, request):
        if request < 10:
            print("ConcreteHandler1 handled")
        elif self.successor:
            self.successor.handle_request(request)

class ConcreteHandler2(Handler):
    def handle_request(self, request):
        if 10 <= request < 20:
            print("ConcreteHandler2 handled")
        elif self.successor:
            self.successor.handle_request(request)

# 命令模式
class Command:
    def execute(self):
        pass

class ConcreteCommand(Command):
    def __init__(self, receiver):
        self.receiver = receiver

    def execute(self):
        self.receiver.action()

class Receiver:
    def action(self):
        print("Receiver action")

# 解释器模式
class Expression:
    def interpret(self, context):
        pass

class TerminalExpression(Expression):
    def __init__(self, data):
        self.data = data

    def interpret(self, context):
        if self.data in context:
            return True
        return False

class NonterminalExpression(Expression):
    def __init__(self, expression1, expression2):
        self.expression1 = expression1
        self.expression2 = expression2

    def interpret(self, context):
        return self.expression1.interpret(context) and self.expression2.interpret(context)

# 迭代器模式
class Iterator:
    def has_next(self):
        pass

    def next(self):
        pass

class ConcreteIterator(Iterator):
    def __init__(self, collection):
        self.collection = collection
        self.index = 0

    def has_next(self):
        return self.index < len(self.collection)

    def next(self):
        if self.has_next():
            item = self.collection[self.index]
            self.index += 1
            return item
        return None

class Collection:
    def __init__(self):
        self.items = []

    def add_item(self, item):
        self.items.append(item)

    def create_iterator(self):
        return ConcreteIterator(self.items)

# 备忘录模式
class Memento:
    def __init__(self, state):
        self.state = state

class Originator:
    def __init__(self):
        self.state = None

    def create_memento(self):
        return Memento(self.state)

    def restore_memento(self, memento):
        self.state = memento.state

# 观察者模式
class Observer:
    def update(self, data):
        pass

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

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

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

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

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