基于python的23种设计模式

以下是基于Python实现的23种设计模式及代码段和详细解释:

1. 工厂模式(Factory Pattern)

简介

工厂模式是一种创建型设计模式,它允许客户端代码通过工厂方法创建对象,而无需直接实例化对象。在工厂方法模式中,我们定义一个工厂方法来创建对象,而不是使用类的构造函数。

代码段

python 复制代码
from abc import ABC, abstractmethod

class Product(ABC):
    """
    抽象产品类,定义所有具体产品的接口
    """
    @abstractmethod
    def operation(self) -> str:
        pass

class ConcreteProduct(Product):
    """
    具体产品类
    """
    def operation(self) -> str:
        return "ConcreteProduct"

class Creator(ABC):
    """
    抽象创建者类,声明工厂方法,返回一个产品类的实例
    """
    @abstractmethod
    def factory_method(self) -> Product:
        pass

    def some_operation(self) -> str:
        """
        可选:创建者还可以提供一些默认实现
        """
        product = self.factory_method()
        result = f"Creator: {product.operation()}"
        return result

class ConcreteCreator1(Creator):
    """
    具体创建者1,实现工厂方法以返回具体产品1的实例
    """
    def factory_method(self) -> Product:
        return ConcreteProduct()

class ConcreteCreator2(Creator):
    """
    具体创建者2,实现工厂方法以返回具体产品2的实例
    """
    def factory_method(self) -> Product:
        return ConcreteProduct()

def client_code(creator: Creator) -> None:
    """
    客户端代码只需要知道创建者的抽象类,无需关心具体实现类
    """
    print(f"Client: I'm not aware of the creator's class, but it still works.\n"
          f"{creator.some_operation()}", end="")

if __name__ == "__main__":
    print("App: Launched with the ConcreteCreator1.")
    client_code(ConcreteCreator1())

解释

该代码段演示了工厂模式,其中有一个抽象产品类和其具体实现类。还有一个抽象创建者类来声明工厂方法和可选的默认实现。具体创建类实现工厂方法以返回具体产品类的实例。客户端代码调用抽象创建者而不是具体创建子类。

2. 抽象工厂模式(Abstract Factory Pattern)

简介

抽象工厂是一种创建型设计模式,它允许您创建一组相关的对象,而无需指定其具体类。抽象工厂定义了一个接口,用于创建相关的对象,而不指定具体类。

代码段

python 复制代码
from abc import ABC, abstractmethod

class AbstractFactory(ABC):
    """
    抽象工厂类,声明所有产品创建方法。
    """
    @abstractmethod
    def create_product_a(self):
        pass

    @abstractmethod
    def create_product_b(self):
        pass

class ConcreteFactory1(AbstractFactory):
    """
    具体工厂1,生成一组具有相互依赖关系的产品。
    """
    def create_product_a(self):
        return ConcreteProductA1()

    def create_product_b(self):
        return ConcreteProductB1()

class ConcreteFactory2(AbstractFactory):
    """
    具体工厂2,生成一组具有相互依赖关系的产品。
    """
    def create_product_a(self):
        return ConcreteProductA2()

    def create_product_b(self):
        return ConcreteProductB2()

class AbstractProductA(ABC):
    """
    抽象产品A类,定义具体产品共有的方法
    """
    @abstractmethod
    def useful_function_a(self) -> str:
        pass

class AbstractProductB(ABC):
    """
    抽象产品B类,定义具体产品共有的方法
    """
    @abstractmethod
    def useful_function_b(self) -> None:
        pass

    @abstractmethod
    def another_useful_function_b(self, collaborator: AbstractProductA) -> None:
        pass

class ConcreteProductA1(AbstractProductA):
    """
    具体产品A1,实现抽象产品A类的接口
    """
    def useful_function_a(self) -> str:
        return "The result of the product A1."

class ConcreteProductA2(AbstractProductA):
    """
    具体产品A2,实现抽象产品A类的接口
    """
    def useful_function_a(self) -> str:
        return "The result of the product A2."

class ConcreteProductB1(AbstractProductB):
    """
    具体产品B1,实现抽象产品B类的接口
    """
    def useful_function_b(self) -> str:
        return "The result of the product B1."

    def another_useful_function_b(self, collaborator: AbstractProductA) -> str:
        """
        B1实现了与特定产品A相关的功能。
        """
        result = collaborator.useful_function_a()
        return f"The result of the B1 collaborating with the ({result})"

