Python中的超级参数,你知道吗？

1.Python 中的超级参数

在Python中，super 在另一个类上调用一个方法。当一个类继承于另一个类时，它被称为父类、基类或超类。

使用super 是非常直接的，因为它直接进入父类并调用其方法。

参数可以传递给super 。它需要两个参数，一个类和一个类实例。

示例代码：

class A:
    def roo(self):
        return 'roo() from A'
class B(A):
    def roo(self):
        print('roo() from B')
        return super().roo()
class C(A):
    def roo(self):
        print('roo() from C')
        return super().roo()
class D(B, C):
    def roo(self):
        print('roo() from D')
        return super(C, self).roo()
a=A()
b=B()
c=C()
d=D()
print(a.roo())
print(b.roo())
print(c.roo())
print(d.roo())

输出：

roo() from A
roo() from B
roo() from A
roo() from C
roo() from A
roo() from D
roo() from A

2.超级使用继承的概念

如果你不熟悉面向对象的编程概念，继承可能会显得很陌生。在面向对象编程中，继承指的是一个类从另一个类派生（或继承）属性和行为的能力，而无需再次实现它们。

理解这些概念的方便方法是看一段代码，所以让我们创建一些类来描述一些形状。

示例代码：

class Rectangle_Shape:
    def __init__(self, len, wid):
        self.length = len
        self.width = wid
    def area(self):
        return self.length * self.width
    def perimeters(self):
        return 2 * self.length + 2 * self.width
class Square_Shape:
    def __init__(self, len):
        self.length = len
    def area(self):
        return self.length * self.length
    def perimeters(self):
        return 4 * self.length
s=Square_Shape(4)
print(s.area())
r=Rectangle_Shape(3,5)
print(r.area())

这个类有两个对应的类：Rectangle_Shape 和Square_Shape 。

输出：

16
15

这个例子演示了两种相互关联的形状：一个正方形是矩形的一种类型。代码没有反映这种关系，导致代码基本上是重复的。

通过使用继承，你可以减少你所写的代码量，同时反映出现实世界中矩形和正方形之间的关系。

示例代码：

class Rectangle_Shape:
    def __init__(self, length, width):
        self.length = length
        self.width = width
    def area(self):
        return self.length * self.width
    def perimeters(self):
        return 2 * self.length + 2 * self.width
# Making the Square_Shape class that initiates the Rectangle_Shape class
class Square_Shape(Rectangle_Shape):
    def __init__(self, len):
        super().__init__(len, len)
s=Square_Shape(4)
print(s.area())

在这种情况下，super() 调用Rectangle_Shape 类的init() ，然后在Square_Shape 类中使用，而不必重写代码。

输出：

如例中所示，Rectangle_Shape 是父类，Square_Shape 是子类。

Python中超级参数的精确使用

下面是M,N, 和O 类的代码。

class M:
    def __init__(self):
            print("M initiated successfully")
class N(M):
    def __init__(self):
            super().__init__()
            print("N initiated successfully")
class O(N):
    def __init__(self):
            super(O, self).__init__()
            print("O initiated successfully")
o=O()

正如上面的代码所假设的，所有的类都重载了它们的直接父类init() 方法。super() 不需要任何属性，所以使用它不需要参数就足够了。

输出：

M initiated successfully
N initiated successfully
O initiated successfully

假设我们想让类M2 跳过N‘的init() 方法，而运行M‘的init() 方法。init() 方法应该继承自M ，而不是N ，尽管我们类的直接父类是N 。

这里是类M2 。让我们看一下它的执行情况。

class M:
    def __init__(self):
            print("M initiated successfully")
class N(M):
    def __init__(self):
            super().__init__()
            print("N initiated successfully")
class O(N):
    def __init__(self):
            super(O, self).__init__()
            print("O initiated successfully")
class M2(N):
    def __init__(self):
            super(N, self).__init__()
            print("other O initiated successfully")
m2=M2()

从上面的代码中可以假设，这次我们向super() 方法传递了属性以选择正确的超类。作为运行m2 = M2() 的结果，我们得到以下输出。

M initiated successfully
other O initiated successfully

我们没有调用直接的父类__init__() 方法，而是调用了M‘sinit() Python 方法。

对于使用这些语句或操作符的隐式查找，如 super()[name]，super() 是未定义的。

此外，除了零参数形式，super() 并不限于使用内部方法。使用双参数形式可以准确识别参数并进行适当的引用。

在类定义中，零参数只起作用，因为编译器填写了必要的细节来检索类和实例。

在Python中使用Super来向构造函数传递参数多重继承

如果你在平时处理各种继承，一个基类应该被设计为多继承。

有些时候，两个类有相似的参数名称。当这种情况发生时，你不能从**kwargs 中删除键值对，也不能从*args 中删除。

可以定义一个Base 类，它与对象不同，可以吸收/忽略参数。

示例代码：

class Base(object):
    def __init__(self, *args, **kwargs): pass
class P(Base):
    def __init__(self, *args, **kwargs):
        print("P")
        super(P, self).__init__(*args, **kwargs)
class Q(Base):
    def __init__(self, *args, **kwargs):
        print("Q")
        super(Q, self).__init__(*args, **kwargs)
class R(P):
    def __init__(self, arg, *args, **kwargs):
        print("R","arguments=",arg)
        super(R, self).__init__(arg, *args, **kwargs)
class S(Q):
    def __init__(self, arg, *args, **kwargs):
        print("S", "arguments=",arg)
        super(S, self).__init__(arg, *args, **kwargs)
#Python小白学习交流群：153708845        
class T(R,S):
    def __init__(self, arg, *args, **kwargs):
        print("T", "arguments=",arg)
        super(T, self).__init__(arg, *args, **kwargs)
        print("MRO---", [x.__name__ for x in T.__mro__])
t=T(10)

输出：

T arguments= 10
R arguments= 10
P
S arguments= 10
Q
MRO--- ['T', 'R', 'P', 'S', 'Q', 'Base', 'object']

需要注意的是，Base 必须是MRO 中的倒数第二个类，这样才行。

Python编程语言为面向对象编程提供了广泛的功能。在这组功能中，super 函数参数起着重要的作用，特别是在正确使用的时候。

希望这篇文章能帮助你更好地理解如何在Python中使用super 函数参数。