回忆一下之前type的介绍
class Foo(object): def __init__(self,name): self.name = name f = Foo("lxj") print( type(f)) # 输出:<class '__main__.Foo'> 表示,obj 对象由Foo类创建 print( type(Foo)) # 输出:<type 'type'> 表示,Foo类对象由 type 类创建
可以得出f对象是Foo类的一个实例,Foo类是 type 类的一个实例,即:Foo类 是通过type类创建的实例。type就是一个类的类,我们也称为元类
由于元类是一个类的类,所以它被用来构造类(就像一个类用于构造对象一样)。但是等一下,我们不是创建一个具有标准类定义的类吗?当然,但是Python在底下做了什么:
当它看到一个类定义时,Python会执行它来收集字典中的属性(包括方法)。
当类定义结束时,Python确定类的元类。我们称之为Meta
最终,Python执行Meta(name,base,dct),其中:
Meta是元类,所以这个调用正在实例化它。
name是新创建的类的名称
base:类的基类的一个元组
dct将属性名称映射到对象,列出所有类的属性
我们如何确定一个类的元类?简单地说,如果一个类或它的一个基类有一个__metaclass__属性,它就被当作元类。否则,类型是元类。
当我们定义一个
class MyKlass(object): foo = 2
在这个例子中,没有__metaclass__属性,所以就用type代替,创建过程像下面这样
MyKlass = type(name, bases, dct)
如果metaclass被定义
class MyMeta(): pass class MyKlass(object,metaclass=MyMeta): # python3写法 foo = 2
创建过程就像这样
MyKlass = MyMeta(name, bases, dct)
__new__ :当你想要控制一个新的对象的创建(在我们的例子中是类)
__init__ :应该在创建新对象后控制新对象的初始化时执行。
MyKlass = MyMeta.__new__(MyMeta, name, bases, dct) MyMeta.__init__(MyKlass, name, bases, dct)
看个例子
class MyMeta(type): def __new__(meta, name, bases, dct): print('-----------------------------------') print ("Allocating memory for class", name) print ("meta>>",meta) #通过程序meta:<class '__main__.MyMeta'> print (bases) print (dct) return super(MyMeta, meta).__new__(meta, name, bases, dct) def __init__(cls, name, bases, dct): print ('-----------------------------------') print ("Initializing class", name) print ("cls>>",cls) #cls:<class '__main__.MyKlass'> print (bases) print (dct) super(MyMeta, cls).__init__(name, bases, dct) class MyKlass(object,metaclass=MyMeta): # __metaclass__ = MyMeta def foo(self, param): pass barattr = 2
我们使用pycharm的debug模式来看下程序的运行顺序:
1、解释器从上到下执行,class MyMeat - __new__ - __init__ - class MyKclass -def foo -barattr 我的理解是依次获得函数或则属性的内存地址
2、检测到有metaclass字段,运行__new__ ,__init__
有调试结果得出来,当有metaclass字段时,当解释器编译完所有代码时,会回过头再执行metaclass指向的类中的__new__和__init__方法
用元类实现一个单例模式:
当我们创建一个类时,每次实例化都是一个新的内存地址,看代码
class Spam(object): def __init__(self): print("creating Spam") s = Spam() a =Spam() print(s is a ) #结果为False
再看用元类实现单例模式:
class Singleton(type): def __init__(cls,*args,**kwargs): #cls类 print("Singleton __init__") print(cls,*args,*kwargs) cls.__instance = None super().__init__(*args,**kwargs) def __call__(cls, *args, **kwargs): print("Singleton __call__") print(cls) if cls.__instance is None: #判断实例是否被创建 cls.__instance = super().__call__(*args,**kwargs) print(cls.__instance) return cls.__instance else: return cls.__instance class Spam(metaclass=Singleton): def __init__(self,name): print("creating Spam name is ",name) # sp= Singleton(1) s = Spam('lxj') a =Spam('sx') print(s is a ) 结果: Singleton __init__ <class '__main__.Spam'> Spam () {'__module__': '__main__', '__init__': <function Spam.__init__ at 0x7fc0096ff8c8>, '__qualname__': 'Spam'} Singleton __call__ <class '__main__.Spam'> creating Spam name is lxj <__main__.Spam object at 0x7fc00970dcf8> Singleton __call__ <class '__main__.Spam'> True
1、首先在实例化前,因为有metaclas存在,我们调用了__init__函数(参考上面的解释),把cls._instance置为None(即还未实例化),这里cls为Spam,为什么不用__new__方法,因为__new__方法中cls为Singleton。上面的知识点我们也知道__init__方法是用在控制新对象的初始化
2、在结果中我们看到,在我们实例化过程中,调用的是__call__,每实例话一次,就调用一次__call__方法,在call方法中对实例化进行控制
3、结果中我们看到a和s为指向同一内存地址
在学到django时再仔细深入https://github.com/inglesp/Metaclasses
https://stackoverflow.com/questions/100003/what-are-metaclasses-in-python