---
fid: 20240730-201114
author: Kimi
tags: 
---

```{index} index
```

# super() 的作用是什么？(Kimi)
(20240730-201114)=

2024-07-30


## `super().__init__()` 的作用是什么？

在Python中，`super().__init__()` 是一个特殊的调用，用于初始化父类（或基类）的实例。当你在一个子类中使用 `super().__init__()` 时，它将调用父类中定义的 `__init__()` 方法。这是多态和继承机制的一部分，确保父类被正确地初始化，并且可以在子类中扩展或修改父类的行为。

这里是一些关键点：

1. **继承**：`super()` 函数返回了一个代理对象，它允许你调用父类的方法。
2. **初始化**：`__init__()` 是一个特殊的方法，用于在创建对象时进行初始化设置。
3. **调用顺序**：当你在子类中定义自己的 `__init__()` 方法时，通常应该首先调用 `super().__init__()`，以确保父类被正确初始化。
4. **多态性**：使用 `super()` 可以确保即使在多级继承结构中，父类的 `__init__()` 方法也能被正确调用。

例如，如果你有一个基类 `Animal` 和一个子类 `Dog`，`Dog` 类的 `__init__()` 方法可能会这样写：

```python
class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 初始化父类
        self.breed = breed
```

在这个例子中，`Dog` 类通过调用 `super().__init__(name)` 来确保 `Animal` 类的 `__init__()` 方法被调用，设置了 `name` 属性。然后，`Dog` 类可以添加自己的属性 `breed`。


## 忘了 super().__init__ 会怎么样?


我在定义类时 class mydict(UserDict) 时，忘记了在 __init__() 方法中调用 super().__init__ 会怎么样？

如果你在定义一个类时继承了 `UserDict` 类，但在 `__init__()` 方法中忘记了调用 `super().__init__()`，这将导致几个问题：

1. **父类初始化未执行**：`UserDict` 类的 `__init__()` 方法将不会被执行，这意味着任何在 `UserDict` 的初始化方法中设置的属性或执行的代码都不会被执行。

2. **属性缺失**：如果 `UserDict` 的 `__init__()` 方法中设置了一些属性或进行了一些初始化操作，这些属性在你的 `mydict` 类中将不可用。

3. **方法不可用**：`UserDict` 类可能定义了一些方法，如果未正确初始化，这些方法可能无法在你的 `mydict` 类中正常工作。

4. **潜在的错误**：如果 `UserDict` 的 `__init__()` 方法中包含了重要的错误检查或条件逻辑，没有执行这些检查可能导致运行时错误或不正确的行为。

5. **继承链中断**：如果你的 `mydict` 类继续被其他类继承，并且这些子类依赖于 `UserDict` 的初始化逻辑，那么整个继承链中的类都可能受到影响。

例如，如果你有以下代码：

```python
from collections import UserDict

class mydict(UserDict):
    def __init__(self, *args, **kwargs):
        # 忘记调用 super().__init__()
        # super().__init__(*args, **kwargs)
        pass

# 使用 mydict 类
d = mydict({'key': 'value'})
```

如果你尝试使用 `d` 作为字典，可能会遇到问题，因为 `UserDict` 的初始化逻辑没有被执行。例如，`UserDict` 可能期望在初始化时接收一个字典来复制其内容，但没有调用 `super().__init__()` 将导致这个预期的行为没有发生。

正确的做法是在你的 `mydict` 类的 `__init__()` 方法中调用 `super().__init__()`，以确保 `UserDict` 的初始化逻辑被正确执行：

```python
class mydict(UserDict):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # 你可以在这里添加额外的初始化代码
```

这样，`UserDict` 的 `__init__()` 方法将被调用，任何必要的初始化操作都将被执行，你的 `mydict` 类将能够正常工作。


## 如何正确地调用 super() 方法？

如果我想在 __init__ 方法中添加一些自定义的初始化逻辑，应该如何正确地调用 super() 方法？