class ConcreteProductB2(AbstractProductB):
    """
    具体产品B2,实现抽象产品B类的接口
    """
    def useful_function_b(self) -> str:
        return "The result of the product B2."

    def another_useful_function_b(self, collaborator: AbstractProductA) -> str:
        """
        B2实现了与特定产品A相关的功能。
        """
        result = collaborator.useful_function_a()
        return f"The result of the B2 collaborating with the ({result})"

def client_code(factory: AbstractFactory) -> None:
    """
    客户端代码仅与抽象工厂及其产品接口一起使用。
    """
    product_a = factory.create_product_a()
    product_b = factory.create_product_b()

    print(f"{product_b.useful_function_b()}")

    print(f"{product_b.another_useful_function_b(product_a)}", end="")

if __name__ == "__main__":
    print("Client: Testing client code with the first factory type...")
    client_code(ConcreteFactory1())

    print("\n")

    print("Client: Testing the same client code with the second factory type...")
    client_code(ConcreteFactory2())

解释

该代码段演示了抽象工厂模式,其中有一个抽象工厂类和多个实现不同产品分类的具体工厂类。每个工厂类都实现了工厂方法来生产不同类型的产品。每个产品类实现了共同的抽象产品接口。客户端代码只与抽象工厂和产品接口一起使用,而不需要关心具体实现类。

3. 建造者模式(Builder Pattern)

简介

建造者模式是一种创建型设计模式,它允许您使用相同的构建代码生成不同类型和形式的对象。建造者模式的精髓在于将对象构建过程与其表示分离。

代码段

python 复制代码
from abc import ABC, abstractmethod
from typing import Any

class Builder(ABC):
    """
    抽象建造者类,声明所有产品构建步骤。
    """
    @abstractmethod
    def produce_part_a(self) -> None:
        pass

    @abstractmethod
    def produce_part_b(self) -> None:
        pass

    @abstractmethod
    def produce_part_c(self) -> None:
        pass

    @abstractmethod
    def get_result(self) -> Any:
        pass

class ConcreteBuilder1(Builder):
    """
    具体建造者类1,实现所有产品构建方法,并返回最终结果。
    """
    def __init__(self) -> None:
        self.reset()

    def reset(self) -> None:
        self.product = Product1()

    def produce_part_a(self) -> None:
        self.product.add("PartA1")

    def produce_part_b(self) -> None:
        self.product.add("PartB1")

    def produce_part_c(self) -> None:
        self.product.add("PartC1")

    def get_result(self) -> Product1:
        result = self.product
        self.reset()
        return result

class ConcreteBuilder2(Builder):
    """
    具体建造者类2,实现所有产品构建方法,并返回最终结果。
    """
    def __init__(self) -> None:
        self.reset()

    def reset(self) -> None:
        self.product = Product2()

    def produce_part_a(self) -> None:
        self.product.add("PartA2")
相关推荐
豆包MarsCode6 分钟前
我用豆包MarsCode IDE 做了一个 CSS 权重小组件
开发语言·前端·javascript·css·ide·html
铅华尽7 分钟前
Java---JDBC案例--手机信息管理系统
java·开发语言·智能手机
凌虚(失业了求个工作)7 分钟前
RAG 示例:使用 langchain、Redis、llama.cpp 构建一个 kubernetes 知识库问答
人工智能·redis·python·langchain·llama
0zxm16 分钟前
01.Django快速入门
数据库·vscode·python·django·sqlite
X 西安17 分钟前
第十章JavaScript的应用
开发语言·javascript·ecmascript
特种加菲猫21 分钟前
初阶数据结构之队列的实现
开发语言·数据结构·笔记
霁月风29 分钟前
设计模式——装饰器模式
c++·设计模式·装饰器模式
夏旭泽30 分钟前
设计模式-原型模式
设计模式·原型模式
CV大法好32 分钟前
刘铁猛C#入门 027 抽象和开闭原则
开发语言·c#
七侠镇莫尛貝大侠202337 分钟前
C:mbedtls库实现https双向认证连接示例_七侠镇莫尛貝大侠20241122
c语言·开发语言·https