Python设计模式

1.工厂模式

工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。

class CarFactory:
   def createCar(self,brand):
       if brand == "奔驰":
           return Benz()
       elif brand == "宝马":
           return BMW()
       elif brand == '比亚迪':
           return BYD()
       else:
           return "未知品牌，无法创建"
class Benz:
   pass
class BMW:
   pass
class BYD:
   pass
factory = CarFactory()
c1 = factory.createCar("奔驰")
c2 = factory.createCar("宝马")
print(c1)
print(c2)
#执行结果：
#<__main__.Benz object at 0x021C5770>
#<__main__.BMW object at 0x021C5790>

2.单例模式

单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。
单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久驻留内存中，从而极大的降低开销。
单例模式有多种实现的方式，我们这里推荐重写 new() 的方法。

class MySingleton:
    __obj = None
    __init_flag = True
    
    def __new__(cls, *args, **kwargs):
        if cls.__obj == None:
        	cls.__obj = object.__new__(cls)
        return cls.__obj
        
    def __init__(self,name):
        if MySingleton.__init_flag:
            print("init....")
            self.name = name
            MySingleton.__init_flag = False
a = MySingleton("aa")
print(a)
b = MySingleton("bb")
print(b)
#执行结果：
#init....
#<__main__.MySingleton object at 0x01E15610>
#<__main__.MySingleton object at 0x01E15610>

代码的详细解释：
类变量：
_obj：用于存储 MySingleton 的唯一实例。初始化为 None。
__init_flag: 一个标志，用于确保__init__方法只被调用一次。初始化为 True。

__new__方法:
__new__是一个静态方法，用于创建并返回类的新实例。在Python中，当你尝试创建一个对象时，__new__方法首先被调用，然后才是__init__方法。
在这个__new__方法中，首先检查 __obj 是否为 None。如果是，则创建一个新的 MySingleton 实例并赋值给 __obj。无论是否创建新实例，都会返回 __obj。这样，即使多次尝试创建 MySingleton 的实例，也只会返回第一次创建的那个实例。

__init__方法:
__init__方法是类的初始化方法，用于设置对象的初始状态。
在这个 __init__方法中，首先检查 __init_flag是否为 True。如果是，则打印 “init…”，设置实例的 name 属性，并将 __init_flag 设置为 False。由于 __init_flag 在第一次初始化后被设置为 False，所以后续的 MySingleton 实例创建（虽然实际上不会创建新的实例，但__init__方法仍然会被调用）不会再次执行初始化代码。
代码执行流程：
创建一个名为 a 的 MySingleton 实例，并传入参数 “aa”。此时，__new__创建一个新实例，__init__也被调用，所以 “init…” 会被打印，并且 a 的 name 属性被设置为 “aa”。
创建一个名为 b 的 MySingleton 实例，并传入参数 “bb”。但是，由于 MySingleton 是一个单例类，所以 b 实际上与 a 是同一个对象。虽然 __init__方法会被调用（因为 __new__返回了同一个对象），但由于 __init_flag 已经被设置为 False，所以不会再次执行初始化代码。因此，“init…” 不会被再次打印，并且 b 的 name 属性仍然是 “aa”，而不是 “bb”。

3.工厂和单例模式结合

将工厂类定义成“单例”，只需要简单的套用即可实现：

#测试工厂模式和单例模式的整合使用
class CarFactory:
   __obj = None           #类属性
   __init_flag = True
   def create_car(self,brand):
       if brand =="奔驰":
           return Benz()
       elif brand =="宝马":
           return BMW()
       elif brand == "比亚迪":
           return BYD()
       else:
           return "未知品牌，无法创建"
   def __new__(cls, *args, **kwargs):
	   if cls.__obj ==None:
	       cls.__obj = object.__new__(cls)
       return cls.__obj
   def __init__(self):
       if CarFactory.__init_flag:
           print("init CarFactory....")
           CarFactory.__init_flag = False
class Benz:
   pass
class BMW:
   pass
class BYD:
   pass
factory = CarFactory()
c1 = factory.create_car("奔驰")
c2 = factory.create_car("比亚迪")
print(c1)
print(c2)
factory2 = CarFactory()
print(factory)
print(factory2)
#执行结果：
#init CarFactory....
#<__main__.Benz object at 0x01E36E90>
#<__main__.BYD object at 0x01E36C30>
#<__main__.CarFactory object at 0x01E36730>
#<__main__.CarFactory object at 0x01E36730>