深入理解Python虚拟机:super超级魔法的背后原理

简介: 深入理解Python虚拟机:super超级魔法的背后原理

super 类作为Python虚拟机中强大的功能之一,super 可以说是 Python 对象系统基石,他可以帮助我们更灵活地使用继承和方法调用。


super类的使用


在 Python 中,我们经常使用继承来构建类的层次结构。当子类继承了父类的属性和方法时,有时我们需要在子类中调用父类的方法或属性。这就是 super 类的用武之地。


super 函数的一般用法是在子类中调用父类的方法,格式为 super().method() 。这样可以方便地使用父类的实现,并在子类中添加自己的特定行为。


下面是一个示例代码,演示了 super 函数的使用:

class Parent:
    def __init__(self, name):
        self.name = name
    
    def say_hello(self):
        print(f"Hello, I'm {self.name}")
 
class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age
    
    def say_hello(self):
        super().say_hello()
        print(f"I'm {self.name} and I'm {self.age} years old")
 
child = Child("Alice", 10)
child.say_hello()

输出结果为:

Hello, I'm Alice
I'm Alice and I'm 10 years old

在上述示例中,Child类继承自Parent类。在Child类的构造函数中,我们使用super().init(name)来调用父类Parent的构造函数,以便在子类中初始化父类的属性。


在say_hello方法中,我们使用super().say_hello()调用父类Parent的say_hello方法,并在子类中添加了额外的输出。


除了调用父类的方法,super函数还可以用于访问父类的属性。例如,super().attribute可以用来获取父类的属性值。


super类的工作原理-Super 设计的目的


要理解super类的工作原理,我们需要了解Python中的多重继承和方法解析顺序(Method Resolution Order,MRO)。多继承是指一个类可以同时继承多个父类。在Python中,每个类都有一个内置属性__mro__,它记录了方法解析顺序。MRO是根据C3线性化算法生成的,它决定了在多重继承中调用方法的顺序。当对象进行方法调用的时候,就会从类的 mro 当中的第一个类开始寻找,直到最后一个类为止,当第一次发现对应的类有相应的方法时就进行返回就调用这个类的这个方法。


Super 类的的签名为 class super(type, object_or_type=None),这个类返回的是一个 super 对象,也是一个代理对象,当使用这个对象进行方法调用的时候,这个调用会转发给 type 父类或同级类。object_or_type 参数的作用是用于确定要搜索的方法解析顺序(也就是通过object_or_type得到具体的 mro),对于方法的搜索从 type 后面的类开始。


例如,如果 的 object_or_type 的 mro 是 D -> B -> C -> A -> object 并且type的值是 B ,则进行方法搜索的顺序为C -> A -> object ,因为搜索是从 type 的下一个类开始的。 下面我们使用一个例子来实际体验一下:

class A:
    def __init__(self):
        super().__init__()
 
    def method(self):
        print("In method of A")
 
 
class B(A):
    def __init__(self):
        super().__init__()
 
    def method(self):
    print("In method of B")
 
 
class C(B):
    def __init__(self):
    super().__init__()
 
    def method(self):
        print("In method of C")
 
 
if __name__ == '__main__':
    print(C.__mro__)
    obj = C()
    s = super(C, obj)
    s.method()
    s = super(B, obj)
    s.method()

上面的程序输出结果为:

