标签：python解释器 类实例化 调用 属性 形参 成功 doc 表达 结果
元类是类的类，是类的模板（就如对象的模板是类一样)
元类的实例为类，类的实例为对象
元类是用来产生类的
动态语言和静态语言最大的不同，就是函数和类的定义，不是编译时定义的，是运行时动态创建的
我们之前说类实例化第一个调用的是__init__，但__init__其实不是实例化一个类的时候第一个被调用 的方法。当使用 Persion(name, age) 这样的表达式来实例化一个类时，最先被调用的方法 其实是 __new__方法。
__new__方法接受的参数虽然也是和__init__一样，但__init__是在类实例创建之后调用，而 __new__方法正是创建这个类实例的方法。
class A:
pass
class B(A):
def __new__(cls):
print("__new__方法被执行")
def __init__(self):
print("__init__方法被执行")
b = B()__new__方法被执行
当类中有__call__方法时，实例对象直接加括号，会执行这个方法，你拿到的实例对象就是它返回的
class zx():
def __call__(self,name,age):
print(name)
print(age)
zx125=zx()
zx125("wl",18)wl
18
type()函数既可以返回一个对象的类型，又可以创建出新的类型
创建一个新的class时需要传入3个参数：
1.class的名称
2.继承父类的集合（元组）
3.函数名和函数对象的键值对(字典)
通过type()函数创建的类和直接写class是完全一样的，因为Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用type()函数创建出class。
def speank(self):
print("llllllllllll")
zx=type("zx",(object,),dict(say=speank))
zx1=zx()
zx1.say()
print(type(zx1))
print(type(zx))llllllllllll
<class ‘main.zx‘>
<class ‘type‘>
执行字符串的代码，当成python解释器，把代码丢给解释器解释
exec(s,g,l)
g表示当前的一个全局名称空间，当前的一个l局部名称空间，代码解析完毕，会按属性是全局和局部，放入以上参数
例1
cmd = """
x=1
print('exec函数运行了')
def func(self):
pass
"""
class_dic = {}
# 执行cmd中的代码，然后把产生的名字丢入class_dic字典中
exec(cmd, {}, class_dic)print(class_dic){‘x‘: 1, ‘func‘: <function func at 0x10a0bc048>}
例2
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
y = 20
m={'x':1,'y': 2}
w={'y': 3, 'z': 4}
exec(expr)
exec(expr,m)
exec(expr,m,w)
print(w)60
33
34
{‘y‘: 3, ‘z‘: 30, ‘sum‘: 34}
class关键字
例1 理解class关键字
可见这时候已经生成了一个zx类对象了,zx的属性字典已经被写入了，那么这个过程中到底发生了什么呢？接下来我们慢慢拆解
class Mytype(type):
pass
class zx(metaclass=Mytype):#代码运行到这相当于 zx=Mytype("zx",(object,),{}),此时已经生成了zx类对象了
pass
print(zx.__dict__){'__module__': '__main__', '__dict__': <attribute '__dict__' of 'zx' objects>, '__weakref__': <attribute '__weakref__' of 'zx' objects>, '__doc__': None}例2
创建一个对象，说到底就是用了，上面介绍的方法__init(),__new__(),__call()这三个方法，真正创建对象的只有type()这个内置方法。下面直接进入主题，直接重写元类的三个方法。
1.首先，会运行到class Mytype(type)同理可得，这个时候会生成一个Mytype对象，这是一个关键，自定义的元类创建好了，下面生产类对象就靠它了，这个元类的产生过程是修改不了的，因为是c实现的
2.然后就和例1一样zx=Mytype("zx",(object,),{}),接下来就是三个方法的运用了。首先是Mytype后面加的括号，所以去执行type的__call__()方法
3.然后看一下__call__()方法的参数self, *args, **kwargs,有个self，这个self就是第一步创建的那个Mytype对象，然后会依次执行self.__new__()和self.__init__()方法，也就是Mytype中的这两个方法,这两个方法的作用，主要就是创建对象，给对象填入相关的属性，而__call__()主要就是对操作的封装，然后返回组装完成的类对象
4.我们看到结果，只打印了new,但是按上面的步骤，不是还应该打印一个init的吗？别急，在看打印生成的对象zx它竟然是个None，所以其中必要蹊跷，发生了什么呢？其实过程还是和上面一样的，只不过我们重写了方法，导致运行到__new__()的时候，这个方法，返回了一个None，这怎么行呢？所以当返回值返回到__call__()的时候，导致直接出了异常，方法中断了，但是没有打印异常，是因为源码做了处理，返回了一个None
class Mytype(type):
def __init__(self,*args, **kwargs):
print("init")
def __call__(self, *args, **kwargs):
print("call")
def __new__(cls, *args, **kwargs):
print("new")
class zx(metaclass=Mytype):#代码运行到这相当于 zx=Mytype("zx",(object,),{}),此时已经生成了zx类对象了
pass
print(zx)new
None例3 实现创建类对象
出现了这样的问题当然要解决他呢！首先要注意类对象是由自定义元类生成的，实例对象是由类对象生成的，这两种情况的方法执行流程是相同的，但是有些细节的偏差
1.我把打印结果移到了，__init__()方法去了，但是发现执行这个方法的时候，我们想要的zx类对象其实已经创建好了，这就是主要的区别，生成类对象，和属性填充等操作都会放在__new__()里面，而创建实例对象的时候，一些添加属性的过程，则会放到__init__()里面
2.在__new__()方法中，我创建对象用的方法是type.__new__(cls,*args, **kwargs),为啥呢？因为我们自定义元类的时候，如果没有重写__new__()方法是时候，他就找不到这个方法，这个时候当然就是去父类找这个方法，那Mytype的父类是谁呢？就是type,其实原理是一样的
3.我们成功自定义了元类，并且拿到了zx类对象，我们可以发现整个过程我们都是可以控制的，自定义元类给我们极大的操作过程，那么接下来我们来操作一下实例对象生成的过程
class Mytype(type):
def __init__(self,*args, **kwargs):
print(self)
print(self.__dict__)
print("init")
def __call__(self, *args, **kwargs):
print("call")
def __new__(cls, *args, **kwargs):
# print(cls)
# return object.__new__(cls)
return self.__new__(cls,*args, **kwargs)
class zx(metaclass=Mytype):#代码运行到这相当于 zx=Mytype("zx",(object,),{}),此时已经生成了zx类对象了
pass
<class '__main__.zx'>
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'zx' objects>, '__weakref__': <attribute '__weakref__' of 'zx' objects>, '__doc__': None}
init例4 实例对象的创建过程
这里我把Mytype的__init__()和__new__()方法去掉，让他直接调用默认的方法就行，这里不研究类对象的生成了
1.首先来查看打印结果，一个为空，这就是上面所说的区别，在创建实例对象的时候，使用的是不是type的__new__方法，而是，找zx继承类，一般都是创建一个空对象，除非你自定义一个父类，从写它的__new__()方法
2.创建完了一个空对象，然后调用__init__()方法给他进行填值，最后我们拿到了自己想要的实例对象了
class Mytype(type):
def __call__(self, *args, **kwargs):
obj=self.__new__(self, *args, **kwargs)
print(obj.__dict__)
obj.__init__( *args, **kwargs)
return obj
class zx(metaclass=Mytype):#代码运行到这相当于 zx=Mytype("zx",(object,),{}),此时已经生成了zx类对象了
def __init__(self,name,age):
self.name=name
self.age=age
def run(self):
print("runrun")
ha=zx("小明",18)
print(ha.__dict__){}
{'name': '小明', 'age': 18}总结
1.一切皆对象
2.注意自定义元类的特殊性，他是父类是type,在创建类对象的时候他的__new__()方法，直接把创建对象和添加属性字典的操作都完成了
3.注意对象+()调用的是，元类！的__call()方法，默认元类都是type
4.太难了，太绕了，记一下，容易忘
__new__()一共接收4个参数（也可以使用位置形参接收）
底层就是调用了type()方法
分别为：
1.当前准备创建的类对象；
2.类的名字
3.类继承的父类集合
4.类的方法集合
标签：python解释器 类实例化 调用 属性 形参 成功 doc 表达 结果
原文地址：https://www.cnblogs.com/zx125/p/11460454.html
