使用super()加持python类_super().__init__(**kwargs)

虽然Python是一种纯粹的面向对象的语言，但它足够灵活，功能强大，足以让我们使用面向对象的范例构建应用程序。 Python实现这一目标的方法之一是支持继承，它与super()一起联用。

super()函数

super()返回超类的临时对象，然后允许我们调用该超类的方法。

你为什么要这样做呢？它的用处超出你的想象，最常见的用例是扩展先前构建的类的功能。

使用super()调用以前构建的方法可以使您无需在子类中重写这些方法，并允许我们使用最少的代码修饰超类。

单独继承中的super()函数

如果不熟悉面向对象的编程概念，继承可能是一个不熟悉的术语。继承是面向对象编程中的一个概念，其中类从另一个类派生（或继承）属性和方法，而无需再次实现它们。

废话少说，上代码，让我们编写描述某些形状的类：

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
 
    def area(self):
        return self.length * self.width
 
    def perimeter(self):
        return 2 * self.length + 2 * self.width
 
class Square:
    def __init__(self, length):
        self.length = length
 
    def area(self):
        return self.length * self.length
 
    def perimeter(self):
        return 4 * self.length

这里有两个相似的类：Rectangle和Square.

我们可以这样使用它们：

>>> square = Square(4)
>>> square.area()
16
>>> rectangle = Rectangle(2,4)
>>> rectangle.area()
8

在此示例中，我们有两个彼此相关的形状：正方形是一种特殊的矩形。但是，代码并未反映这种关系，因而上述代码存在冗余.

通过使用继承，不仅可以减少代码量，同时还能反映矩形和正方形之间的真实关系：

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
 
    def area(self):
        return self.length * self.width
 
    def perimeter(self):
        return 2 * self.length + 2 * self.width

# 在这里我们申明，Square类继承自Rectangle类
# 因此可以认为Rectangle是Square的老爸了
class Square(Rectangle):
    def __init__(self, length):
        super().__init__(length, length) # 调用了Rectanle类的初始化方法，后面的length对应width

在这里，使用super()来调用Rectangle类的__init __（），允许在Square类中使用它而不重复代码。下面，核心功能在进行更改后仍然存在：

>>> square = Square(4)
>>> square.area()
16

在此示例中，Rectangle是超类，Square是子类.

因为Square和Rectangle .__ init __（）方法非常相似，所以可以使用super（）从Square的方法中调用超类的.__ init __（）方法（Rectangle .__ init __（））。这样我们就设置.length和.width属性，尽管只为Square提供了length参数。

执行代码时，尽管Square类没有显式地实现area方法，对.area（）的调用将使用超类中的.area（）方法并输出16. Square类从Rectangle类中继承了.area（）方法。

Note: 关于继承的更多知识可以参考 Object-Oriented Programming (OOP) in Python 3.

super() 能为我们做什么？

与其他面向对象语言一样，它允许我们在子类中调用超类的方法。这种情况的主要用途是扩展继承方法。

在下面的示例中，将创建一个继承自Square的类Cube，并扩展.area（）的功能（通过Square继承自Rectangle类）以计算Cube实例的表面积和体积：

class Square(Rectangle):
    def __init__(self, length):
        super().__init__(length, length)
 
class Cube(Square):
    def surface_area(self):
        face_area = super().area()
        return face_area * 6
 
    def volume(self):
        face_area = super().area()
        return face_area * self.length

现在已经构建了类，让我们看一下边长为3的立方体的表面积和体积：

>>> cube = Cube(3)
>>> cube.surface_area()
54
>>> cube.volume()
27

注意：在我们上面的示例中，单独的super（）不会为你调用方法：你必须在对象本身上调用该方法。

在这里，我们为Cube类实现了两种方法：.surface_area（）和.volume（）。这两种计算都依赖于计算单个面的面积，因此不必重新实现面积计算，而是使用super（）来扩展面积计算。

因为Cube继承自Square和并且__ init __（）并没有为Cube做任何其它事情，所以可以跳过定义它，并且将自动调用超类（Square）的.__ init __（）。

这不仅使我们不必重复代码，而且还允许我们在单个位置更改内部.area()逻辑。当你有一堆继承自一个超类的子类时，这尤其有用.

super()深度剖析

在进入多重继承之前，让我们先快速了解一下super()的机制。

虽然上面（和下面）的示例在没有任何参数的情况下调用super（），但super（）也可以使用两个参数：第一个是子类，第二个参数是作为该子类实例的对象。

首先，让我们看两个示例，演示下第一个变量能干啥：

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
 
    def area(self):
        return self.length * self.width
 
    def perimeter(self):
        return 2 * self.length + 2 * self.width
 
class Square(Rectangle):
    def __init__(self, length):
        super(Square, self).__init__(length, length) # 在Square类的上一层类中寻找__init__方法

