1.python中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候会创建一个对象(这里的对象指的是类而非类的实例)
class Foo: #class语法后面跟一个类Foo,这个类本身也是一个对象 pass #f1是通过Foo类实例化的对象 f1=Foo() #通过type查看f1这个对象由哪一个类产生 print(type(f1)) #输出：<class '__main__.Foo'> f1这个对象由Foo类创建 #通过type查看Foo这个类由哪一个对象产生 print(type(Foo)) #输出：<class 'type'> Foo这个类的类是type，type是python的一个内置元类
返回：
<class '__main__.Foo'>
<class 'type'>
2.什么是元类(用来产生class后面定义那个类的类)
(1)元类是类的类，是类的模版
(2)元类是用来控制如何创建类的，正如类是创建对象的模版一样
(3)元类的实例为类，正如类的实例为对象(f1对象是Foo类的一个实例，Foo类是type类的一个实例)
(4)typy是python的一个内建元类(不指定类的类是谁默认用typy去生成)，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象
3.创建元类的两种方式
方式一：利用关键字的方式声明一个类
class Foo: def __init__(self): #加上构造函数__init__ pass #查看Foo这个类 print(Foo) #查看Foo这个类里的属性 print(Foo.__dict__)
返回：
class '__main__.Foo'>
{'__module__': '__main__', '__init__': <function Foo.__init__ at 0x00399858>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}
方式二：直接用type的方式直接实例化一个结果，这个结果相当于class声明的类
def __init__(self,name,age): #顶级作用域里定义构造函数__init__ self.name=name self.age=age def test(self): #创造test方法 print('我是test方法') #创建元类FFo是由type类产生的 FFo=type('FFo',(object,),{'x':1,'__init__':__init__,'test':test}) #实例化type传三个参数进去，参数1：类名字符串形式，参数2：继承的父类元祖的形式(新式类默认object)，参数3：类的属性'x':1和方法属性__init__':__init__和test':test放在属性字典里 #查看Foo这个类 print(FFo) #用FFo这个对象产生实例传俩个参数xixi和18 f1=FFo('xixi',18) #调f1的x的类属性 print(f1.x) #返回：1 #调f1的name的类属性 print(f1.name) #返回：xixi #调f1的方法实例化 f1.test() #返回：我是test方法 #查看Foo这个类里的属性 print(FFo.__dict__)
返回：
<class '__main__.FFo'>
1
xixi
我是test方法
{'x': 1, '__init__': <function __init__ at 0x01D8C6A8>, 'test': <function test at 0x02109858>, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'FFo' objects>, '__weakref__': <attribute '__weakref__' of 'FFo' objects>, '__doc__': None}
4.一个类没有声明自己的元类，默认他的元类就是type,除了使用元类type，用户也可以通过继承type来自定义元类
5.自定制元类控制实例的生成过程
#定制元类必MyType须继承type类 class MyType(type): def __init__(self,a,b,c): #第二步：接收metaclass=MyType传来的四个参数，得到结果Foo,Foo这个类就此生成结束运行 print('触发元类的构造函数执行') #print(a) #参数二传过来的类名 #print(b) #参数三传过来继承的object #print(c) #参数四传过来类的属性字典 def __call__(self, *args, **kwargs): #第四步：接收self是Foo本身，*args, **kwargs接收Foo传的参数xixi print('触发元类里__call__方法') #print(self) #查看self是Foo：<class '__main__.Foo'> #print(args,kwargs) #查看*args, **kwargs传过来的值('xixi',) {} obj = object.__new__(self) #第五步：生成Foo的对象。所有类都继承object，object.__new__就是创建一个新的对象把self传进去，self就是Foo，得到的就是Foo这个对象，Foo产生的对象就是f1赋值给obj self.__init__(obj, *args, **kwargs) #第六步：给f1做封装的属性的事。self.__init__相当于执行Foo.__init__ 就是在执行def __init__(self,name):要传俩个参数self传obj就是f1 name传 *args, **kwargs return obj #第七步：return obj相当于return了f1。__call__得到返回值才赋值给f1 #定义Foo这个类声明它的元类是MyType，只要一class Foo会触发MyType('Foo',(object,),{}) class Foo(metaclass=MyType): #第一步：执行class Foo相当于用MyType来实例化Foo，会触发class MyType(type)自己下面的__init__方法，传四个参数给__init__方法 def __init__(self,name): #第八步：跳到Foo的__init__方法 self.name=name #第九步：给f1封装属性，name的属性封装到f1的属性字典里。得到f1.name=name #调用 f1=Foo('xixi') #第三步：用Foo这个类名加上('xixi')在运行这个类，这个类本身就是一个对象，运行Foo('xixi')就是在调用MyType(type):里的__call__方法(因为Foo是MyType产生的) #第十步：__call__运行完毕代表Foo('xixi') 运行完毕把变量返值回给f1 #查看f1 print(f1) #查看f1字典里的属性 print(f1.__dict__)
返回：
触发元类的构造函数执行
触发元类里__call__方法
<__main__.Foo object at 0x027C49D0>
{'name': 'xixi'}
