Python单继承中的 super()

在Python中，使用super()函数可以让我们更方便地调用父类的方法和属性，特别是在单继承的情况下。本文将详细介绍super()函数的用法和注意事项。

super()函数的用法

super()函数用于返回一个代理对象，可以用来访问一个类的父类的方法和属性。

class Parent:
    def __init__(self):
        self.propertyA = 1

    def methodA(self):
        print("parent's methodA")

class Child(Parent):
    def __init__(self):
        super().__init__()
        self.propertyB = 2

    def methodB(self):
        super().methodA()
        print("child's methodB")

child = Child()
child.methodB()

在这个例子中，Child继承了Parent类，并覆盖了它的__init__方法。在Child的__init__方法中，我们通过super()函数调用了Parent的__init__方法，并初始化了propertyA属性。

在Child的methodB方法中，我们同样使用了super()函数来调用Parent的methodA方法。这里的super()函数实际上返回了一个代理对象，它包含了Child类和它的父类Parent的方法列表，并且能够自动识别方法调用的顺序。

因此，在我们调用super().methodA()时，super()函数会自动找到Parent类中定义的methodA方法，并进行调用。最后，Child的methodB方法打印了child's methodB，完成了本次示例。

super()函数的注意事项

参数的传递

在使用super()函数时，通常我们不需要再向其传递任何参数。在上面的示例中，我们就没有传递任何参数给super()函数。这是因为，super()函数实际上是一个无参构造函数，它使用的参数是自动推导得出的。

在Python 3中，我们也可以使用super()函数来访问不同的父类方法，比如：

class ParentA:
    def method(self):
        print("ParentA's method")

class ParentB:
    def method(self):
        print("ParentB's method")

class Child(ParentA, ParentB):
    def method(self):
        super(ParentA, self).method()

child = Child()
child.method()

在这个例子中，Child同时继承了ParentA和ParentB类，并重写了它们的method方法。

在Child的method方法中，我们使用super(ParentA, self)传递了一个参数ParentA，表示我们希望调用ParentA类中的method方法。这样，在多重继承的情况下，我们就可以通过super()函数来访问不同的父类方法。需要注意的是，如果使用super()函数来访问父类方法时，父类方法的参数是自动传递的。

super()函数的顺序

在单继承的情况下，super()函数会按照继承树中声明的顺序进行调用。

比如，在下面的例子中，我们定义了三个类A、B和C，B和C继承自A类：

class A:
    def method(self):
        print("A's method")

class B(A):
    def method(self):
        super().method()
        print("B's method")

class C(A):
    def method(self):
        super().method()
        print("C's method")

class D(B, C):
    def method(self):
        super().method()
        print("D's method")

d = D()
d.method()

在这个例子中，我们定义了一个D类，它继承自B和C类，并重写了method方法。

当我们调用d.method()时，super().method()会首先访问B类的method方法，然后在其内部调用super().method()访问A类的method方法；接着回到C类的method方法中，再次调用super().method()访问A类的method方法。最后，D类的method方法中调用super().method()，也就是调用C类的method方法。

因此，我们的输出结果是：

A's method
C's method
B's method
D's method

与静态方法和类方法的结合

在Python中，我们还可以使用super()函数来调用静态方法和类方法。需要注意的是，静态方法和类方法不需要传递self参数，而是传递cls参数。因此，在调用静态方法和类方法时，我们需要使用以下语法：

super().method(cls, arg1, arg2, ...)

其中，cls表示当前类，后面的arg1、arg2等表示除cls外的其他参数。

在下面的例子中，我们定义了一个类Parent，它包含了一个静态方法static_method和一个类方法class_method：

class Parent:
    def static_method(cls, x, y):
        print(f"Parent's static_method({x}, {y})")

    @classmethod
    def class_method(cls, x, y):
        print(f"Parent's class_method({cls.__name__}, {x}, {y})")

在Child类中，我们使用super()函数分别调用了Parent类的静态方法和类方法：

class Child(Parent):
    def static_method(cls, x, y):
        super().static_method(cls, x, y)
        print(f"Child's static_method({x}, {y})")

    @classmethod
    def class_method(cls, x, y):
        super().class_method(cls, x, y)
        print(f"Child's class_method({x}, {y})")

child = Child()
child.static_method(1, 2)
child.class_method(3, 4)

在调用child.static_method(1, 2)时，super().static_method(cls, x, y)会首先访问Parent类的static_method静态方法，传递当前类Child、1和2三个参数，并输出Parent's static_method(Child, 1, 2)；然后，Child类的static_method静态方法将输出Child's static_method(1, 2)。

在调用child.class_method(3, 4)时，super().class_method(cls, x, y)会首先访问Parent类的class_method类方法，传递当前类Child、3和4三个参数，并输出Parent's class_method(Child, 3, 4)；然后，Child类的class_method类方法将输出Child's class_method(3, 4)。

小结

super()函数在Python的单继承中是一个非常便利的方法，可以帮助我们访问父类方法和属性，而不必硬编码其类名。需要注意的是，super()函数的调用顺序会按照继承树中声明的顺序进行，我们也可以在多重继承的情况下通过传递参数来访问不同的父类方法。此外，在结合静态方法和类方法时，我们需要传递cls参数而不是self参数。