在Python 3中，super（Square，self）等同于无参数的super（）调用。第一个参数指的是子类Square，而第二个参数指的是Square对象，在这种情况下，它是self。也可以使用其他类调用super（）：

class Cube(Square):
    def surface_area(self):
        face_area = super(Square, self).area()
        return face_area * 6
 
    def volume(self):
        face_area = super(Square, self).area() # 在Square的上一层级搜寻area()方法
        return face_area * self.length

在此示例中，将Square设置为super（）的子类参数，而不是Cube。这就使得super（）开始在实例层次结构中的Square上一个级别搜索匹配方法（在本例中为.area（）），在本例中为Rectangle。

在此特定示例中，一切都没有发生什么变化，但想象一下Square也实现了一个.area（）函数，但是不让Cude来使用，那么，以这种方式调用super（）可以实现目的。

对于大多数用例，建议使用对super（）的无参数调用。

第二个参数怎么样？请记住，这是一个实例对象，它是用作第一个参数的类的实例。例如，isinstance（Cube，Square）必须返回True。

通过包含实例化对象，super（）返回一个绑定方法：绑定到对象的方法，该方法为方法提供对象的上下文，例如任何实例属性。如果未包含此参数，则返回的方法只是一个函数，与对象的上下文无关。

注意：从技术上讲，super（）并不返回方法。它返回一个代理对象，这个对象将调用委托给正确的类方法，而不需要另外创建一个对象。

多重继承中的super()

现在我们已经完成了super（）和单继承的一些示例，接下来我们通过示例将演示多继承如何工作以及super（）如何启用该功能。

多重继承综述

super（）还有一个特别屌的应用场景，这个用例并不像单个继承场景那样常见。除了单继承之外，Python还支持多继承，其中子类可以从多个不必继承的超类（也称为兄弟类）继承。

图表对于理解这样的概念非常有帮助，下图显示了一个非常简单的多继承方案，其中一个类继承自两个不相关（兄弟）的超类：

为了更好地说明多重继承的实际应用，下面是一些代码展示如何从三角形和正方形中构建一个正确的椎体（带有方形底座的椎体）：

class Triangle:
    def __init__(self, base, height):
        self.base = base
        self.height = height
 
    def area(self):
        return 0.5 * self.base * self.height
 
class RightPyramid(Triangle, Square):
    def __init__(self, base, slant_height):
        self.base = base
        self.slant_height = slant_height
 
    def area(self):
        base_area = super().area()
        perimeter = super().perimeter()
        return 0.5 * perimeter * self.slant_height + base_area

此示例声明了一个Triangle类和一个同时继承于Square和Triangle的RightPyramid类。

我们看到另一个使用super（）的.area（）方法，就像在单继承中一样，目的是调用在Rectangle类中定义的.perimeter（）和.area（）方法。

注意：你可能会注意到上面的代码尚未使用Triangle类中的任何继承属性。后面的例子将充分利用Triangle和Square的继承。

但问题是两个超类（Triangle和Square）都定义了一个.area（）。花一点时间思考在RightPyramid上调用.area（）时会发生什么，然后尝试调用它，如下所示：

>> pyramid = RightPyramid(2, 4)
>> pyramid.area()
Traceback (most recent call last):
  File "shapes.py", line 63, in <module>
    print(pyramid.area())
  File "shapes.py", line 47, in area
    base_area = super().area()
  File "shapes.py", line 38, in area
    return 0.5 * self.base * self.height
AttributeError: 'RightPyramid' object has no attribute 'height'

你是否猜测Python会尝试调用Triangle.area（）？这是因为称为方法解析顺序（method resolution order）的东西。

注意：我们是如何知道Triangle.area（）被调用了，而不是像我们希望的那样Square.area（）被调用？如果查看回溯的最后一行（在AttributeError之前），你将看到对特定代码行的引用：

return 0.5 * self.base * self.height

可以看到这是三角形的面积公式.

方法解析顺序

方法解析顺序（或MRO）告诉Python如何搜索继承的方法。当你使用super（）时，这就很有用了，因为MRO会告知Python在哪里寻找方法以及搜寻的优先级别。

每个类都有一个.__ mro__属性，允许我们检查顺序，所以我们来这样搞搞：

>>> RightPyramid.__mro__
(<class '__main__.RightPyramid'>, <class '__main__.Triangle'>, 
 <class '__main__.Square'>, <class '__main__.Rectangle'>, 
 <class 'object'>)

这告诉我们首先在Rightpyramid中搜索方法，然后在Triangle中搜索，接着在Square中搜索，之后在Rectangle中搜索，最后，如果没有找到，则在对象中搜索所有类。

所以我们之前的问题是解释器在Square和Rectangle之前在Triangle中搜索.area（），并且在Triangle中找到.area（）时，Python会调用它而不是你想要的那个。因为Triangle.area（）需要有.height和.base属性，所以Python会抛出AttributeError。