(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
In method of B
In method of A

在上面的代码当中继承顺序为,C 继承 B,B 继承 A,C 的 mro 为,(C, B, A, object),super(C, obj)表示从 C 的下一个类开始搜索,因此具体的搜索顺序为 ( B, A, object),因此此时调用 method 方法的时候,会调用 B 的 method 方法,super(B, obj)表示从 B 的下一个类开始搜索,因此搜索顺序为 (A, object),因此此时调用的是 A 的 method 方法。


Super 和栈帧的关系


需要注意的是我们在一个类的__init__方法当中并没有给 super 任何参数,那么他是如何找到 super 需要的两个参数呢?


这其中的魔法就是在 Super 类对象的初始化会获取当前栈帧的第一个参数对象,这个就是对应上面的object_or_type参数,type就是局部变量表当中的一个参数__class__,我们可以通过查看类方法的局部变量去验证这一点:

import inspect
 
 
class A(object):
    def __init__(self):
    super().__init__()
    print(inspect.currentframe().f_locals)
    def bar(self):
    pass
 
    def foo(self):
    pass
 
 
class Demo(A):
 
    def __init__(self):
    super().__init__()
    print(inspect.currentframe().f_locals)
 
    def bar(self):
    super().bar()
    print(inspect.currentframe().f_locals)
 
    def foo(self):
    print(inspect.currentframe().f_locals)
 
 
if __name__ == '__main__':
    demo = Demo()
    demo.bar()
    demo.foo()

上面的代码输出结果为:

{'self': <__main__.Demo object at 0x103059040>, '__class__': <class '__main__.A'>}
{'self': <__main__.Demo object at 0x103059040>, '__class__': <class '__main__.Demo'>}
{'self': <__main__.Demo object at 0x103059040>, '__class__': <class '__main__.Demo'>}
{'self': <__main__.Demo object at 0x103059040>}

从上面的例子我们可以看到当我们进行方法调用且方法当中有 super 的使用时,栈帧的局部变量表当中会多一个字段__class__,这个字段表示对应的类,比如在 Demo 类当中,这个字段就是 Demo,在类 A 当中这个字段就是 A 。为什么要进行这样的处理呢,这是因为需要调用相应位置类的父类方法,因此所有的使用 super 的位置的type都必须是所在类。而在前面我们已经说明了object_or_type表示的是栈帧当中的第一个参数,也就是对象 self,这一点从上面的局部变量表也可以看出来,通过这个对象我们可以知道对象本身的 mro 序列了。在 super 得到两个参数之后,也就能够实现对应的功能了。


CPython的实现


CPython 内部是如何实现 super 类的,首先来看一下他的__init__方法(删除了error checking 代码):

static int
super_init(PyObject *self, PyObject *args, PyObject *kwds)
{
    superobject *su = (superobject *)self;
    PyTypeObject *type = NULL; // 表示从哪个类的后面开始查询,含义和 上文当中的 type 一样
    PyObject *obj = NULL; // 表示传递过来的对象
    PyTypeObject *obj_type = NULL; // 表示对象 obj 的类型
    // 获取 super 的两个参数 type 和 object_or_type
    if (!PyArg_ParseTuple(args, "|O!O:super", &PyType_Type, &type, &obj))
        return -1;
 
    if (type == NULL) {
        /* Call super(), without args -- fill in from __class__
           and first local variable on the stack. */
        PyFrameObject *f;
        PyCodeObject *co;
        Py_ssize_t i, n;
        f = _PyThreadState_GET()->frame; // 得到当前栈帧
        // 栈帧的第一个参数表示对象
        obj = f->f_localsplus[0];
        if (obj == NULL && co->co_cell2arg) {
            /* The first argument might be a cell. */
            n = PyTuple_GET_SIZE(co->co_cellvars);
            for (i = 0; i < n; i++) {
                if (co->co_cell2arg[i] == 0) {
                    PyObject *cell = f->f_localsplus[co->co_nlocals + i];
                    assert(PyCell_Check(cell));
                    obj = PyCell_GET(cell);
                    break;
                }
            }
        }
        if (co->co_freevars == NULL)
            n = 0;
        else {
            assert(PyTuple_Check(co->co_freevars));
            n = PyTuple_GET_SIZE(co->co_freevars);
        }
        // 下面的代码表示获取 type 对象,也就是从局部变量表当中获取到 __class__ 
        for (i = 0; i < n; i++) {
            PyObject *name = PyTuple_GET_ITEM(co->co_freevars, i);
            assert(PyUnicode_Check(name));
            if (_PyUnicode_EqualToASCIIId(name, &PyId___class__)) {
                Py_ssize_t index = co->co_nlocals +
                    PyTuple_GET_SIZE(co->co_cellvars) + i;
                PyObject *cell = f->f_localsplus[index];
                type = (PyTypeObject *) PyCell_GET(cell);
                break;
            }
        }
    }
 
    if (obj == Py_None)
        obj = NULL;
    if (obj != NULL) {
        // 这个函数是用于获取 obj 的 type
        obj_type = supercheck(type, obj);
        if (obj_type == NULL)
            return -1;
        Py_INCREF(obj);
    }
    return 0;
}

在上面的代码执行完成之后就得到了一个 super 对象,之后在进行函数调用的时候就会将对应类的方法和对象 obj 绑定成一个方法对象返回,然后在进行方法调用的时候就能够成功调用了。

class Demo:
 
    def __init__(self):
    print(super().__init__)
 
 
if __name__ == '__main__':
    Demo()

输出结果:

<method-wrapper '__init__' of Demo object at 0x100584070>

总结 super 是 Python 面向对象编程当中非常重要的一部分内容,在本篇文章当中详细介绍了 super 内部的工作原理和 CPython 内部部分源代码分析了 super 的具体实现。在 Python 当中 super 的使用方式分为两种一种是可以直接使用参数,另外一种是在类的方法当中不使用参数,后者的实现稍微复杂一点,他会从当前栈帧和局部变量表当中分别取出类对象和类,作为 super 的参数,从而实现 super 的功能。

相关文章
|
13天前
|
存储 Dart Java
Dart 虚拟机运行原理
【10月更文挑战第20天】Dart 虚拟机通过一系列复杂的机制和操作,确保 Dart 代码能够准确、高效地执行。它为 Dart 语言的广泛应用提供了坚实的基础和可靠的运行环境
19 6
|
1月前
|
存储 缓存 Java
深度解密 Python 虚拟机的执行环境:栈帧对象
深度解密 Python 虚拟机的执行环境:栈帧对象
59 13
|
2月前
|
调度 Python
揭秘Python并发编程核心:深入理解协程与异步函数的工作原理
在Python异步编程领域,协程与异步函数成为处理并发任务的关键工具。协程(微线程)比操作系统线程更轻量级,通过`async def`定义并在遇到`await`表达式时暂停执行。异步函数利用`await`实现任务间的切换。事件循环作为异步编程的核心,负责调度任务;`asyncio`库提供了事件循环的管理。Future对象则优雅地处理异步结果。掌握这些概念,可使代码更高效、简洁且易于维护。
24 1
|
2月前
|
API 开发者 Python
Python中的魔法方法:从原理到实践
【9月更文挑战第24天】本文将深入探讨Python的魔法方法,这些特殊的方法允许对象定制其行为。文章首先揭示魔法方法的本质和重要性,然后通过代码示例展示如何利用它们来增强类的功能性。最后,我们将讨论在实际应用中应注意的事项,以确保正确和高效地使用这些方法。
|
2月前
|
中间件 API 开发者
深入理解Python Web框架:中间件的工作原理与应用策略
在Python Web开发中,中间件位于请求处理的关键位置,提供强大的扩展能力。本文通过问答形式,探讨中间件的工作原理、应用场景及实践策略,并以Flask和Django为例展示具体实现。中间件可以在请求到达视图前或响应返回后执行代码,实现日志记录、权限验证等功能。Flask通过装饰器模拟中间件行为,而Django则提供官方中间件系统,允许在不同阶段扩展功能。合理制定中间件策略能显著提升应用的灵活性和可扩展性。
38 4
|
1月前
|
数据采集 调度 Python
Python编程异步爬虫——协程的基本原理(一)
Python编程异步爬虫——协程的基本原理(一)
|
1月前
|
数据采集 Python
Python编程异步爬虫——协程的基本原理(二)
Python编程异步爬虫——协程的基本原理(二)
|
1月前
|
Java C语言 Python
解析Python中的全局解释器锁(GIL):影响、工作原理及解决方案
解析Python中的全局解释器锁(GIL):影响、工作原理及解决方案
32 0
|
1月前
|
存储 Java 开发者
用一篇文章告诉你如何篡改 Python 虚拟机
用一篇文章告诉你如何篡改 Python 虚拟机
11 0
|
1月前
|
存储 API 索引
一文让你搞懂 Python 虚拟机执行字节码的奥秘
一文让你搞懂 Python 虚拟机执行字节码的奥秘
29 0