第四十篇 Python之设计模式总结-简单工厂、工厂方法、抽象工厂、单例模式

# 1. 定义一个工厂，对应图中的接受参数
class BigCat(object):
    # 接受参数（接受原材料）
    def __init__(self, money): 
        self.money = money
   # 工厂基本的生产模板
    def pay(self):
        print("收到大猫金融支付金额{0}".format(self.money))

# 2. 定义不同的产品生产线 
class WeChat(object):

    def __init__(self, money):
        self.money = money

    def pay(self):
        print("收到微信支付金额{0}".format(self.money))

class ZhiFuBao(object):

    def __init__(self, money):
        self.money = money

    def pay(self):
        print("收到支付宝支付金额{0}".format(self.money))

# 3. 输入参数(原材料入场)
channel = input("请选择支付方式：")
money = input("请输入消费金额：")

# 简单工厂，if...else判断就行了
# 4. 根据接收的不同原材料，判断是生产什么产品的，然后进行对应产品线的具体生产
# 如果是要微信支付
if channel == ‘WeChat‘:
    WeChat(money).pay()    # Wechat()实例化，生产微信对应的产品
elif channel == ‘ZhiFuBao‘:
    ZhiFuBao(money).pay()
else:
    BigCat(money).pay()

# 1. 先定义不同的支付方式（对应工厂里具体的产品），及每个产品具体的生产细节

class BigCat():
    # 关于传参的处理方式一： 有构造函数
    def __init__(self,money):
        self.money = money

    def pay(self):
        print("收到大猫金融的支付金额{0}".format(self.money))

class WeChat():
    # 关于传参的处理方式二：直接就没有构造函数，只在具体的方法里接受参数
    def pay(self, money):
        print("收到微信支付的金额{0}".format(money))

class ZhiFuBao():
    def __init__(self, money):
        self.money = money

    def pay(self):
        print("收到支付宝支付的金额{0}".format(self.money))

# 2. 为每个支付方式(每个产品）定义特定的工厂,每个工厂都有具体的工厂方法函数，负责返回
# 具体的工厂方法函数，其实就是对每个产品具体的生产细节进行了包装，让外部使用者只能用，却不知道具体的生产过程细节

# 3. 对外只提供这些特定的工厂（接口）
class BigCatFactory():
    # 关于传参的处理方式一:
    # 因为BigCat()类是需要传参的，return其实就是先调用BigCat()类，将BigCat()执行结果返回，所以也需要传参
    # 因此，可以在create的时候就传递参数
    def create(self,money):
        return  BigCat(money)

class WeChatFactory():
    # 关于传参的处理方式二：
    # WeChat()没有构造函数，初始化的时候不接收参数，所以对外提供的接口不需要传参
    # 只有在调用WeChat下面具体的pay()方法时才需要传递参数
    def create(self):
        return  WeChat()

class ZhiFuBaoFactory():
    def create(self, money):
        return  ZhiFuBao(money)

# 1. 先获取工厂
from factorymethodpractice import BigCatFactory

# 获取工厂
factory = BigCatFactory()

# 2. 调工厂去创建具体的产品
# 关于传参的处理方式一：在调用create的时候就给create传递参数
payment = factory.create(100)

# # 3. 有了具体的产品，就可以去执行具体产品里具体的逻辑了
payment.pay()

‘‘‘   -------------------------     ‘‘‘

from factorymethodpractice import WeChatFactory
factory = WeChatFactory()
payment = factory.create()
# 关于传参的处理方式二:只在调用具体方法的时候给需要传参的方法才传递参数
payment.pay(200)

# 接口文件 fruitfactorypractice.py


# 定义Apple产品类，实现具体的生产细节
class Apple():
    # 参数处理方式一：有构造方法
    def __init__(self,name):
        self.name = name

    def appleguantou(self):
        print("{}罐头生产出来了".format(self.name))

# 定义生产Apple的工厂方法
class AppleFactory():
    # create的时候就需要传递参数，因为Apple在实例化的时候就需要用到参数
    def create(self, name):
        return Apple(name)

### ++++++++++++++++++++++++++###


# 定义Pear产品类，实现具体的生产细节
class Pear(object):
    # 参数的处理方式二：没有构造方法
    def pearguantou(self,name):
        print("{}罐头生产出来了".format(name))
# 定义生产Pear的工厂方法
class PearFactory(object):
    # 参数的处理方式二：create的时候不需要传递参数，只有在调用到需要用参数的方法pearguantou的时候才传递参数
    def create(self):
        return Pear()

# 调用文件，使用工厂方法 文件名：usefactorymethod.py

from fruitfactorypractice import AppleFactory
factory = AppleFactory()
proment = factory.create(‘??‘)
proment.appleguantou()



from fruitfactorypractice import PearFactory
factory = PearFactory()
proment = factory.create()
proment.pearguantou("雪梨")

dd = __import__("lib.text.commons")  #这样仅仅导入了lib模块
dd = __import__("lib.text.commons",fromlist = True)  #改用这种方式就能导入成功
# 等价于import config
inp_func = input("请输入要执行的函数：")
f = getattr(dd,inp_func)
f()

# 示例代码
class Test():

    def __init__(self, name, price):
        self.name = name
        self.price = price
    def unit(self):
        pass

test = Test(‘彩票‘,666)

print(hasattr(test, ‘name‘))
print(hasattr(test, ‘prce‘))
print(hasattr(test, ‘unit‘))

# True
# False
# True

 # 先删除属性
delattr(test, ‘name‘)
# 再通过hasattr()查看该属性是否还存在
print(hasattr(test,‘name‘))  # False

# 注意：
# 这不是真的删除，而是只在内存里操作

# 修改name属性的值
setattr(test,‘name‘,‘励志人生‘)
print(test.name)

class Singleton():
    def __new__(cls, *args, **kwargs):
        # 在 new之前判断一下，如果已经存在"_instance"，就直接返回cls._instance
        # 如果不存在，就创建一个
        if not hasattr(cls, ‘_instance‘):
            print("还没有实例，即将创建一个实例")
            cls._instance = super(Singleton, cls).__init__(cls, )
        return cls._instance

# 实例化第一个实例，执行了if内的语句
single1 = Singleton()
# 还没有实例，即将创建一个实例

# 实例化第二个实例，没有执行if内的语句，因为已经存在一个实例了
single2 = Singleton()

# 通过id,内存地址验证，两个实例就是同一个对象
print(id(single1))
print(id(single2))
# 4334057560
# 4334057560

# 函数套函数，是闭包
‘‘‘
原理：
1. 有个字典
2. 以类名为key,以对象为value，存到这个字典里
3. 如果不存在就创建；如果存在就直接返回
‘‘‘

def singleton(cls, *args, **kw):
    instances = {}
    def get_instance():
        if cls not in instances:
            # 以类为key,以类的对象为值，存储起来
            instances[cls] = cls(*args, **kw)
        return instances[cls]
    return get_instance

# 修饰器是写函数名的，不能加();如果加()就是调用运行
@singleton
class Apple(object):
    pass

apple1 = Apple()
apple2 = Apple()
apple3 = Apple()
print(id(apple1))
print(id(apple2))
print(id(apple3))

# 4381172848
# 4381172848
# 4381172848