python单例模式与metaclass
单例模式的实现方式
将类实例绑定到类变量上
class Singleton(object): _instance = None def __new__(cls, *args): if not isinstance(cls._instance, cls): cls._instance = super(Singleton, cls).__new__(cls, *args) return cls._instance
但是子类在继承后可以重写 __new__ 以失去单例特性
class D(Singleton): def __new__(cls, *args): return super(D, cls).__new__(cls, *args)
使用装饰器实现
def singleton(_cls): inst = {} def getinstance(*args, **kwargs): if _cls not in inst: inst[_cls] = _cls(*args, **kwargs) return inst[_cls] return getinstance @singleton class MyClass(object): pass
问题是这样装饰以后返回的不是类而是函数,当然你可以 singleton 里定义一个类来解决问题,但这样就显得很麻烦了
使用 __metaclass__ ,这个方式最推荐
class Singleton(type): _inst = {} def __call__(cls, *args, **kwargs): if cls not in cls._inst: cls._inst[cls] = super(Singleton, cls).__call__(*args) return cls._inst[cls] class MyClass(object): __metaclass__ = Singleton
metaclass
元类就是用来创建 类 的东西,可以简单把元类称为“类工厂”,类是元类的实例。 type 就是Python的内建元类, type 也是自己的元类,任何一个类
>>> type(MyClass) type >>> type(type) type
python在创建类 MyClass 的过程中,会在类的定义中寻找 __metaclass__ ,如果存在则用其创建类 MyClass ,否则使用内建的 type 来创建类。对于类有继承的情况,如果当前类没有找到,会继续在父类中寻找 __metaclass__ ,直到所有父类中都没有找到才使用 type 创建类。
如果模块里有 __metaclass__ 的全局变量的话,
,亲自试了,没这个作用,无任何影响
查看 type 的定义,
type(object) -> the object's typetype(name, bases, dict) -> a new type
所以利用 type 定义一个类的元类,可以用函数返回一个上面第二种定义的对象,也可以继承 type 并重写其中的方法。
直接使用type生成的对象作为元类,函数作用是使属性变为大写
def update_(name, bases, dct): attrs = ((name, value) for name, value in dct.items() if not name.startswith('__')) uppercase_attr = {name.upper(): value for name, value in attrs} return type(name, bases, uppercase_attr) class Singleton(object): __metaclass__ = update_ abc = 2 d = Singleton() print d.ABC # 2
上一节中,单例模式 元类实现 用的是类继承方式,而对于第一种 __new__ 的方式,本质上调用的是 type.__new__ ,不过使用 super 能使继承更清晰一些并避免一些问题
这里简单说明一下, __new__ 是在 __init__ 前调用的方法,会创建对象并返回,而 __init__ 则是用传入的参数将对象初始化。看一下 type 中这两者以及 __call__ 的实现
def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__ """ type(object) -> the object's type type(name, bases, dict) -> a new type # (copied from class doc) """ pass @staticmethod # known case of __new__ def __new__(S, *more): # real signature unknown; restored from __doc__ """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ pass def __call__(self, *more): # real signature unknown; restored from __doc__ """ x.__call__(...) <==> x(...) """ pass
前面提到类相当于元类的实例化,再联系创建单例模式时使用的函数,用的是 __call__ ,其实用三种magic method中任何一种都是可以的,来看一下使用元类时各方法的调用情况
class Basic(type): def __new__(cls, name, bases, newattrs): print "new: %r %r %r %r" % (cls, name, bases, newattrs) return super(Basic, cls).__new__(cls, name, bases, newattrs) def __call__(self, *args): print "call: %r %r" % (self, args) return super(Basic, self).__call__(*args) def __init__(cls, name, bases, newattrs): print "init: %r %r %r %r" % (cls, name, bases, newattrs) super(Basic, cls).__init__(name, bases, dict) class Foo: __metaclass__ = Basic def __init__(self, *args, **kw): print "init: %r %r %r" % (self, args, kw) a = Foo('a') b = Foo('b')
结果
new: <class '__main__.Basic'> 'Foo' () {'__module__': '__main__', '__metaclass__': <class '__main__.Basic'>, '__init__': <function init at 0x106fd5320>}
init: <class '__main__.Foo'> 'Foo' () {'__module__': '__main__', '__metaclass__': <class '__main__.Basic'>, '__init__': <function init at 0x106fd5320>}
call: <class '__main__.Foo'> ('a',)
init: <__main__.Foo object at 0x106fee990> ('a',) {}
call: <class '__main__.Foo'> ('b',)
init: <__main__.Foo object at 0x106feea50> ('b',) {}
元类的 __init__ 和 __new__ 只在创建类 Foo 调用了一次,而创建 Foo 的实例时,每次都会调用元类的 __call__ 方法
</div>