单例模式
懒汉式
class SingleTon:
# 类属性
_obj = None # 用来存储对象
# 创造对象
def __new__(cls, *args, **kwargs):
# 如果对象不存在，就创造一个对象
if cls._obj is None:
cls._obj = super().__new__(cls, *args, *kwargs)
# 返回对象
return cls._obj
if __name__ == '__main__':
obj_1 = SingleTon() # 创造一个对象
obj_2 = SingleTon() # 再次创造一个对象
print("obj_1的内存地址：", id(obj_1)) # obj_1的内存地址： 2801491317584
print("obj_2的内存地址：", id(obj_2)) # obj_2的内存地址： 2801491317584
print(obj_1 is obj_2) # True
饿汉式
- test.py
class SingleTon:
pass
# 创建一个对象
obj = SingleTon
# 提供接口
def get_instance():
return obj
- main.py
from test import get_instance
if __name__ == '__main__':
obj_1 = get_instance() # 创建一个对象
obj_2 = get_instance() # 再创建一个对象
print(obj_1 is obj_2) # True
工厂模式
简单工厂模式
"""
实现：简单计算器（加减乘除）
1. 提供一个抽象产品类
2. 提供多个具体产品类
3. 提供一个工厂类
"""
from abc import ABC, abstractmethod
# 计算器（抽象产品类）
class Calculator(ABC): # 继承 ABC 抽象类
def __init__(self):
self.left_value = 0
self.right_value = 0
def set(self, left_value, right_value):
self.left_value = left_value
self.right_value = right_value
return self
@abstractmethod
def run(self): # 抽象方法
pass
# 加法计算器（具体产品类）
class AddCalculator(Calculator): # 继承 Calculator 类
def run(self):
return self.left_value + self.right_value
# 减法计算器（具体产品类）
class SubCalculator(Calculator): # 继承 Calculator 类
def run(self):
return self.left_value - self.right_value
# 乘法计算器（具体产品类）
class MulCalculator(Calculator): # 继承 Calculator 类
def run(self):
return self.left_value * self.right_value
# 除法计算器（具体产品类）
class DivCalculator(Calculator): # 继承 Calculator 类
def run(self):
if self.right_value == 0:
raise "除数不能为零！"
return self.left_value / self.right_value
# 工厂类
class Factory:
@staticmethod
def produce_calculator(char): # 类方法
match char:
case "+":
return AddCalculator() # 创建对象
case "-":
return SubCalculator() # 创建对象
case "*":
return MulCalculator() # 创建对象
case "/":
return DivCalculator() # 创建对象
case _:
raise "不支持其他的运算符！"
if __name__ == '__main__':
# 工厂生产4种类型的计算器产品
add_calculator = Factory.produce_calculator("+") # 加法计算器
sub_calculator = Factory.produce_calculator("-") # 减法计算器
mul_calculator = Factory.produce_calculator("*") # 乘法计算器
div_calculator = Factory.produce_calculator("/") # 除法计算器
# 使用除法计算器
res = div_calculator.set(10, 5).run() # 设置左值（被除数）和右值（除数），然后运行
print(res) # 2.0
工厂方法模式
from abc import ABC, abstractmethod
# 产品（抽象产品类）
class Product(ABC): # 继承 ABC 抽象类
# 抽象：此产品补充燃料的功能
@abstractmethod
def fuel(self):
pass
# 抽象：此产品起飞的功能
@abstractmethod
def fly(self):
pass
# 飞机（具体产品类）
class PlaneProduct(Product): # 继承 Product 产品类
# 实现：此产品补充燃料的功能
def fuel(self):
print(f"飞机-CS{id(self)}，补充燃料中...")
# 实现：此产品起飞的功能
def fly(self):
print(f"飞机-CS{id(self)}，起飞！")
# 火箭（具体产品类）
class RocketProduct(Product): # 继承 Product 产品类
# 实现：此产品补充燃料的功能
def fuel(self):
print(f"火箭-CS{id(self)}，补充燃料中...")
# 实现：此产品起飞的功能
def fly(self):
print(f"火箭-CS{id(self)}，起飞！")
# 工厂（抽象工厂类）
class Factory(ABC):
# 抽象：生产产品
@abstractmethod
def produce_product(self):
pass
# 飞机工厂（具体工厂类）
class PlaneFactory(Factory):
# 具体：生产飞机产品
def produce_product(self):
return PlaneProduct() # 创建对象，并返回出去
# 火箭工厂（具体工厂类）
class RocketFactory(Factory):
# 具体：生产火箭产品
def produce_product(self):
return RocketProduct() # 创建对象，并返回出去
# 演示
def work(factory):
product = factory.produce_product() # 工厂生产产品
product.fuel() # 使用产品的"补充燃料"功能
product.fly() # 使用产品"飞行"的功能
if __name__ == '__main__':
# 创建一个飞机工厂
plane_factory = PlaneFactory()
# 让飞机工厂干活
work(plane_factory)
# 创建一个火箭工厂
rocket_factory = RocketFactory()
# 让火箭工厂干活
work(rocket_factory)
抽象工厂模式
from abc import ABC, abstractmethod
# 抽象产品
class Product(ABC):
@abstractmethod
def show(self):
pass
# 抽象键盘产品
class KeyBoard(Product):
@abstractmethod
def show(self):
pass
# 抽象鼠标产品
class Mouse(Product):
@abstractmethod
def show(self):
pass
# 具体键盘产品1
class MikaKeyBoard(KeyBoard):
def show(self):
print("Mika键盘")
# 具体键盘产品2
class PikiKeyBoard(KeyBoard):
def show(self):
print("Piki键盘")
# 具体鼠标产品1
class MikaMouse(Mouse):
def show(self):
print("Mika鼠标")
# 具体鼠标产品2
class PikiMouse(Mouse):
def show(self):
print("Piki鼠标")
# 抽象工厂类
class Factory(ABC):
@abstractmethod
def produce_keyboard(self):
pass
@abstractmethod
def produce_mouse(self):
pass
# 具体工厂1
class MikaFactory(Factory):
def produce_keyboard(self):
return MikaKeyBoard()
def produce_mouse(self):
return MikaMouse()
# 具体工厂2
class PikiFactory(Factory):
def produce_keyboard(self):
return PikiKeyBoard()
def produce_mouse(self):
return PikiMouse()
# 测试
def work(factory):
keyborad = factory.produce_keyboard() # 工厂制作键盘
mouse = factory.produce_mouse() # 工厂制作鼠标
keyborad.show() # 查看键盘信息
mouse.show() # 查看鼠标信息
if __name__ == '__main__':
# 创造Mika工厂，让它运行工作
factory = MikaFactory()
work(factory)
# 创建Piki工厂，让它运行工作
factory = PikiFactory()
work(factory)
建造者模式
"""
小明想要给自己的"戴尔"电脑外接一些设备：Mika鼠标、Piki键盘
小花想要给自己的"联想"电脑外接一些设备：Piki鼠标、Mika键盘
1. 找到技术人员告诉需求
2. 技术员工进行组装
3. 检查组装情况
"""
from abc import ABC, abstractmethod
# 组装电脑（抽象）
class AssembleComputer(ABC):
@abstractmethod
def install_mouse(self, brand): # 安装鼠标（抽象）
pass
@abstractmethod
def install_keyboard(self, brand): # 安装键盘（抽象）
pass
@abstractmethod
def show(self): # 查看组装的状态（抽象）
pass
# 组装"戴尔"电脑（具体）
class AssembleDellComputer(AssembleComputer):
def __init__(self):
self.__installation_list = [] # 安装列表，用来记录当前已经成功安装了的组件
def install_mouse(self, brand):
self.__installation_list.append(f"{brand}鼠标")
print(f"已安装：{brand}鼠标")
def install_keyboard(self, brand):
self.__installation_list.append(f"{brand}键盘")
print(f"已安装：{brand}键盘")
def show(self):
print("此电脑的所有外接设备：", end="")
for item in self.__installation_list:
print(item, end=", ")
print()
# 组装"联想"电脑（具体）
class AssembleLenovoComputer(AssembleComputer):
def __init__(self):
self.__installation_list = [] # 安装列表，用来记录当前已经成功安装了的组件
def install_mouse(self, brand):
self.__installation_list.append(f"{brand}鼠标")
print(f"已安装：{brand}鼠标")
def install_keyboard(self, brand):
self.__installation_list.append(f"{brand}键盘")
print(f"已安装：{brand}键盘")
def show(self):
print("此电脑的所有外接设备：", end="")
for item in self.__installation_list:
print(item, end=", ")
print()
# 建造者（抽象）
class Builder(ABC):
def __init__(self, computer_type):
# self.product 里面保存(维护)着一个组装对象
if computer_type == "戴尔":
self._product = AssembleDellComputer()
elif computer_type == "联想":
self._product = AssembleLenovoComputer()
else:
raise "电脑类型错误！"
@abstractmethod
def install_mouse(self, brand):
pass
@abstractmethod
def install_keyboard(self, brand):
pass
@abstractmethod
def check(self):
pass
# 建造者（具体）————技术人员
class Technician(Builder):
# 技术人员安装鼠标
def install_mouse(self, brand):
print(f"技术人员正在安装{brand}鼠标...")
self._product.install_mouse(brand)
print(f"技术人员安装{brand}鼠标成功！")
# 技术人员安装键盘
def install_keyboard(self, brand):
print(f"技术人员正在安装{brand}键盘...")
self._product.install_keyboard(brand)
print(f"技术人员安装{brand}键盘成功！")
# 技术人员检查安装情况
def check(self):
print("技术人员正在检查设备的安装情况...")
print("技术人员检查完毕，安装结果如下：")
self._product.show()
if __name__ == '__main__':
# 创造一个负责组装戴尔电脑的技术人员
t1 = Technician("戴尔")
# 创造一个负责组装联想电脑的技术人员
t2 = Technician("联想")
# 小明告诉 t1 技术人员，组装 Mika鼠标、Piki键盘，技术人员根据要求进行安装
t1.install_mouse("Mika")
t1.install_keyboard("Piki")
# 小花告诉 t2 技术人员，组装 Piki鼠标、Mika键盘，技术人员根据要求进行安装
t2.install_mouse("Piki")
t2.install_keyboard("Mika")
# t1 技术人员检查组装情况
t1.check()
# t2 技术人员检查组装情况
t2.check()
原型模式
import copy # 导入copy模块，用于深度复制对象
# 定义一个名为 Prototype(原型)的类，用于管理对象的注册、注销和克隆
class Prototype:
def __init__(self):
self._objects = {} # 初始化一个字典来存储注册的对象，键为名称，值为对象实例
def register_object(self, name, obj):
"""
注册一个对象到_objects字典中
:param name: 对象的名称
:param obj: 要注册的对象实例
"""
self._objects[name] = obj
def unregister_object(self, name):
"""
从_objects字典中注销一个对象
:param name: 要注销的对象的名称
"""
del self._objects[name]
def clone(self, name, **attr):
"""
克隆一个已注册的对象，并更新其内部属性字典
:param name: 要克隆的对象的名称
:param attr: 要更新的属性字典，使用关键字参数传入
:return: 克隆并更新后的对象实例
"""
obj = copy.deepcopy(self._objects.get(name)) # 使用deepcopy进行深度复制，得到一个新的对象实例
obj.__dict__.update(attr) # 更新对象的__dict__属性，即更新其内部属性。 attr == {'a': 1, 'b': 2, 'c': 3}
return obj
def test():
# 定义一个类A，用于演示
class A:
def __str__(self):
return "I am A"
# 创建A的一个实例a
a = A()
# 创建一个Prototype实例，用于管理对象
prototype = Prototype()
# 将a注册到prototype中，名称为'a'
prototype.register_object('a', a)
# 克隆a并更新其内部属性，得到b
b = prototype.clone('a', a=1, b=2, c=3)
# 打印a的字符串表示
print(a)
# 打印b的内部属性字典
print(b.__dict__)
# 尝试打印b的属性a, b, c
print(b.a)
print(b.b)
print(b.c)
if __name__ == '__main__':
test()
补充说明：
-
原型模式（Prototype Pattern）是一种创建型设计模式，它允许一个对象通过复制其自身的内部状态来创建新的对象实例。
-
这种复制过程可以被称为“克隆”。
-
原型模式提供了一种不依赖于类的构造函数来创建对象实例的方式，而是使用现有的对象实例来创建新的对象。
原型模式的作用：
- 性能优化：当对象的创建过程非常复杂或者代价非常高时，使用原型模式可以避免重复执行这些复杂的操作，从而提高性能。通过克隆一个已经存在的对象，可以快速地生成新的对象实例。
- 避免子类的构造函数被频繁调用：在继承层次较深的场景下，频繁地调用子类的构造函数可能会带来性能问题。通过原型模式，可以避免这种情况，因为对象的创建是通过克隆来完成的。
- 动态扩展：由于原型模式允许在运行时动态地添加或删除对象，因此它可以支持动态扩展。这意味着可以根据需要动态地改变系统中对象的数量或类型。
- 简化对象创建：当对象创建涉及复杂的配置或设置时，原型模式可以提供一个更简单的创建对象的方式。通过克隆一个已经配置好的对象实例，可以快速地生成具有相同配置的新对象。
示例代码中的原型模式：
- 在示例代码中，
Prototype类就是一个原型管理器的实现。 - 它维护了一个存储已注册对象的字典（
_objects）。 - 通过
register_object()方法可以将对象注册到字典中，通过unregister_object()方法可以从字典中注销对象。 clone()方法则用于克隆已注册的对象，并允许通过关键字参数来更新克隆对象的属性。- 这个示例代码中的
A类是一个简单的类，用于演示原型模式的使用。 - 通过创建一个
A类的实例a，并将其注册到Prototype实例中，然后调用clone()方法来克隆a并更新其属性，可以得到一个新的对象实例b。 - 这个过程中，
a和b是独立的对象实例，但它们具有相同的初始状态（因为b是a的克隆），并且b的属性可以被单独更新。
总结
创建型模式总结
- 单例模式：创建一个全局的对象
- 工厂方法模式：实现单个类的对象的创建
- 抽象工厂模式：实现多个类的对象的创建
- 建造者模式：实现复杂类的对象的创建
- 原型模式：实现自身类的克隆
1286
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
