Python常用设计模式

设计模式

使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性
1.单例设计模式
目的：让类创建的对象，在系统中只有 唯一的一个实例；每一次执行类名() 返回的对象，内存地址是相同的
实用场景：音乐播放对象；回收站对象；打印机对象

Python 创建单例模式的三种方式

方法一：使用装饰器
装饰器维护一个字典对象instances，缓存了所有单例类，只要单例不存在则创建，已经存在直接返回该实例对象。

def singleton(cls):
    instances = {} 
    def wrapper(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls] 
    return wrapper
@singleton
class Foo(object):
    pass
foo1 = Foo()
foo2 = Foo()
print foo1 is foo2  返回True

方法二：使用基类
new是真正创建实例对象的方法，所以重写基类的new方法，以此来保证创建对象的时候只生成一个实例

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance
class Foo(Singleton):
    pass
foo1 = Foo()
foo2 = Foo()
print foo1 is foo2  返回True

方法三：使用元类
元类是用于创建类对象的类，类对象创建实例对象时一定会调用call方法，因此在调用call时候保证始终只创建一个实例即可，type是python中的一个元类。）是用于创建类对象的类，类对象创建实例对象时一定会调用call方法，因此在调用call时候保证始终只创建一个实例即可，type是python中的一个元类。

class Singleton(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instance 
class Foo(object):
    __metaclass__ = Singleton
foo1 = Foo()
foo2 = Foo()
print foo1 is foo2  返回True

2.工厂模式
不直接向客户暴露对象创建的实现细节,而是通过一个工厂类来负责创建产品类的实例

适用场景:需要生产多种,大量复杂对象的时候,需要降低代码耦合度的时候,当系统中的产品类经常需要扩展的时候

from abc import ABCMeta,abstractmethod

class Operation():
    def __init__(self,NumberA=0,NumberB=0):
        self.NumberA = NumberA
        self.NumberB = NumberB

    def GetResult(self):
        pass

class AddOp(Operation):
    def GetResult(self):
        return self.NumberB + self.NumberA

class MinusOp(Operation):
    def GetResult(self):
        return self.NumberA - self.NumberB

class MultiOp(Operation):
    def GetResult(self):
        return self.NumberA * self.NumberB

class DivideOp(Operation):
    def GetResult(self):
        try:
            return 1.0*self.NumberA / self.NumberB
        except ZeroDivisionError:
            raise

class OperationFatory():
    def ChooseOperation(self,op):
        if op == '+':
            return AddOp()
        if op == '-':
            return MinusOp()
        if op == '*':
            return MultiOp()
        if op == '/':
            return DivideOp()

if __name__ == '__main__':
    ch = ''
    while not ch=='q': 
        NumberA = eval(raw_input('Please input number1:  '))
        op = str(raw_input('Please input the operation:  '))
        NumberB = eval(raw_input('Please input number2:  '))
        OPFactory = OperationFatory()
        OPType = OPFactory.ChooseOperation(op)
        OPType.NumberA = NumberA
        OPType.NumberB = NumberB
        print 'The result is:',OPType.GetResult()
        print '\n#--  input q to exit any key to continue'
        try:
            ch = str(raw_input())
        except:
            ch = ''

3.装饰器
闭包：在函数内部再定义一个函数，并且这个函数用到外部函数的变量，那么将这个韩式和用到的一些变量称为闭包。
装饰器本质上是一个 Python 函数，它可以让其他函数在不需要做任何代码修改的前提下增加额外的功能，装饰器的返回值也是一个函数对象。

def set_fun(test):
    def call_fun(*args, **kwargs):
        print("对原函数进行添加权限")
        print(args, kwargs)
        test(*args, **kwargs)

    return call_fun

@set_fun   # 等价于test = set_func(test)
def test(*args, **kwargs):
    print("原函数的功能")
    print(args, kwargs)
test()

4.生成器
在Python 中，一边循环一边计算的机制，称为生成器：generator，生成器是可以迭代对象，但是生成器可以通过send 传值返回到前面；
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，迭代器是一个可以记住遍历的位置的对象。迭代器是一个拥有next 方法和iter 方法