Bootstrap

深入解析Python继承：玩转super()，让你的代码更优雅！

1. super()基础

在Python中，super()是一个用于调用父类方法的函数。它通常用于多重继承中，自动处理继承关系，确保正确调用父类的方法。

class Parent:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} speaks")

class Child(Parent):
    def __init__(self, name):
        super().__init__(name)  # 调用父类构造函数

    def speak(self):
        super().speak()  # 调用父类的speak方法
        print("Additional")  # 添加新功能

# 实例化Child类
child = Child("Alice")
child.speak()

输出：

Alice speaks
Additional
  • 自动处理继承关系：super()自动解析继承链，调用正确的父类方法，而不需要显式指定父类名称。
  • 支持多重继承：super()能在复杂的多继承体系中正确调用父类方法，避免直接调用父类而导致的混乱。
  • 方便扩展父类功能：通过super()调用父类的方法，可以在不修改父类代码的情况下扩展功能，增强代码的可维护性。
总结

super()是实现父类方法调用的便利方式，尤其在涉及多重继承时，它能保证方法调用顺序的正确性并增强代码的灵活性。

2. 使用super()的思路和技巧

1. 简化代码：

super()是简化继承体系中的代码的好帮手。通过super()可以避免显式地调用父类，减少代码冗余和重复。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 调用Animal类的构造函数
        self.breed = breed

    def speak(self):
        super().speak()  # 调用Animal类的speak方法
        print(f"{self.name} barks")

dog = Dog("Buddy", "Golden Retriever")
dog.speak()

输出：

Buddy makes a sound
Buddy barks

通过super()，我们可以避免重复写父类构造函数或其他方法调用，简化了代码的结构。

2. 多重继承中的使用：

在多重继承的情况下，super()会遵循MRO（方法解析顺序），确保调用的方法按正确顺序执行。

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

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

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

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

d = D()

输出：

A initialized
C initialized
B initialized
D initialized

在此例中，D继承了B和C，但super()遵循了MRO，确保了父类构造函数按顺序被正确调用。

MRO文章详解，可见： 深入剖析 Python MRO：破解多重继承的秘密，让 super() 更强大！

3. 扩展父类方法：

使用super()时，我们可以先调用父类方法，然后在此基础上扩展新的功能。

class Vehicle:
    def start(self):
        print("Vehicle starting")

class Car(Vehicle):
    def start(self):
        super().start()  # 调用父类的start方法
        print("Car is ready to drive")

car = Car()
car.start()

输出：

Vehicle starting
Car is ready to drive

3. 使用super()的注意事项以及Bug

1. 避免父类方法重复调用：

在多重继承的情况下，可能会出现父类方法被重复调用的情况。这是因为super()依赖于MRO，如果没有合理设计继承结构，可能导致某些父类方法被多次调用。

class A:
    def speak(self):
        print("A speaking")

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

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

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

d = D()
d.speak()

输出：

A speaking
C speaking
B speaking
D speaking

如上所示，A类的speak()方法被调用了两次：一次通过B类，另一次通过C类。这种重复调用可能是一个潜在的错误。

解决方法： 确保设计清晰的继承关系，并检查MRO的顺序，避免父类方法重复调用。

2. 使用super()时要注意__init__()的调用：

在调用super()时，确保父类的构造函数被正确调用。如果忘记调用父类构造函数，可能导致父类中的属性没有初始化。

class Parent:
    def __init__(self, name):
        self.name = name

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)  # 忘记调用父类的构造函数，会导致父类属性未初始化
        self.age = age

child = Child("Alice", 25)
print(child.name)  # 报错：AttributeError: 'Child' object has no attribute 'name'

解决方法： 始终确保在子类的__init__方法中调用super().__init__()，以正确初始化父类的属性。

3. super()调用时不清楚MRO：

如果继承体系过于复杂，super()的调用顺序可能让人困惑，特别是在多重继承时。可以使用help()函数检查MRO。

help(D)

这会输出D类的继承顺序，帮助我们理清调用顺序，避免错误。

4. super()不适用于静态方法和类方法：

super()适用于实例方法，但无法直接用于静态方法和类方法。在这种情况下，需要直接指定父类调用方法。

class Parent:
    @staticmethod
    def speak():
        print("Parent speaking")

class Child(Parent):
    @staticmethod
    def speak():
        super().speak()  # 会报错：TypeError: super() argument 1 must be type, not 'staticmethod'

Child.speak()

解决方法： 静态方法和类方法应通过显式指定父类来调用。

总结：

使用super()时，要注意合理设计继承结构，避免方法重复调用和初始化不完全的问题。合理使用MRO，并根据实际情况调整代码，确保继承关系的正确性和稳定性。

4. Super 项目实战

在实际开发中，super() 主要用于处理类继承关系，避免重复代码，提高代码的可维护性。为了让 super() 的作用更直观，我们通过一个 “在线教育平台的用户权限管理” 项目来讲解 super() 的实际应用。

4.1. 项目背景

在一个在线教育平台中，我们需要管理三种用户：

  1. 普通用户（User）：可以浏览课程和购买课程；
  2. 教师（Teacher）：可以上传和管理自己的课程；
  3. 管理员（Admin）：可以管理所有用户和课程。

不同用户之间存在相似的功能，因此我们采用 继承 设计模式，并使用 super() 来优化代码结构。

