<think>我们正在讨论Python中所有双下划线开头和结尾的属性和方法。这类名称在Python中被称为“魔术方法”（Magic Methods）或“特殊方法”（Special Methods）。它们由Python语言定义，用于实现对象的特定行为。根据引用[1][2][4]的内容，这些方法在特定的操作中被Python解释器自动调用。
关键点：
1. 双下划线开头和结尾（如`__init__`, `__str__`）的方法是Python内置的特殊方法，用于重载运算符或定义对象的特定行为。
2. 这些方法不是普通的函数，必须定义在类中。
3. 双下划线开头和结尾的变量（属性）也是特殊用途的，但相对较少，通常用于表示一些特殊含义（如模块的`__name__`，类的`__doc__`等）。
我们将从以下几个方面进行说明：
一、常见的特殊方法（魔术方法）
二、特殊属性
三、使用场景和注意事项
一、常见的特殊方法（魔术方法）
根据引用[1]和[4]，以下是一些常见的魔术方法：
1. 对象创建和初始化：
- `__new__(cls, ...)`: 创建实例时调用的静态方法（第一个参数是类），返回实例对象。
- `__init__(self, ...)`: 初始化实例，在`__new__`之后调用。
2. 字符串表示：
- `__str__(self)`: 定义对象的“非正式”字符串表示，用于`str(obj)`和`print(obj)`。
- `__repr__(self)`: 定义对象的“正式”字符串表示，通常用于交互式解释器和调试，应尽可能返回一个可以用于重建对象的字符串表达式。
3. 运算符重载：
- 算术运算符：`__add__(self, other)`, `__sub__(self, other)`, `__mul__(self, other)`, `__truediv__(self, other)`, `__mod__(self, other)`等。
- 比较运算符：`__eq__(self, other)`, `__ne__(self, other)`, `__lt__(self, other)`, `__le__(self, other)`, `__gt__(self, other)`, `__ge__(self, other)`。
- 其他运算符：`__invert__(self)`（按位取反`~`），`__neg__(self)`（负号`-`），`__pos__(self)`（正号`+`）等。
4. 容器和序列操作：
- `__len__(self)`: 返回容器长度，用于`len(obj)`。
- `__getitem__(self, key)`: 获取索引对应的元素，用于`obj[key]`。
- `__setitem__(self, key, value)`: 设置索引对应的元素，用于`obj[key]=value`。
- `__delitem__(self, key)`: 删除索引对应的元素，用于`del obj[key]`。
- `__contains__(self, item)`: 定义`in`操作符的行为。
5. 迭代器协议：
- `__iter__(self)`: 返回一个迭代器对象，通常用于`for`循环。
- `__next__(self)`: 迭代器对象需要实现的方法，返回下一个元素。
6. 上下文管理（`with`语句）：
- `__enter__(self)`: 进入上下文时调用，返回的对象赋值给`as`后面的变量。
- `__exit__(self, exc_type, exc_value, traceback)`: 离开上下文时调用，用于处理异常和清理资源。
7. 属性访问控制：
- `__getattr__(self, name)`: 当访问不存在的属性时调用。
- `__setattr__(self, name, value)`: 设置属性时调用（包括直接赋值和`setattr`函数）。
- `__delattr__(self, name)`: 删除属性时调用。
- `__getattribute__(self, name)`: 访问任何属性时都会调用（包括存在的和不存在的）。
8. 描述符（Descriptor）协议（用于实现属性、方法绑定等高级特性）：
- `__get__(self, instance, owner)`: 当描述符被读取时调用。
- `__set__(self, instance, value)`: 当描述符被设置时调用。
- `__delete__(self, instance)`: 当描述符被删除时调用。
二、特殊属性
除了方法，Python也有一些双下划线开头和结尾的特殊属性：
1. `__name__`：对象的名字，如模块、类、函数的名字。
2. `__doc__`：对象的文档字符串（docstring）。
3. `__module__`：定义对象的模块名。
4. `__class__`：对象的类。
5. `__dict__`：对象属性的字典（参见之前的问题）。
6. `__slots__`：限制实例可以拥有的属性（用于内存优化）。
7. `__annotations__`：包含类型注解的字典（Python 3.6+）。
8. `__bases__`：类的基类元组。
三、使用场景和注意事项
1. 特殊方法通常由Python解释器隐式调用，不建议直接调用（除非你知道自己在做什么）。
2. 特殊属性由Python内部设置，通常只读（除了`__dict__`等少数可写）。
3. 自定义类中实现特殊方法可以实现运算符重载、对象行为定制等高级功能。
4. 引用[3]指出：双下划线开头并结尾的变量（如`__var__`）会继承给子类，类似于普通属性。而双下划线开头但没有结尾（如`__var`）的变量是私有变量，会触发名称修饰（Name Mangling），即变成`_类名__var`的形式，这样可以避免子类中的命名冲突[^3][^4][^5]。
5. 模块级别的特殊属性：模块也有`__name__`、`__file__`、`__package__`等属性。
示例代码：
定义一个类，展示几个特殊方法的使用：
```python
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f'Vector({self.x}, {self.y})'
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __eq__(self, other):
return self.x == other.x and self.y == other.y
# 使用
v1 = Vector(2, 4)
v2 = Vector(3, 1)
print(v1 + v2) # 调用__add__，然后调用__str__：Vector(5, 5)
print(v1 == v2) # 调用__eq__：False
```
关于特殊属性，我们可以查看上面Vector类的属性：
```python
print(Vector.__name__) # 输出 'Vector'
print(Vector.__module__) # 输出 '__main__'（如果是直接运行）
```
注意：在模块级别，我们也可以定义一些特殊属性（比如`__doc__`用于模块文档），但通常不建议在模块级别定义太多自己的双下划线属性，以免与Python内置的特殊属性冲突。
总结：
双下划线开头和结尾的名称是Python中用于特殊目的的标识符，它们赋予了类特殊的能力，使得自定义类可以像内置类型一样行为。同时，Python也提供了一些特殊属性用于获取对象的元信息。
§§相关问题§§
1. 名称修饰（Name Mangling）的具体规则是什么？私有变量如何访问？
2. 描述符协议（Descriptor Protocol）在实际开发中有哪些应用场景？
3. 除了常见的魔术方法，Python中还有哪些较少用但功能强大的特殊方法？
</think>### Python 双下划线开头和结尾的属性方法详解（`__xxx__`）
在 Python 中，以双下划线开头和结尾的标识符（如 `__init__`, `__str__`）被称为**特殊方法**或**魔术方法**（Magic Methods）。它们由 Python 语言定义，用于实现对象的特定行为，在特定操作时会被解释器自动调用[^1][^4]。以下是完整分类和说明：
#### 一、核心功能分类
1. **对象生命周期方法**
```python
__new__(cls) # 创建实例时调用（构造函数之前）
__init__(self) # 对象初始化（最常用）[^1]
__del__(self) # 对象销毁时调用（析构函数）
```
2. **字符串表示方法**
```python
__str__(self) # 定义 print(obj) 的输出[^1]
__repr__(self) # 定义解释器直接显示的对象表示
__format__(self) # 定义 format() 函数的格式化行为
```
3. **运算符重载方法**
```python
__add__(self, other) # 实现 + 运算 (a + b)
__sub__(self, other) # 实现 - 运算 (a - b)[^1]
__mul__(self, other) # 实现 * 运算
__eq__(self, other) # 实现 == 比较
__lt__(self, other) # 实现 < 比较
```
4. **容器类型方法**
```python
__len__(self) # 定义 len(obj) 的行为
__getitem__(self, key) # 定义 obj[key] 的访问
__setitem__(self, key, value) # 定义 obj[key]=value
__contains__(self, item) # 定义 in 运算符行为
```
5. **调用与上下文管理**
```python
__call__(self) # 使对象可调用（如 obj()）
__enter__(self) # with 语句进入时调用
__exit__(self) # with 语句退出时调用
```
#### 二、特殊属性（只读）
| 属性 | 说明 |
|------|------|
| `__name__` | 对象名称（函数/类/模块）[^4] |
| `__doc__` | 对象的文档字符串 |
| `__module__` | 定义对象的模块名 |
| `__class__` | 对象所属的类 |
| `__dict__` | 对象属性的字典[^4] |
| `__slots__` | 限定类允许的属性 |
| `__annotations__` | 类型注解字典 |
#### 三、关键特性
1. **自动触发机制**
特殊方法由 Python 解释器隐式调用：
```python
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
p1 = Point(1, 2) # 自动调用 __init__
p2 = Point(3, 4)
p3 = p1 + p2 # 自动触发 __add__
```
2. **命名规范约束**
- `__xxx__` 是 Python 保留命名空间[^4]
- 自定义属性**禁止**使用此格式（可能导致与未来 Python 特性冲突）
3. **与私有变量的区别**
| 类型 | 示例 | 可继承性 | 访问性 |
|------|------|----------|--------|
| 特殊方法 | `__init__` | 可继承 | 公有 |
| 私有变量 | `__name` | 不可继承[^3] | 需通过 `_ClassName__name` 访问[^5] |
#### 四、使用示例
```python
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f"Vector({self.x}, {self.y})" # 自定义输出格式
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y) # 向量加法
v1 = Vector(2, 3)
v2 = Vector(4, 5)
print(v1) # 输出: Vector(2, 3)（调用 __str__）
v3 = v1 + v2 # 输出: Vector(6, 8)（调用 __add__）
```
#### 五、注意事项
1. 避免在自定义属性中使用 `__xxx__` 格式
2. 直接调用魔术方法可能破坏封装性（如 `obj.__init__()`）
3. 内置类型（如 `list`, `dict`）已实现大量特殊方法
4. 通过 `dir(obj)` 可查看对象的所有特殊方法
> 特殊方法是 Python **面向对象编程的基石**，它们使得自定义对象能像内置类型一样支持运算符、迭代等核心操作[^1][^4]。
最低0.47元/天 解锁文章
扫一扫
964
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
