迹忆客 专注技术分享

本文的主题是正确使用 Python 超级参数。 我们还将了解超和继承的概念、使用超参数的适当代码示例以及基类的概念。

Python 中的 super 参数

在 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

super 使用继承概念

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

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

示例代码：

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 类中使用它，而无需重写代码。

输出：

16

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

Python 中 super 参数的准确使用

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 的 init() Python 方法。

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

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

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

使用 Super 将参数传递给 Python 多重继承中的构造函数

如果您通常处理各种继承，则应为多重继承设计基类。

有时两个类具有相似的参数名称。 发生这种情况时，您不能从 **kwargs 中删除键值对或从 *args 中删除它们。

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

示例代码：

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)
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 编程语言为面向对象编程提供了广泛的功能。 在该集合中，超级函数参数起着重要作用，尤其是在正确使用时。

希望本文能帮助您更好地理解如何在 Python 中使用超级函数参数。