幸运的是，你可以控制MRO的构建方式。只需更改RightPyramid类的签名，即可按所需顺序进行搜索，方法将得以正确解析：

class RightPyramid(Square, Triangle):
    def __init__(self, base, slant_height):
        self.base = base
        self.slant_height = slant_height
        super().__init__(self.base)
 
    def area(self):
        base_area = super().area()
        perimeter = super().perimeter()
        return 0.5 * perimeter * self.slant_height + base_area

注意到，RightPyramid使用Square类中的.__ init __（）进行部分初始化。这允许.area（）在对象上使用.length，如设计的那样。

现在，您可以构建椎体，我们检查MRO，并计算表面积：

>>> pyramid = RightPyramid(2, 4)
>>> RightPyramid.__mro__
(<class '__main__.RightPyramid'>, <class '__main__.Square'>, 
<class '__main__.Rectangle'>, <class '__main__.Triangle'>, 
<class 'object'>)
>>> pyramid.area()
20.0

一切顺利！

不过，这里仍然存在问题。为了简单起见，我在这个例子中做了一些错误：第一个，可以说最重要的是，我有两个具有相同方法名称和签名的独立类。这会导致方法解析问题，就像我们上面所展示的那样。

当您使用具有多重继承的super（）时，必须设计好类以进行协作。这样做是确保你的方法是唯一的，以便确保方法是唯一的 - 无论是使用方法名称还是方法参数。

在这种情况下，为了避免不必要的麻烦，可以将Triangle类的.area（）方法重命名为.tri_area（）.

class Triangle:
    def __init__(self, base, height):
        self.base = base
        self.height = height
        super().__init__()
 
    def tri_area(self):
        return 0.5 * self.base * self.height

让我们继续在RightPyramid类中使用它：

class RightPyramid(Square, Triangle):
    def __init__(self, base, slant_height):
        self.base = base
        self.slant_height = slant_height
        super().__init__(self.base)
 
    def area(self):
        base_area = super().area()
        perimeter = super().perimeter()
        return 0.5 * perimeter * self.slant_height + base_area
 
    def area_2(self):
        base_area = super().area()
        triangle_area = super().tri_area()
        return triangle_area * 4 + base_area

这里的下一个问题是代码没有像Square对象那样的委托Triangle对象，所以调用.area_2（）会给我们一个AttributeError，因为.base和.height没有任何值。

你需要做两件事来解决这个问题：

1. 使用super（）调用的所有方法都需要调用其超类的该方法版本。这意味着您需要将super（）.__ init __（）添加到Triangle和Rectangle的.__ init __（）方法中。

2. 重新设计所有.__ init __（）调用以获取关键字字典。请参阅下面的完整代码。

class Rectangle:
    def __init__(self, length, width, **kwargs):
        self.length = length
        self.width = width
        super().__init__(**kwargs)
 
    def area(self):
        return self.length * self.width
 
    def perimeter(self):
        return 2 * self.length + 2 * self.width
 
# Here we declare that the Square class inherits from 
# the Rectangle class
class Square(Rectangle):
    def __init__(self, length, **kwargs):
        super().__init__(length=length, width=length, **kwargs)
 
class Cube(Square):
    def surface_area(self):
        face_area = super().area()
        return face_area * 6
 
    def volume(self):
        face_area = super().area()
        return face_area ** 3
 
class Triangle:
    def __init__(self, base, height, **kwargs):
        self.base = base
        self.height = height
        super().__init__(**kwargs)
 
    def tri_area(self):
        return 0.5 * self.base * self.height
 
class RightPyramid(Square, Triangle):
    def __init__(self, base, slant_height, **kwargs):
        self.base = base
        self.slant_height = slant_height
        kwargs["height"] = slant_height
        kwargs["length"] = base
        super().__init__(base=base, **kwargs)
 
    def area(self):
        base_area = super().area()
        perimeter = super().perimeter()
        return 0.5 * perimeter * self.slant_height + base_area
 
    def area_2(self):
        base_area = super().area()
        triangle_area = super().tri_area()
        return triangle_area * 4 + base_area

这份代码中存在许多重要差异：

• kwargs在某些地方被修改（例如RightPyramid .__ init __（））：这将允许这些对象的用户仅使用对该特定对象有意义的参数来实例化它们。

• 在** kwargs之前设置关键字参数：你可以在RightPyramid .__ init __（）中看到这个。

注意：遵循kwargs的状态在这里可能很棘手，所以这里是一个.__ init __（）调用表，显示拥有该调用的类，以及该调用期间kwargs的内容：

现在，当我们再次使用这些更新的类时：

>>> pyramid = RightPyramid(base=2, slant_height=4)
>>> pyramid.area()
20.0
>>> pyramid.area_2()
20.0