python元类深入解析

谁借莪１个温暖的怀抱￠ 2023-06-02 10:46 24阅读 0赞

## 元类 ##

#### 什么是元类 ####

元类是类的类，是类的模板（就如对象的模板是类一样)

元类的实例为类，类的实例为对象

元类是用来产生类的

动态语言和静态语言最大的不同，就是函数和类的定义，不是编译时定义的，是运行时动态创建的

#### \_\_new\_\_() ####

我们之前说类实例化第一个调用的是`__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\_\_() ####

当类中有`__call__`方法时，实例对象直接加括号，会执行这个方法，你拿到的实例对象就是它返回的

class zx():
        def __call__(self,name,age):
            print(name)
            print(age)
    
    zx125=zx()
    zx125("wl",18)

wl  
18

#### 内置函数type（） ####

`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'>

#### 内置函数exec（） ####

执行字符串的代码，当成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.类继承的父类集合