python实现单例模式，理解装饰器模式

用__new__来实现单例模式

单例模式就是只有一个实例，从而减少创建实例的开销

# __new__是新式类都有的一个静态方法
# 原型是obj.__new__(cls[,...])
# 一般我们创建一个实例都是先调用类的__new__方法，然后调用实例方法__init__进行初始化
c = C(2)# 实际执行一下步骤
c = C.__new(C, 2)
if isinstance(c,C):
    C.__init__(c,2)

# 重写__new__方法是，解释器自动判断这个方法为静态方法，不用@staticmethod

class Singleton(object):
    _singletons = {}
    def __new__(cls):
        if not cls._singletons.has_key(cls):
            cls._singletons[cls] = object.__new__(cls)
        return cls._singletons[cls]

# test
a = Singleton()
b = Singleton()
print(id(a) == id(b))    # True

 第二种方法：

class Singleton(object):
    def __new__(cls, *args, **kw):
        if not hasattr(cls, '_instance'):
            orig = super(Singleton, cls)
            cls._instance = orig.__new__(cls, *args, **kw)
        return cls._instance

class MyClass(Singleton):
    a = 1

第三种方法：

class Borg(object):
    _state = {}
    def __new__(cls, *args, **kw):
        ob = super(Borg, cls).__new__(cls, *args, **kw)
        ob.__dict__ = cls._state
        return ob

class MyClass2(Borg):
    a = 1

第四种方法：

def singleton(cls):
    instances = {}
    def getinstance(*args, **kw):
        if cls not in instances:
            instances[cls] = cls(*args, **kw)
        return instances[cls]
    return getinstance

@singleton
class MyClass:
  ...

第五种方法：

# mysingleton.py
class My_Singleton(object):
    def foo(self):
        pass

my_singleton = My_Singleton()

# to use
from mysingleton import my_singleton

my_singleton.foo()

 

装饰器--面向切面编程AOP

是通过函数闭包实现的，作用就是为已经存在的对象（python一切皆对象）添加额外的功能

装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，比如插入日志，性能测试，事务处理等等。

有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并且重用

def log(func):
    def wrapper(*args,**kw):
        print('call function {}'.format(func.__name__)
        return func(*args,**kw)
    return wrapper   # 返回的是引用


@log
def now():
    print('2020-5-11')


now()   # 调用


# 等价于

xx = log(now)