q
arg未绑定对象
父类的构造方法没有入参
A,B无arg参数
1
要理解 “D.__init__需要 arg 参数但未传递”，关键在于多继承的方法解析顺序（MRO） 和super () 的参数传递逻辑，结合你的代码结构一步步拆解就很清晰了：
先明确类的继承关系和每个类的__init__参数
假设已修正构造方法名为__init__（原代码是_init_，这是基础错误），各阶级的__init__定义如下：
python
运行
class A:
def __init__(self):# 无参数
super().__init__()
class B:
def __init__(self):# 无参数
super().__init__()
class C(A):
def __init__(self, arg):# 需要1个参数arg
super().__init__()# 调用时没传参数
class D(B):
def __init__(self, arg):# 需要1个参数arg
super().__init__()# 调用时没传参数
class E(C, D):
def __init__(self, arg):# 需要1个参数arg
super().__init__(arg)# 调用时传了arg
核心：MRO（方法解析顺序）决定调用链
当实例化E时（e = E(520)），Python 会按MRO 顺序调用所有相关类的__init__。对于E(C, D)，MRO 顺序是：E → C → A → D → B → object
（可以通过E.__mro__查看这个顺序，这是 Python 多继承中 “先左后右、深度优先” 的解析规则）
一步步看参数传递过程
调用 E 的__init__：E.__init__(self, 520) 执行，内部调用 super().__init__(520)。根据 MRO，super()此时指向C，所以实际调用 C.__init__(self, 520)（参数520被传递给 C，符合 C 需要arg的要求）。
调用 C 的__init__：C.__init__(self, 520) 执行，内部调用 super().__init__()（注意：这里没传任何参数）。根据 MRO，super()此时指向A，所以实际调用 A.__init__(self)（A 不需要参数，没问题）。
调用 A 的__init__：A.__init__(self) 执行，内部调用 super().__init__()（依然没传参数）。根据 MRO，super()此时指向D（因为 A 的下一个是 D），所以实际调用 D.__init__(self)。
问题出在这里：调用 D 的__init__D.__init__ 的定义是 def __init__(self, arg):，它必须接收 1 个参数 arg，但此时从 A 的super()过来的调用是 D.__init__(self)（没有传arg）。因此，Python 会报错：TypeError: D.__init__() missing 1 required positional argument: 'arg'。
一句话总结
因为 MRO 顺序要求在调用完 A 的__init__后必须调用 D 的__init__，但 D 的__init__需要arg参数，而整个调用链中（从 C 到 A 的super()）没有传递这个参数，导致 D 的__init__参数缺失。
偏离
应该是A的super没有放置参数
好难啊
学习学习
{:5_101:}
>>> class A:
... def say(self):
... print("FishA")
...
>>> class B:
... def say(self):
... print("FishB")
...
>>> class C(A, B):
... def say(self):
... super().say()
...
>>> c = C()
>>> c.say()
FishA
很好！你这个例子其实正好展示了 **多继承 + super() + MRO 方法解析顺序** 的效果。我们一步一步来看为什么最后打印的是 **FishA**。
---
## 🔍 代码回顾
```python
class A:
def say(self):
print("FishA")
class B:
def say(self):
print("FishB")
class C(A, B):
def say(self):
super().say()
c = C()
c.say()
```
输出：
```
FishA
```
---
## ✅ 关键点：`super()` + MRO
当你执行：
```python
c.say()
```
时发生了：
1️⃣ 进入 `C.say()`
2️⃣ `super().say()` 被调用
3️⃣ super 并不是“只找父类 A”
它是按 **MRO（方法解析顺序）** 找方法的。
---
## 📌 C 的 MRO 顺序是：
你可以打印看看：
```python
print(C.mro())
```
结果：
```
[<class '__main__.C'>,
<class '__main__.A'>,
<class '__main__.B'>,
<class 'object'>]
```
顺序是：
```
C → A → B → object
```
---
## ✨ super() 的工作方式
在 `C.say()` 里：
```python
super().say()
```
并不是“找父类 A”这么简单，而是：
👉 按 MRO 顺序
👉 从 **C 的下一个类（A）开始找 say()**
A 里刚好有：
```python
def say(self):
print("FishA")
```
所以就打印：
```
FishA
```
B 根本没机会执行。
---
## ❓如果我们改继承顺序呢？
把 C 改成：
```python
class C(B, A):
```
再执行：
```python
c.say()
```
输出将变成：
```
FishB
```
因为 MRO 变为：
```
C → B → A → object
```
---
## 🎯 总结一句话
`super()` 在多继承中不是“找父类”，
而是“**按 MRO 顺序继续往后找**”。
所以：
* C(A, B) → 找到 A.say → 打印 FishA
* C(B, A) → 找到 B.say → 打印 FishB
---
如果你还想继续深入，比如：
* super() 到底是怎么跳转的？
* 多层继承链如何工作？
* 和 Java/C++ 的 super 有啥不同？
我可以继续帮你拆得更细 😊
又深刻的学习一遍
1
class B 多了一个super（）
不知道
03
0
1
1
同样的到a就结束了