super() 这么优秀，官方也极力推荐，但这里面有些坑你们可能把握不住…

小白不急躁

super从入门到劝退
我还是老老实实的绑定去吧
但是我记住了深度优先and从左到右

yb23991257

学习学习

painx

class A:
    def say(self):
        print("FishA")

class B:
    def say(self):
        print("FishB")
        
class C(A):
    def say(self):
        A.say(self)
        print("FishC")
        
class D(B):
    def say(self):
        B.say(self)
        print("FishD")

class E(C, D):
    def say(self):
        D.say(self)
        C.say(self)
        print("FishE")

e = E()
e.say()

================
这段代码运行结果明明是：
FishB
FishD
FishA
FishC
FishE

20011230

1

dot_35

.

跳大神er

布吉岛

阿碧的老司机

1

nick_wanci

gigi.wudan

keep going

盖世嘤雄

classA里面的init少一个arg参数吧？

qq1013202623

1

sevenqqq

1

leihongwei93

最后一个例子的运行结果是不是错了呀，我运行了一下，应该是：
FishB
FishD
FishA
FishC
FishE

phTian

不过对于这种情况，如果我们老老实实去调用未绑定父类的方法，事儿也不会那么多：
class A:
    def say(self):
        print("FishA")

class B:
    def say(self):
        print("FishB")
        
class C(A):
    def say(self):
        A.say(self)
        print("FishC")
        
class D(B):
    def say(self):
        B.say(self)
        print("FishD")

class E(C, D):
    def say(self):
        D.say(self)
        C.say(self)
        print("FishE")

e = E()
e.say()
代码实现如下：
=================== RESTART: C:\Users\goodb\Desktop\FishC.py ===================
FishA
FishB
FishC
FishD
FishE

这一步的结果顺序是不是不对啊？@FishC

FishC

phTian 发表于 2024-06-28 11:31
不过对于这种情况，如果我们老老实实去调用未绑定父类 ...

哈哈，这段代码的确让人头疼，不过让咱们从头捋一捋，看看到底哪儿出问题了。

首先，我们看下你的类继承关系：
- `E` 继承了 `C` 和 `D`
- `C` 继承了 `A`
- `D` 继承了 `B`

也就是说 `E` 的继承链是这样的：

1. E -> C -> A
   
2.    -> D -> B

复制代码

现在来看 `E` 类的 `say` 方法：

1. class E(C, D):
   
2.     def say(self):
   
3.         D.say(self)
   
4.         C.say(self)
   
5.         print("FishE")

复制代码

调用 `D.say(self)` 时，`D` 类会调用 `B.say(self)`，然后打印 `FishD`：

1. B.say(self) -> print("FishB")
   
2. D.say(self) -> print("FishD")

复制代码

然后调用 `C.say(self)`，`C` 类会调用 `A.say(self)`，然后打印 `FishC`：

1. A.say(self) -> print("FishA")
   
2. C.say(self) -> print("FishC")

复制代码

所以 `e.say()` 实际调用顺序是：
1. `D.say(self)`
   - 调用 `B.say(self)` -> 输出 `FishB`
   - 然后 `D.say(self)` -> 输出 `FishD`
2. `C.say(self)`
   - 调用 `A.say(self)` -> 输出 `FishA`
   - 然后 `C.say(self)` -> 输出 `FishC`
3. 最后 `E.say(self)` -> 输出 `FishE`

这样顺序就是：

1. FishB
   
2. FishD
   
3. FishA
   
4. FishC
   
5. FishE

复制代码

显然跟你实际的输出顺序不同。实际输出是：

1. FishA
   
2. FishB
   
3. FishC
   
4. FishD
   
5. FishE

复制代码

这说明类的 `say` 方法并没有按照 `E` 类中的调用顺序来执行。那么，这就是 Python 中的 `MRO`（方法解析顺序）在起作用了！

用 `super()` 和 `MRO` 机制重新写这段代码会更好一点：

1. class A:
   
2.     def say(self):
   
3.         print("FishA")
   
4. 
   
5. class B:
   
6.     def say(self):
   
7.         print("FishB")
   
8. 
   
9. class C(A):
   
10.     def say(self):
    
11.         super().say()
    
12.         print("FishC")
    
13. 
    
14. class D(B):
    
15.     def say(self):
    
16.         super().say()
    
17.         print("FishD")
    
18. 
    
19. class E(C, D):
    
20.     def say(self):
    
21.         super().say()
    
22.         print("FishE")
    
23. 
    
24. e = E()
    
25. e.say()

复制代码

这样使用 `super()` 后，顺序就会按 `MRO` 进行：

1. FishB
   
2. FishD
   
3. FishA
   
4. FishC
   
5. FishE

复制代码

我们可以验证一下 `E` 的 `MRO`：

1. print(E.__mro__)

复制代码

输出：

1. (<class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class '__main__.D'>, <class '__main__.B'>, <class 'object'>)

复制代码

所以最终顺序应该是：

1. FishB -> FishD -> FishA -> FishC -> FishE

复制代码

这样一来，我们就能够看到 `super()` 如何依照 `MRO` 顺序来进行方法调用了。Python 里的继承顺序可真是个迷宫，得让人慢慢探索啊！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

雨明

因为类A的构造函数中不需要传入参数

shuaibin007

甲鱼迷弟

嘻嘻

a48948008

学习学习

735146730

A调用D
D有arg