Python设计模式

代理模式:https://blog.youkuaiyun.com/liuskyter/article/details/80362722

单例模式:

__call__实现单例

class MyMeta(type):
    obj =None  #创建一个空的类对象 
    def __call__(self,*args,**kwargs):  #call 方法比init方法执行更提前,子类实例化成对象的时候会被调用
        if not self.obj:       #如果obj对象不为None,这里的self是player类
            obj = object.__new__(self)     #object类中调用new方法,创建一个空的对象
            self.obj = obj    #赋值给self.的self.obj变量,这里是把,一个对象赋值给一个变量。
            self.__init__(obj,*args,**kwargs)  #调用player中的init方法
        return self.obj   #这个return一定要注意缩进,现在的缩进是表明不管if这个条件成立或者不成立,都会返回self.obj对象,假设对象已经创建的话

   



class player(metaclass=MyMeta):
    obj =None

	def __init__(self,*args,**kwargs):
	    print('你创建个了播放器对象')
	    pass
	
	def play(self,path):
	    print('playing'+path)

__new__实现单例

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'instance'):
            cls.instance = super(Person,cls).__new__(cls)
        return cls.instance


a = Person('p1',20)
b = Person('p2',21)
print(a == b)

工厂模式

简单工厂

构造简单工厂把所有汽车实例化的过程封装在里面。

class SimpleCarFactory(object):
    """简单工厂
    """
    @staticmethod
    def product_car(name):
        if name == 'mb':
            return Mercedes()
        elif name == 'bmw':
            return BMW()

有了SimpleCarFactory类后,就可以通过向固定的接口传入参数获得想要的对象实例。

c1 = SimpleCarFactory.product_car('mb')
c2 = SimpleCarFactory.product_car('bmw')
工厂方法
#coding=utf-8
import abc

class AbstractFactory(object):
    """抽象工厂
    """
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def product_car(self):
        pass

class MercedesFactory(AbstractFactory):
    """梅赛德斯工厂
    """
    def product_car(self):
        return Mercedes()

class BMWFactory(AbstractFactory):
    """宝马工厂
    """
    def product_car(self):
        return BMW()

每个工厂负责生产自己的产品也避免了我们在新增产品时需要修改工厂的代码,而只要增加相应的工厂即可。如新增一个Audi产品,只需新增一个Audi类和AudiFactory类。

c1 = MercedesFactory().product_car()
c2 = BMWFactory().product_car()
抽象工厂

如果我们要生产很多产品,就会发现我们同样需要写很多对应的工厂类。比如如果MercedesFactory和BMWFactory不仅生产小汽车,还要生产SUV,那我们用工厂方法就要再多构造两个生产SUV的工厂类。所以为了解决这个问题,我们就要再更进一步的抽象工厂类,让一个工厂可以生产同一类的多个产品,这就是抽象工厂。

#coding=utf-8
import abc

# 两种小汽车
class Mercedes_C63(object):
    """梅赛德斯 C63
    """
    def __repr__(self):
        return "Mercedes-Benz: C63"

class BMW_M3(object):
    """宝马 M3
    """
    def __repr__(self):
        return "BMW: M3"

# 两种SUV
class Mercedes_G63(object):
    """梅赛德斯 G63
    """
    def __repr__(self):
        return "Mercedes-Benz: G63"

class BMW_X5(object):
    """宝马 X5
    """
    def __repr__(self):
        return "BMW: X5"

class AbstractFactory(object):
    """抽象工厂
    可以生产小汽车外,还可以生产SUV
    """
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def product_car(self):
        pass

    @abc.abstractmethod
    def product_suv(self):
        pass

class MercedesFactory(AbstractFactory):
    """梅赛德斯工厂
    """
    def product_car(self):
        return Mercedes_C63()

    def product_suv(self):
        return Mercedes_G63()

class BMWFactory(AbstractFactory):
    """宝马工厂
    """
    def product_car(self):
        return BMW_M3()

    def product_suv(self):
        return BMW_X5()

我们让基类AbstractFactory同时可以生产汽车和SUV,然后令MercedesFactory和BMWFactory继承AbstractFactory并重写product_car和product_suv方法即可。

c1 = MercedesFactory().product_car()
s1 = MercedesFactory().product_suv()
print(c1, s1)
s2 = BMWFactory().product_suv()
c2 = BMWFactory().product_car()
print(c2, s2)

结论:
简单工厂模式适用于需创建的对象较少,不会造成工厂方法中的业务逻辑太过复杂的情况下,而且用户只关心那种类型的实例被创建,并不关心其初始化过程时,比如多种数据库(MySQL/MongoDB)的实例,多种格式文件的解析器(XML/JSON)等。
工厂方法模式继承了简单工厂模式的优点又有所改进,其不再通过一个工厂类来负责所有产品的创建,而是将具体创建工作交给相应的子类去做,这使得工厂方法模式可以允许系统能够更高效的扩展。实际应用中可以用来实现系统的日志系统等,比如具体的程序运行日志,网络日志,数据库日志等都可以用具体的工厂类来创建。
抽象工厂模式在工厂方法基础上扩展了工厂对多个产品创建的支持,更适合一些大型系统,比如系统中有多于一个的产品族,且这些产品族类的产品需实现同样的接口,像很多软件系统界面中不同主题下不同的按钮、文本框、字体等等。

建造者模式

在玩射击类游戏时,假设我们买了一把主武器,需要给它配上一些配件,那么我们购买的主武器主类。

class Main(object):
	def __init__(self, name):
		self.name = name
	def muffler_level(self,muffler_level):  #消音效果
		self.muffler_level= muffler_level
	def capacity(self,capacity_level): #弹夹容量
		self.capacity_level= capacity_level

实例化主武器类

m4 = Main('m4')

然后我们买了A品牌的消音器和B品牌的弹夹

消音器类muffler

class Muffler(self, name,muffler_level):
	def __init__(self,name.muffler_level):
			self.name = name 
			self.muffler_level = muffler_level

弹夹类 capacity

class Capacity(self,name,capacity_level):
	def __init__(self,capacity):
		self.name = name 
		self.capacity = capacity

实例化两个配件类

muffler_A =  Muffler('A',90)
capacity_B = Capacity('B','30')

装配武器,我们实例化的m4的消音效果和弹夹容量取决于我们购买的消音器A和弹夹B的属性,把(一个类的属性或实例化对象)封装成另一个类的属性,这种方式我们叫做建造者模式。

m4.muffler_level(muffler_A.muffler_level)
m4.capaciy(capacity_B.capacity)

观察者模式:

https://www.jianshu.com/p/730d7c5bd596

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值