Concept-概念前置

设计模式：软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。

面向对象三大特性：封装、继承、多态。

面向对象设计的SOLID原则：
（1）开放封闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。

（2）里氏替换原则：所有引用父类的地方必须能透明地使用其子类的对象。

（3）依赖倒置原则：高层模块不应该依赖低层模块，二者都应该依赖其抽象； 抽象不应该依赖细节；细节应该依赖抽象。

（4）接囗隔离原则：使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口。
（5）单一职责原则：不要存在多于一个导致类变更的原因，即一个类只负责一项职责。
 

举个例子，可能有不止一块代码调用到该实体，这时候去修改实体里的代码，就很可能引起其他模块会出现问题，当模块关联较多时就会引起不必要的工作量，这是1；

原方法支持父类，当我们在基础上加或修改功能而衍生的子类也应当符合，这是2；

要针对接口编程， 而不是针对实现编程，实现上也就是对底层的依赖按接口格式去写，再实现，而不是随意修改参数格式，即3。

创建型模式

简单工厂模式，工厂方法模式，抽象工厂模式，创建者模式，原型模式，单例模式。

创建型模式（Creational Pattern）	一种用于 创建对象 的设计模式。它们包含一些通用的方法，更加灵活地创建对象，且 封装 了对象的实例化过程
工厂模式（Factory Pattern）	用于根据 客户端需求动态创建 对象。 （包括简单工厂模式，工厂方法模式，抽象工厂模式）
单例模式（Singleton Pattern）	用于确保一个类 只有一个 实例，并提供对该实例的全局访问点。它通常被用于管理共享资源或者限制系统中某些类的实例数量。
建造者模式（Builder Pattern）	用于将一个复杂对象的 构建过程分离 成多个简单的步骤，从而可以灵活地组合和构建不同的对象。它通常被用于创建复杂的对象，比如包含多个组件或者配置项的对象。
原型模式（Prototype Pattern）	用于 复制或克隆 已有的对象，从而创建新的对象。它通过克隆现有对象来创建新对象，从而避免了昂贵的初始化操作。

工厂模式

Factory Pattern

简单工厂模式（Simple Factory Pattern）：简单工厂模式是一种基本的工厂模式，通常由一个工厂类根据传入的参数动态决定创建哪种产品类的实例。（简单而言：一个工厂类根据传入参数创建哪个类实例）场景：适用于对象较少且产品等级结构稳定的情况。 Characters: 工厂角色（Factory） 抽象产品角色（Product） 具体产品角色（Concrete Product）

class Product:def use(self):passclass ConcreteProductA(Product):def use(self):print("Using product A.")class ConcreteProductB(Product):def use(self):print("Using product B.")class Factory:@staticmethoddef create_product(product_type):if product_type == "A":return ConcreteProductA()elif product_type == "B":return ConcreteProductB()product_a = Factory.create_product("A")
product_a.use()   # 输出：Using product A.product_b = Factory.create_product("B")
product_b.use()   # 输出：Using product B.

工厂方法模式（Factory Method Pattern）：将实际创建对象的工作推迟到子类中完成。可以在不修改工厂类的情况下，增加新的产品系列和产品等级结构。（简单而言：工厂类抽象化，将增改操作下发给子类）场景: 工厂方法模式适用于对象数量较多且产品等级结构较为复杂的情况。Characters: 工厂角色（Factory） 具体工厂角色（Concrete Factory） 抽象产品角色（Product） 具体产品角色（Concrete Product）

class Product:def use(self):passclass ConcreteProductA(Product):def use(self):print("Using product A.")class ConcreteProductB(Product):def use(self):print("Using product B.")class Factory:def create_product(self):passclass ConcreteFactoryA(Factory):def create_product(self):return ConcreteProductA()class ConcreteFactoryB(Factory):def create_product(self):return ConcreteProductB()factory_a = ConcreteFactoryA()
product_a = factory_a.create_product()
product_a.use()  # 输出：Using product A.factory_b = ConcreteFactoryB()
product_b = factory_b.create_product()
product_b.use()  # 输出：Using product B.

抽象工厂模式（Abstract Factory Pattern）：是一种将工厂类进行抽象化的进一步改进，它使用了对象组合的方式来构建不同的产品族。（工厂抽象化，组合各种产品，有点像工厂方法模式的不同类方法组合）