如果你想在 `__init__` 方法中添加一些自定义的初始化逻辑，并且同时正确地调用父类的 `__init__` 方法，你应该按照以下步骤进行：

1. **调用 `super()`**：首先，使用 `super().__init__()` 调用父类的 `__init__()` 方法。这确保了父类被正确初始化。

2. **传递参数**：如果父类的 `__init__()` 方法需要参数，确保传递正确的参数。这可以通过使用 `*args` 和 `**kwargs` 来实现，它们分别表示任意数量的位置参数和关键字参数。

3. **添加自定义逻辑**：在调用 `super().__init__()` 之后，你可以添加任何自定义的初始化逻辑。

以下是一个示例，展示了如何在 `__init__` 方法中正确调用 `super()` 并添加自定义逻辑：

```python
class Parent:
    def __init__(self, value):
        self.value = value
        print("Parent initialized with value:", self.value)

class Child(Parent):
    def __init__(self, value, extra):
        # 调用父类的 __init__ 方法，并传递 value 参数
        super().__init__(value)
        # 添加自定义属性和逻辑
        self.extra = extra
        print("Child initialized with extra:", self.extra)

# 使用 Child 类
child = Child(10, 'additional info')
```

在这个例子中，`Child` 类继承自 `Parent` 类。在 `Child` 的 `__init__` 方法中，首先调用 `super().__init__(value)` 来初始化父类的属性。然后，`Child` 类添加了一个额外的属性 `extra` 并打印了一条消息。

当你创建 `Child` 类的实例时，你会看到输出显示了父类和子类的初始化信息，这表明父类的 `__init__()` 方法和子类的自定义逻辑都被正确执行了。

记住，`super()` 函数是 Python 2.2 以后版本中引入的，它提供了一种方便的方式来调用父类的方法，而不必显式地指定父类的名称。这在多继承的情况下尤其有用，因为它自动处理了方法解析顺序（MRO）。


## 举一个使用和扩展 UserDict 功能的例子

`UserDict` 是 Python `collections` 模块中的一个类，它提供了字典接口，但是可以存储任意的对象。这使得它非常适合作为自定义字典类的基类。以下是一个使用和扩展 `UserDict` 功能的例子：

```python
from collections import UserDict

class MyDict(UserDict):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._reversed = {}
        self._update_reversed()

    def _update_reversed(self):
        self._reversed = {value: key for key, value in self.items() if value not in self._reversed}

    def __setitem__(self, key, value):
        super().__setitem__(key, value)
        self._update_reversed()

    def __delitem__(self, key):
        super().__delitem__(key)
        self._update_reversed()

    def get_reversed_key(self, value):
        return self._reversed.get(value)

# 使用 MyDict 类
my_dict = MyDict({'apple': 1, 'banana': 2, 'cherry': 3})

# 正常使用字典
print(my_dict['apple'])  # 输出: 1

# 使用扩展功能，根据值获取键
print(my_dict.get_reversed_key(2))  # 输出: 'banana'

# 添加新项
my_dict['date'] = 4
print(my_dict.get_reversed_key(4))  # 输出: 'date'

# 删除项
del my_dict['cherry']
print(my_dict.get_reversed_key(3))  # 输出: None，因为 'cherry' 已经被删除
```

在这个例子中，`MyDict` 类继承自 `UserDict`，并且添加了以下功能：

1. **反向查找**：`MyDict` 类可以反向查找键，即根据值来查找对应的键。这是通过维护一个 `_reversed` 字典实现的，它存储了值到键的映射。

2. **更新反向映射**：每次通过 `__setitem__` 或 `__delitem__` 方法修改字典时，都会调用 `_update_reversed` 方法来更新 `_reversed` 字典。

3. **获取反向键**：`get_reversed_key` 方法允许用户根据值来获取对应的键，如果该值在字典中不存在，则返回 `None`。

这个例子展示了如何通过继承 `UserDict` 并添加一些自定义的方法来扩展字典的功能。你可以根据需要添加更多的方法或属性，以实现更复杂的功能。