Python创建型模式

抽象工厂模式

模式特点：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的类。
程序实例：提供对不同主题的信件和简历。
　　　　　Letter和Resume是两种不同的抽象产品，它们都有Fancy和Modern这两种不同的主题；DocumentCreator是产生Letter和Resume的抽象工厂，根据具体实现（FancyDocumentCreator和ModernDocumentCreator）产生对应的具体的对象（ModernLetter与ModernResume，或者FancyLetter与FancyResume）

class Letter:
    def getInfo(self):
        pass

class Resume:
    def getInfo(self):
        pass

class FancyLetter(Letter):
    def getInfo(self):
        print 'I am FancyLetter'
        
class FancyResume(Resume):
    def getInfo(self):
        print 'I am FancyResume'
        
class ModernLetter(Letter):
    def getInfo(self):
        print 'I am ModernLetter'
        
class ModernResume(Resume):
    def getInfo(self):
        print 'I am ModernResume'

        
class DocumentCreator:
    def createLetter(self):
        pass
    def createResume(self):
        pass

class FancyDocumentCreator(DocumentCreator):
    def createLetter(self):
        temp = FancyLetter()
        return temp
    def createResume(self):
        temp = FancyResume()
        return temp
    
class ModernDocumentCreator(DocumentCreator):
    def createLetter(self):
        temp = ModernLetter()
        return temp
    def createResume(self):
        temp = ModernResume()
        return temp
    

def create(Factory):
    letter = Factory.createLetter()
    resume = Factory.createResume()
    letter.getInfo()
    resume.getInfo()
    
def main():
    create(ModernDocumentCreator())
    create(FancyDocumentCreator())

if __name__ == '__main__':
    main()

建造者模式

模式特点：将一个复杂对象的构建(Director)与它的表示(Builder)分离，使得同样的构建过程可以创建不同的表示(ConcreteBuilder)。

程序实例：“画”出一个四肢健全（头身手腿）的小人

图片.png

class Person:
    def CreateHead(self):
        pass
    def CreateHand(self):
        pass
    def CreateBody(self):
        pass
    def CreateFoot(self):
        pass

class ThinPerson(Person):
    def CreateHead(self):
        print "thin head"
    def CreateHand(self):
        print "thin hand"
    def CreateBody(self):
        print "thin body"
    def CreateFoot(self):
        print "thin foot"

class ThickPerson(Person):
    def CreateHead(self):
        print "thick head"
    def CreateHand(self):
        print "thick hand"
    def CreateBody(self):
        print "thick body"
    def CreateFoot(self):
        print "thick foot"

class Director:
    def __init__(self,temp):
        self.p = temp
    def Create(self):
        self.p.CreateHead()
        self.p.CreateBody()
        self.p.CreateHand()
        self.p.CreateFoot()

if __name__ == "__main__":
    p = ThickPerson()
    d = Director(p)
    d.Create()

建造者模式与工厂模式的区别：

工厂模式一般都是创建一个产品，注重的是把这个产品创建出来就行，只要创建出来，不关心这个产品的组成部分。从代码上看，工厂模式就是一个方法，用这个方法就能生产出产品。
建造者模式也是创建一个产品，但是不仅要把这个产品创建出来，还要关系这个产品的组成细节，组成过程。从代码上看，建造者模式在建造产品时，这个产品有很多方法，建造者模式会根据这些相同方法但是不同执行顺序建造出不同组成细节的产品。
可以比较两个模式的example代码，一比较就会比较出来，工厂模式关心整体，建造者模式关心细节,比如上面代码中我可以创建一个没有手的人，但是工厂模式只关心这个对象的创建。

工厂方法模式

模式特点：定义一个用于创建对象的接口，让子类决定实例化哪一个类。这使得一个类的实例化延迟到其子类。

程序实例：基类键盘类，派生出微软键盘类和罗技键盘类，由这两种子类完成生成键盘工作。子类的创建由键盘工厂的对应的子类完成。

图片.png

class Keyboard:
    def Create(self):
        print " keyboard"

class MicrKeyboard(Keyboard):
    def Create(self):
        print "microsoft keyboard"

class LogiKeyboard(Keyboard):
    def Create(self):
        print "logitech keyboard"

class KeyboardFactory:
    def CreateKeyboard(self):
        temp = KeyBoard()
        return temp

class MicrFactory(KeyboardFactory):
    def CreateKeyboard(self):
        temp = MicrKeyboard()
        return temp

class LogiFactory(KeyboardFactory):
    def CreateKeyboard(self):
        temp = LogiKeyboard()
        return temp

if __name__ == "__main__":
    mf = MicrFactory()
    m=mf.CreateKeyboard()
    m.Create()
    lf = LogiFactory()
    l=lf.CreateKeyboard()
    l.Create()

抽象工厂模式-与-工厂方法模式区别 :

工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类可以创建多个具体产品类的实例。
比如罗技A、微软B工厂都生产鼠标，则A,B就是抽象工厂，
每个工厂生产的鼠标和键盘就是产品，对应于工厂方法。
用了工厂方法模式，你替换生成键盘的工厂方法，就可以把键盘从罗技换到微软。
但是用了抽象工厂模式，你只要换家工厂，就可以同时替换鼠标和键盘一套。如果你要的产品有几十个，当然用抽象工厂模式一次替换全部最方便（这个工厂会替你用相应的工厂方法）

原型模式

模式特点：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

程序实例：从点原型，生成新的点
Python中有7中方法实现

图片.png

import copy

class Point:
    __slots__ = ("x","y")
    
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
de make_object(Class, *args, **kwargs):
    return Class(*args, **kwargs)

if __name__ = '__main__':
    point1 = Point(1,2)
    point2 = eval("{}({},{})".format("Point", 2, 4))
    point3 = getattr()["Point"](3,6)
    point4 = globals()["Point"](4,8)
    point5 = make_object(5,10)
    point6 = copy.deepcopy(point5)
    point6.x = 6
    point6.y = 12
    point7 = point1.__class__(7, 14)

单例模式

模式特点：保证类仅有一个实例，并提供一个访问它的全局访问点。

说明：为了实现单例模式费了不少工夫，后来查到一篇博文对此有很详细的介绍，而且实现方式也很丰富，通过对代码的学习可以了解更多Python的用法。以下的代码出自GhostFromHeaven的专栏，地址：http://blog.csdn.net/ghostfromheaven/article/details/7671853。不过正如其作者在Python单例模式终极版所说：

我要问的是，Python真的需要单例模式吗？我指像其他编程语言中的单例模式。

答案是：不需要！

因为，Python有模块（module），最pythonic的单例典范。

模块在在一个应用程序中只有一份，它本身就是单例的，将你所需要的属性和方法，直接暴露在模块中变成模块的全局变量和方法即可！

Python创建型模式

抽象工厂模式

建造者模式

建造者模式与工厂模式的区别：

工厂方法模式

抽象工厂模式-与-工厂方法模式区别 :

原型模式

单例模式

你可能感兴趣的:(Python创建型模式)