场景: 抽象工厂模式可以同时创建多个不同的产品，且这些产品之间存在着一定的关联性。

Characters: 工厂角色（Factory） 具体工厂角色（Concrete Factory） 抽象产品角色（Product） 具体产品角色（Concrete Product） 客户端（Client）

class ProductA:def use(self):passclass ConcreteProductA1(ProductA):def use(self):print("Using product A1.")class ConcreteProductA2(ProductA):def use(self):print("Using product A2.")class ProductB:def operate(self):passclass ConcreteProductB1(ProductB):def operate(self):print("Operating product B1.")class ConcreteProductB2(ProductB):def operate(self):print("Operating product B2.")class Factory:def create_product_a(self):passdef create_product_b(self):passclass ConcreteFactory1(Factory):def create_product_a(self):return ConcreteProductA1()def create_product_b(self):return ConcreteProductB1()class ConcreteFactory2(Factory):def create_product_a(self):return ConcreteProductA2()def create_product_b(self):return ConcreteProductB2()factory_1 = ConcreteFactory1()
product_a1 = factory_1.create_product_a()
product_a1.use()  # 输出：Using product A1.
product_b1 = factory_1.create_product_b()
product_b1.operate()  # 输出：Operating product B1.factory_2 = ConcreteFactory2()
product_a2 = factory_2.create_product_a()
product_a2.use()  # 输出：Using product A2.
product_b2 = factory_2.create_product_b()
product_b2.operate()  # 输出：Operating product B2.

单例模式

Singleton Pattern

保证一个类仅有一个实例，并提供访问该实例的全局访问点。

class Singleton:__instance = Nonedef __new__(cls):if cls.__instance is None:cls.__instance = object.__new__(cls)return cls.__instances1 = Singleton()
s2 = Singleton()
print(s1 is s2)  # 输出：True =》 说明唯一性

建造者模式

Builder Pattern

将一个复杂对象的构建过程分离成多个简单的步骤
场景: 灵活地组合和构建不同的对象。Characters:产品类（Product） 抽象建造者类（Builder）具体建造者类（ConcreteBuilder） 指挥者类（Director）

class Product:def __init__(self):self.part_a = Noneself.part_b = Noneclass Builder:def build_part_a(self):passdef build_part_b(self):passdef get_result(self):passclass ConcreteBuilder1(Builder):def __init__(self):self.product = Product()def build_part_a(self):self.product.part_a = "Part A1"def build_part_b(self):self.product.part_b = "Part B1"def get_result(self):return self.productclass ConcreteBuilder2(Builder):def __init__(self):self.product = Product()def build_part_a(self):self.product.part_a = "Part A2"def build_part_b(self):self.product.part_b = "Part B2"def get_result(self):return self.productclass Director:def __init__(self, builder):self.builder = builderdef construct(self):self.builder.build_part_a()self.builder.build_part_b()return self.builder.get_result()builder_1 = ConcreteBuilder1()
director_1 = Director(builder_1)
product_1 = director_1.construct()
print(f"Product 1: {product_1.part_a}, {product_1.part_b}")  # 输出：Product 1: Part A1, Part B1builder_2 = ConcreteBuilder2()
director_2 = Director(builder_2)
product_2 = director_2.construct()
print(f"Product 2: {product_2.part_a}, {product_2.part_b}")  # 输出：Product 2: Part A2, Part B2

原型模式

Prototype Pattern

允许通过复制现有对象来创建新的对象，而无需重新实例化。Think: 定义一个抽象原型类，包含了用于复制自身的抽象方法 clone()。然后，定义具体的原型类。在客户端代码中，可以通过调用具体对象 clone() 方法来创建新的对象，而无需重新实例化。（注意深浅拷贝问题）

import copyclass Prototype:def clone(self):return copy.deepcopy(self)class ConcretePrototype1(Prototype):def __init__(self, attr):self.attr = attrclass ConcretePrototype2(Prototype):def __init__(self, attr):self.attr = attrif __name__ == '__main__':prototype_1 = ConcretePrototype1("attr_1")prototype_2 = ConcretePrototype2("attr_2")clone_1 = prototype_1.clone()clone_2 = prototype_2.clone()print(f"Original: ({prototype_1.attr}, {prototype_2.attr})")  # 输出：Original: (attr_1, attr_2)print(f"Clone: ({clone_1.attr}, {clone_2.attr})")  # 输出：Clone: (attr_1, attr_2)