创建型模式与对象的创建有关。 创建型模式抽象了对象实例化的过程，这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。创建型模式有以下
工厂模式（Factory Method）
意图：定义一个用于创建对象的接口， 让子类决定实例化哪一个类
代码示例：
python
# 抽象产品类 - Shape
class Shape:
def draw(self):
pass
# 具体产品类 - Circle
class Circle(Shape):
def draw(self):
print("Drawing a circle")
# 具体产品类 - Rectangle
class Rectangle(Shape):
def draw(self):
print("Drawing a rectangle")
# 工厂类 - ShapeFactory
class ShapeFactory:
def create_shape(self, shape_type):
if shape_type.lower() == "circle":
return Circle()
elif shape_type.lower() == "rectangle":
return Rectangle()
return None
# 客户端代码
shape_factory = ShapeFactory()
# 创建一个圆形对象
circle = shape_factory.create_shape("circle")
circle.draw() # 输出：Drawing a circle
# 创建一个矩形对象
rectangle = shape_factory.create_shape("rectangle")
rectangle.draw() # 输出：Drawing a rectangle在这个示例中，Shape是抽象产品类，Circle和Rectangle是具体产品类。ShapeFactory是工厂类，其中的create_shape方法根据传入的参数决定实例化哪个具体产品类来创建对象。客户端代码通过调用工厂类的方法来创建具体的产品对象，并调用其draw方法进行绘制。
抽象工厂模式（Abstract Factory）
意图：提供一个创建一系列相互依赖对象的接口，而无需指定他们具体的类
基于工厂模式的改良，工厂模式包括：抽象产品类、具体产品类、工厂类
抽象工厂模式的包括： 抽象产品类、具体产品类、抽象工厂类、具体工厂类
python
# 抽象工厂接口
class AbstractFactory:
def create_engine(self):
pass
def create_tire(self):
pass
# 具体工厂实现类 - 奔驰工厂
class BenzFactory(AbstractFactory):
def create_engine(self):
return BenzEngine()
def create_tire(self):
return BenzTire()
# 具体工厂实现类 - 宝马工厂
class BMWFactory(AbstractFactory):
def create_engine(self):
return BMWEngine()
def create_tire(self):
return BMWTire()
# 抽象产品接口 - 引擎
class Engine:
def description(self):
pass
# 具体产品类 - 奔驰引擎
class BenzEngine(Engine):
def description(self):
return "This is a Benz engine."
# 具体产品类 - 宝马引擎
class BMWEngine(Engine):
def description(self):
return "This is a BMW engine."
# 抽象产品接口 - 轮胎
class Tire:
def description(self):
pass
# 具体产品类 - 奔驰轮胎
class BenzTire(Tire):
def description(self):
return "This is a Benz tire."
# 具体产品类 - 宝马轮胎
class BMWTire(Tire):
def description(self):
return "This is a BMW tire."
# 客户端代码
def client(factory):
engine = factory.create_engine()
tire = factory.create_tire()
print(engine.description())
print(tire.description())
# 使用奔驰工厂创建产品
benz_factory = BenzFactory()
client(benz_factory)
# 使用宝马工厂创建产品
bmw_factory = BMWFactory()
client(bmw_factory)在上面的示例中，AbstractFactory 是抽象工厂接口，定义了创建产品的方法。BenzFactory 和 BMWFactory 是具体工厂实现类，分别负责创建奔驰和宝马汽车的引擎和轮胎。Engine 和 Tire 是抽象产品接口，定义了产品的方法。BenzEngine、BMWEngine、BenzTire 和 BMWTire 是具体产品类，分别实现了奔驰和宝马汽车的引擎和轮胎。
客户端代码可以通过传入不同的具体工厂实例来创建不同品牌的汽车引擎和轮胎，并使用它们的方法。
抽象工厂方法模式可以方便地扩展产品系列，例如添加奥迪工厂和奥迪产品类，只需要新增对应的工厂和产品类即可。
单例模式（Singleton）
意图：保证一个类仅只有一个实例，并提供一个他的全局访问点
python
# 单例类 - Logger
class Logger:
_instance = None
def __init__(self):
# 私有构造函数，防止外部实例化
pass
@classmethod
def get_instance(cls):
if not cls._instance:
cls._instance = Logger()
return cls._instance
def log(self, message):
print("Logging:", message)
# 客户端代码
logger1 = Logger.get_instance()
logger1.log("Message 1") # 输出：Logging: Message 1
logger2 = Logger.get_instance()
logger2.log("Message 2") # 输出：Logging: Message 2
print(logger1 is logger2) # 输出：True，两个实例是同一个对象在这个示例中，Logger是单例类，它的构造函数被声明为私有，以防止外部实例化。通过get_instance方法获取该类的唯一实例。客户端代码通过调用get_instance方法来获取日志记录器的实例，并调用其log方法记录日志。由于单例模式的特性，无论多少次调用get_instance方法，都会返回同一个实例。
构建器模式（Builder）
意图：将对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
py
# 产品类 - 电脑
class Computer:
def __init__(self):
self.cpu = None
self.memory = None
self.storage = None
def set_cpu(self, cpu):
self.cpu = cpu
def set_memory(self, memory):
self.memory = memory
def set_storage(self, storage):
self.storage = storage
def display(self):
print(f"CPU: {self.cpu}")
print(f"Memory: {self.memory}")
print(f"Storage: {self.storage}")
# 建造者接口
class Builder:
def build_cpu(self):
pass
def build_memory(self):
pass
def build_storage(self):
pass
def get_computer(self):
pass
# 具体建造者类 - 游戏电脑建造者
class GamingComputerBuilder(Builder):
def __init__(self):
self.computer = Computer()
def build_cpu(self):
self.computer.set_cpu("Intel i7")
def build_memory(self):
self.computer.set_memory("16GB DDR4")
def build_storage(self):
self.computer.set_storage("1TB SSD")
def get_computer(self):
return self.computer
# 具体建造者类 - 办公电脑建造者
class OfficeComputerBuilder(Builder):
def __init__(self):
self.computer = Computer()
def build_cpu(self):
self.computer.set_cpu("Intel i5")
def build_memory(self):
self.computer.set_memory("8GB DDR4")
def build_storage(self):
self.computer.set_storage("500GB HDD")
def get_computer(self):
return self.computer
# 指挥者类
class Director:
def __init__(self, builder):
self.builder = builder
def construct(self):
self.builder.build_cpu()
self.builder.build_memory()
self.builder.build_storage()
# 客户端代码
gaming_builder = GamingComputerBuilder()
director = Director(gaming_builder)
director.construct()
gaming_computer = gaming_builder.get_computer()
gaming_computer.display()
office_builder = OfficeComputerBuilder()
director = Director(office_builder)
director.construct()
office_computer = office_builder.get_computer()
office_computer.display()在上面的示例中，Computer 是产品类，表示电脑对象。Builder 是建造者接口，定义了构建电脑的方法。GamingComputerBuilder 和 OfficeComputerBuilder 是具体建造者类，分别负责构建游戏电脑和办公电脑。Director 是指挥者类，负责控制建造过程。
客户端代码可以通过创建不同的具体建造者实例，并通过指挥者来构建不同类型的电脑对象。使用建造者模式可以方便地构建具有不同配置的电脑对象，而无需直接调用产品类的构造函数或者繁琐地设置每个属性。
原型模式（Prototype）
意图：原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象
py
import copy
# 原型接口
class Prototype:
def clone(self):
pass
# 具体原型类 - 矩形
class Rectangle(Prototype):
def __init__(self, width, height):
self.width = width
self.height = height
def set_width(self, width):
self.width = width
def set_height(self, height):
self.height = height
def clone(self):
return copy.deepcopy(self)
def __str__(self):
return f"Rectangle [width={self.width}, height={self.height}]"
# 客户端代码
if __name__ == '__main__':
# 创建原型对象
rectangle = Rectangle(10, 20)
# 克隆原型对象
cloned_rectangle = rectangle.clone()
print("Cloned Rectangle:", cloned_rectangle)
# 修改克隆对象的属性
cloned_rectangle.set_width(15)
cloned_rectangle.set_height(25)
print("Modified Cloned Rectangle:", cloned_rectangle)在 Python 中，我们使用 copy 模块的 deepcopy() 函数来实现对象的深拷贝，以克隆原型对象。然后，我们可以通过调用克隆对象的方法来修改其属性。
需要注意的是，Python 中的类不需要显式地实现接口，因此我们只需定义一个基类 Prototype，然后在具体原型类 Rectangle 中重写 clone() 方法即可。
附加知识
1. python中@classmethod是什么，有什么作用
（使用方式等同于Java中的静态方法）
在 Python 中，@classmethod 是一个装饰器（Decorator），用于定义一个类方法。类方法是与类相关联的方法，而不是与类的实例相关联的方法。
类方法使用装饰器 @classmethod 来标识，并且第一个参数通常被命名为 cls，表示类本身。与实例方法不同，类方法可以直接通过类名调用，而不需要创建类的实例。
@classmethod 的作用主要有以下几点：
- 允许在不创建类的实例的情况下调用方法。这对于执行与类相关的操作非常有用，例如创建类级别的工厂方法。
- 允许在类方法内部访问类的属性和其他类方法，而无需使用实例。
- 提供一种约定，使得代码更易读和理解，因为它明确指示该方法是一个类方法。
下面是一个使用@classmethod定义类方法的示例：
py
class MyClass:
count = 0
def __init__(self):
MyClass.count += 1
@classmethod
def get_instance_count(cls):
return cls.count在上面的示例中，get_instance_count() 是一个类方法，它返回创建的 MyClass 实例的数量。你可以通过类名直接调用该方法，而不需要创建类的实例：
py
print(MyClass.get_instance_count()) # 输出: 0
obj1 = MyClass()
print(MyClass.get_instance_count()) # 输出: 1
obj2 = MyClass()
print(MyClass.get_instance_count()) # 输出: 22. python中类中的__init__ 和其他方法执行顺序
在 Python 中，类的方法执行顺序主要取决于方法的调用方式和继承关系。下面是一般情况下常见的执行顺序：
定义类时，会先执行类体中的代码，包括属性和方法的定义。
当创建类的实例时，会自动调用__init__方法作为构造函数，用于初始化对象的属性。
在实例化过程中，如果类定义了父类，则会先执行父类的 __init__ 方法，然后再执行子类的 __init__ 方法。
在实例化后，可以通过实例调用类的其他方法。
以下是一个示例来说明执行顺序：
py
class Parent:
def __init__(self):
print("Parent's __init__")
def method(self):
print("Parent's method")
class Child(Parent):
def __init__(self):
super().__init__() # 先执行父类的 __init__
print("Child's __init__")
def method(self):
super().method() # 调用父类的 method
print("Child's method")
child = Child()输出结果：
py
Parent's __init__
Child's __init__在上面的示例中，首先创建了 Child 类的实例 child。在实例化过程中，由于 Child 类继承自 Parent 类，因此会先执行父类 Parent 的__init__方法，然后再执行子类 Child 的__init__方法。最终输出结果中可以看到先打印了 "Parent's init"，然后才打印了 "Child's init"。
深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
浅拷贝是指创建一个新对象，然后将原始对象的非静态字段的值复制到新对象中。如果字段是基本类型，则复制其值；如果字段是引用类型，则复制引用而不是实际对象。这意味着原始对象和浅拷贝对象会共享相同的引用对象。如果修改了引用对象的属性，则原始对象和浅拷贝对象都会受到影响。
深拷贝是指创建一个新对象，并递归地复制原始对象及其所有引用对象的内容。这意味着原始对象和深拷贝对象拥有相同的值，但是它们引用的是不同的对象实例。修改深拷贝对象或其引用对象的属性不会影响原始对象。
下面是一个示例来说明浅拷贝和深拷贝的区别：
py
import copy
class Person:
def __init__(self, name, address):
self.name = name
self.address = address
def setAddress(self, address):
self.address = address
def getAddress(self):
return self.address
def __str__(self):
return f"Person [name={self.name}, address={self.address}]"
class Address:
def __init__(self, city):
self.city = city
def setCity(self, city):
self.city = city
def __str__(self):
return f"Address [city={self.city}]"
# 客户端代码
if __name__ == "__main__":
address = Address("New York")
person1 = Person("John", address)
# 浅拷贝
person2 = copy.copy(person1)
print("Shallow Copy:")
print("person1:", person1)
print("person2:", person2)
# 修改引用对象的属性
person2.getAddress().setCity("London")
print("After modifying reference object:")
print("person1:", person1)
print("person2:", person2)
print()
# 深拷贝
deepCopiedAddress = Address(address.getCity())
person3 = Person(person1.name, deepCopiedAddress)
print("Deep Copy:")
print("person1:", person1)
print("person3:", person3)
# 修改引用对象的属性
person3.getAddress().setCity("Paris")
print("After modifying reference object:")
print("person1:", person1)
print("person3:", person3)在上述代码中，我们定义了一个 Person 类和一个 Address 类。Person 类包含一个引用类型字段 address，它引用了 Address 对象。
首先，我们创建了一个原始对象 person1，然后通过浅拷贝创建了一个新对象 person2。可以看到，person1 和 person2 的引用字段 address 指向同一个 Address 对象。因此，当我们修改 person2 的引用对象的属性时，person1 的引用对象也会受到影响。
接下来，我们使用深拷贝创建了 person3 对象。通过 copy.copy() 函数复制 person1 对象时，只是创建了一个新的 Person 对象，但仍然共享相同的 Address 对象。而通过 copy.deepcopy() 函数进行深拷贝时，会递归地复制所有引用对象的内容，因此 person3 的引用对象是一个新的 Address 对象。
最后，我们修改了 person3 的引用对象的属性，并打印出原始对象 person1 和深拷贝对象 person3，可以看到它们的引用对象不再共享相同的值。