__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')每个工厂负责生产自己的产品也避免了我们在新增产品时需要修改工厂的代码，而只要增加相应的工厂即可。如新增一个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