4.2. 为什么选用 super()

在这个项目中，我们选择 super() 主要基于以下原因：

  1. 代码复用性高：

    • 所有用户（普通用户、教师、管理员）都具有基本信息（用户名、邮箱等）。
    • 通过 super()，子类可以直接复用 User 类的方法，而无需重复编写代码。

  2. 支持多重继承：

    • 假设未来有一个 “管理员同时也是教师” 的角色，可以使用 super() 解决多重继承中的方法解析问题。

  3. 增强代码维护性：

    • 如果需要修改某个公共功能（如登录逻辑），只需修改 User 父类，而子类无需更改。

4.3. 代码实现

4.3.1. 定义基础 User 类

首先，我们创建一个 User 类，定义所有用户共有的功能。

class User:
    def __init__(self, username, email):
        self.username = username
        self.email = email

    def show_info(self):
        print(f"用户名: {self.username}, 邮箱: {self.email}")

    def login(self):
        print(f"{self.username} 登录成功")

该 User 类包含：

  • __init__() 初始化用户名和邮箱；
  • show_info() 显示用户信息；
  • login() 处理用户登录。
4.3.2. 使用 super() 继承 User

我们创建 教师（Teacher） 和 管理员（Admin） 两个子类，并使用 super() 调用 User 的方法。

class Teacher(User):
    def __init__(self, username, email, courses=None):
        super().__init__(username, email)  # 继承 User 的初始化方法
        self.courses = courses if courses else []

    def upload_course(self, course_name):
        self.courses.append(course_name)
        print(f"{self.username} 上传课程: {course_name}")

    def show_info(self):
        super().show_info()  # 复用父类的 show_info 方法
        print(f"已上传课程: {', '.join(self.courses) if self.courses else '无'}")

class Admin(User):
    def __init__(self, username, email):
        super().__init__(username, email)

    def delete_user(self, user):
        print(f"管理员 {self.username} 删除用户 {user.username}")
4.3.3. super() 在多重继承中的应用

考虑一个特殊角色：“教师管理员（TeacherAdmin）”，他既是教师，也有管理员权限。这种情况涉及 多重继承。

class TeacherAdmin(Teacher, Admin):
    def __init__(self, username, email, courses=None):
        super().__init__(username, email, courses)

    def show_info(self):
        super().show_info()
        print("该用户同时具备管理员权限")

由于 super() 遵循 MRO（方法解析顺序），它会按照 TeacherAdmin -> Teacher -> User 的顺序调用父类方法，避免手动指定调用顺序。

4.4. 使用 super() 的技巧

1. 调用父类的 __init__() 方法

在子类的 __init__() 方法中使用 super()，避免手动初始化父类属性，提高代码复用率。

super().__init__(username, email)
2. 复用父类的方法

如果子类需要扩展父类方法，可以先调用 super()，然后添加新功能。

def show_info(self):
    super().show_info()  # 调用父类的 show_info()
    print("扩展新功能")
3. 避免父类方法重复调用

在多重继承中，super() 遵循 MRO（方法解析顺序），可防止重复调用父类方法。可以用 help(类名) 检查 MRO。

help(TeacherAdmin)

4.5. 使用 super() 的注意事项

1. super() 不能用于静态方法
class Example:
    @staticmethod
    def static_method():
        super().some_method()  # ❌ 报错

解决方案：直接使用类名调用父类方法：

ParentClass.some_method()
2. 避免 super() 重复调用

如果在多重继承中手动调用 super()，可能导致父类方法被重复执行，影响程序逻辑。

3. super() 需要正确的继承顺序

使用 super() 依赖 MRO，如果继承链混乱，可能导致方法解析错误。因此，需要合理设计类的继承关系。

4.6. 完整的使用过程

# 创建用户
user = User("Alice", "[email protected]")
user.login()
user.show_info()

# 创建教师
teacher = Teacher("Bob", "[email protected]")
teacher.login()
teacher.upload_course("Python编程入门")
teacher.show_info()

# 创建管理员
admin = Admin("Charlie", "[email protected]")
admin.login()
admin.delete_user(user)

# 创建教师管理员
teacher_admin = TeacherAdmin("David", "[email protected]")
teacher_admin.upload_course("数据结构与算法")
teacher_admin.show_info()

4.7. 总结

在本项目中，super() 带来的优势：

  1. 简化代码：避免重复定义相同功能；
  2. 增强可读性：子类能直接调用父类方法，逻辑更清晰；
  3. 多重继承管理：通过 MRO 确保方法调用顺序正确。

在实际开发中，合理使用 super()，可以使代码更加优雅、易于维护，提高软件的扩展性。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
Spring Security6.4 中的一次性令牌登录（One-Time Token Login）
软件接口测试理论知识
「Selenium」- 在页面中，点击按钮（或元素） @20210311
数据的分布和映射
机器学习04-数据理解之数据可视化-(基于Pima数据集)
LLM推理加速3：推理优化总结Mooncake/AttentionStore/vllm0.5/cache优化 etc
ssm 使用PageHelper 实现分页查询，前台是easyui
一键部署开源DeepSeek并集成到钉钉
cesium查看entity的属性信息
[源码解析] TensorFlow 分布式环境(3)--- Worker 静态逻辑
;