Python中内置函数super()用法示例详解

目录

• 前言
• 一、函数语法
• 参数：
• 常见写法：
• 返回值：
• 提示：
• 二、基础用法示例
• 1、基本继承调用
• 2、构造函数链
• 三、进阶技巧
• 1、多继承与 MRO（方法解析顺序）
• 2、显式两参 super()
• 3、类方法与静态方法
• 四、补充说明与常见误区
• 1、误把 super() 当“父类调用”
• 2、静态方法并非完全不能 super()
• 3、签名与参数传递
• 小结

在面向对象编程中，类常有继承关系，子类需要复用或扩展基类逻辑。Python 提供内置函数 super()，返回一个代理对象，用于按 MRO（方法解析顺序） 调用当前类之后的下一个类的方法。这样可以避免硬编码父类名，使代码在多继承下更健壮、可维护。

super([type[, object-or-type]])

• type：可选。通常为当前类。
• object-or-type：可选。当前实例（self）或当前类（配合类方法/静态方法显式传入）。

🔹实例方法

super().method(...)

# 等价于：
super(CurrentClass, self).method(...)

🔹类方法

@classmethod
def m(cls, ...):
    super().method(...)

# 等价于：
super(CurrentClass, cls).method(...)

一个 super 代理对象，可用于调用 MRO 中“当前类之后的下一个类” 的方法。

Python 3 支持零参 super()。单参形式很少需要，一般用零参或两参。

class Parent:
    def greet(self):
        print("Hello from Parent")

class Child(Parent):
    def greet(self):
        super().greet()   # 调用父类方法
        print("Hello from Child")

c = Child()
c.greet()

# Hello from Parent
# Hello from Child

class A:
    def __init__(self):
        print("A init")

class B(A):
    def __init__(self):
        super().__init__()  # 调用 A.__init__()
        print("B init")

b = B()
# A init
# B init

class A:
    def greet(self): 
        print("A")

class B(A):
    def greet(self): 
        super().greet()
        print("B")

class C(A):
    def greet(self):
        super().greet()
        print("C")

class D(B, C):
    def greet(self):
        super().greet()
        print("D")

d = D()
d.greet()

# A
# C
# B
# D

MRO 顺序：D → B → C → A → object。

super() 并非“父类调用”，而是沿 MRO 从当前类的后继继续向上。

当你不在方法定义的典型上下文（或需要手动指明上下文）时，可显式传入两参：

class Base:
    def who(self): print("Base.who")

class Sub(Base):
    def who(self):
        print("Sub.who → call super:")
        return super(Sub, self).who()

Sub().who()
# Sub.who → call super:
# Base.who

类方法可直接零参 super()（因为有 cls）：

class A:
    @classmethod
    def hello(cls):
        print("A hello")

class B(A):
    @classmethod
    def hello(cls):
        super().hello()
        print("B hello")

B.hello()

# A hello
# B hello

静态方法中没有隐式的 self/cls，零参 super() 不可用。但可以显式两参使用（调用无需实例的方法）：

class A:
    @classmethod
    def ping(cls): print("A.ping")

class B(A):
    @staticmethod
    def call_ping():
        # 显式指定当前类与类型参数
        super(B, B).ping()

B.call_ping()
# A.ping

若要在静态方法中调用需要实例的方法，你必须自备实例并作为第二参传入（或改为实例/类方法设计）。

它依赖 MRO，是当前位置之后的下一个类；多继承下若某类不调用 super()，调用链会被中断。

不能用零参，但可以显式两参（见上例）。关键是你是否有合适的第二参数以及要调用的是否为可在该上下文调用的方法（如 @classmethod）。

在 __init__ 或其他需要链式调用的方法中，建议：

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)

以免在多继承组合时出现参数不匹配。

super() 返回一个基于 MRO 的代理，不是“直接父类”的别名。

零参 super() 适用于实例方法与类方法；在静态方法或特殊上下文中，可用显式两参。

在多继承中配合合作式 super() 与一致的参数传递，能保证方法/构造链完整运行，避免菱形继承中的重复与遗漏。

到此这篇关于Python中内置函数super()用法的文章就介绍到这了,更多相关Python内置函数super()内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

您可能感兴趣的文章:

• 深入理解Python中的super()方法
• Python中的super()方法使用简介
• 详解python的super()的作用和原理
• Python中super()函数简介及用法分享
• python中的继承机制super()函数详解
• python类中super() 的使用解析
• Python super()函数使用及多重继承
• python中super()函数的理解与基本使用