Python知识点——魔法方法（Magic Method）

魔法方法是 Python 中一种特殊的、以双下划线 __ 开头和结尾的方法。它们能让你定义 Python 语法的行为，比如对象的创建、比较、算术运算、打印输出等。当你使用特定的语法或内置函数时，Python 会自动调用这些方法。

掌握魔法方法是写出 "Pythonic" 代码和构建强大、直观的类的关键。

---

一、魔法方法的核心特点

1. 自动调用 ：你不需要手动调用 obj.__init__()，而是在创建对象 obj = ClassName() 时，Python 会自动调用它。
2. 拦截内置操作 ：它们允许你的对象响应 Python 的内置操作符和函数。例如，obj1 + obj2 会触发 obj1.__add__(obj2)。
3. 双下划线命名 ：所有魔法方法都遵循 __methodname__ 的命名规范。这是 Python 的约定，不要自己定义这样的方法除非你明确想实现一个魔法行为。
4. 定义类的行为：通过重写这些方法，你可以自定义类的实例如何被创建、比较、转换为字符串、进行算术运算等。

---

二、常用魔法方法分类详解

下面是一些最常用的魔法方法，按照功能进行了分类。

1. 对象创建与初始化

这类方法控制对象的创建和初始化过程。

• __new__(cls, *args, **kwargs)

  • 作用：创建并返回一个新的实例。它是实例化过程中调用的第一个方法。
  • 参数 ：cls 是类本身。
  • 注意：通常不需要重写，除非你想控制实例的创建（例如，实现单例模式）。必须返回一个实例。

• __init__(self, *args, **kwargs)

  • 作用 ：初始化一个已经被 __new__ 创建的实例。
  • 参数 ：self 是新创建的实例。
  • 注意 ：这是最常用的魔法方法。它负责设置实例的初始状态。不应该返回任何值（None）。

• __del__(self)

  • 作用：当对象被垃圾回收时调用，作为对象的 "析构函数"。
  • 注意 ：不推荐使用。它的调用时机不确定，可能导致资源泄漏。更推荐使用 with 语句或显式的 close() 方法来管理资源。

2. 字符串表示

这类方法定义了对象如何被转换为字符串，对于调试和打印输出至关重要。

• __str__(self)

  • 作用：返回对象的 "非正式" 或 "用户友好" 的字符串表示。
  • 调用时机 ：当使用 str(obj) 或 print(obj) 时。
  • 建议：返回一个易读的字符串。

• __repr__(self)

  • 作用：返回对象的 "正式" 或 "开发者友好" 的字符串表示。理想情况下，这个字符串应该能用来重新创建该对象。
  • 调用时机 ：当使用 repr(obj) 或在交互式环境中直接输入对象名时。
  • 建议 ：返回一个明确、无歧义的字符串。如果不确定，至少要实现 __repr__。

示例：

import datetime

class Person:
    def __init__(self, name, birth_year):
        self.name = name
        self.birth_year = birth_year

    def __str__(self):
        return f"Person: {self.name}"

    def __repr__(self):
        return f"Person(name='{self.name}', birth_year={self.birth_year})"

p = Person("Alice", 1990)

print(p)              # 输出: Person: Alice (__str__被调用)
print(str(p))         # 输出: Person: Alice (__str__被调用)
print(repr(p))        # 输出: Person(name='Alice', birth_year=1990) (__repr__被调用)

3. 比较运算符

通过重写这些方法，你可以定义自定义对象之间如何进行比较。

• __eq__(self, other): self == other
• __ne__(self, other): self != other
• __lt__(self, other): self < other
• __le__(self, other): self <= other
• __gt__(self, other): self > other
• __ge__(self, other): self >= other

示例：

class Book:
    def __init__(self, title, pages):
        self.title = title
        self.pages = pages

    def __eq__(self, other):
        # 检查 other 是否是 Book 类型的实例
        if not isinstance(other, Book):
            return False
        return self.title == other.title and self.pages == other.pages

    def __lt__(self, other):
        if not isinstance(other, Book):
            # 与非 Book 对象比较，通常不支持
            return NotImplemented
        return self.pages < other.pages

b1 = Book("1984", 328)
b2 = Book("1984", 328)
b3 = Book("To Kill a Mockingbird", 281)

print(b1 == b2)  # True (__eq__被调用)
print(b1 == "1984") # False (__eq__被调用)
print(b3 < b1)   # True (__lt__被调用)

4. 算术运算符

这类方法允许你的对象支持加法、减法等算术运算。

• __add__(self, other): self + other
• __sub__(self, other): self - other
• __mul__(self, other): self * other
• __truediv__(self, other): self / other
• __floordiv__(self, other): self // other
• __mod__(self, other): self % other

示例：

class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if isinstance(other, Vector2D):
            return Vector2D(self.x + other.x, self.y + other.y)
        return NotImplemented

    def __repr__(self):
        return f"Vector2D({self.x}, {self.y})"

v1 = Vector2D(1, 2)
v2 = Vector2D(3, 4)

v3 = v1 + v2
print(v3)  # 输出: Vector2D(4, 6) (__add__被调用)

5. 容器类型的模拟

如果你想让你的类的实例像列表、字典一样可以被索引、切片或迭代，你需要实现以下方法。

• __len__(self)

  • 作用：返回对象的 "长度" 或 "大小"。
  • 调用时机 ：当使用 len(obj) 时。

• __getitem__(self, key)

  • 作用：获取指定键（索引、键名等）的值。
  • 调用时机 ：当使用 obj[key] 时。

• __setitem__(self, key, value)

  • 作用：设置指定键的值。
  • 调用时机 ：当使用 obj[key] = value 时。

• __delitem__(self, key)

  • 作用：删除指定键的值。
  • 调用时机 ：当使用 del obj[key] 时。

• __iter__(self)

  • 作用：返回一个迭代器对象。
  • 调用时机 ：当使用 for 循环遍历对象时。

示例（模拟一个简单的自定义列表）：

class MyList:
    def __init__(self, items):
        self.items = list(items)

    def __len__(self):
        return len(self.items)

    def __getitem__(self, index):
        return self.items[index]

    def __setitem__(self, index, value):
        self.items[index] = value

    def __repr__(self):
        return f"MyList({self.items})"

my_list = MyList([10, 20, 30])

print(len(my_list))      # 输出: 3 (__len__被调用)
print(my_list[1])        # 输出: 20 (__getitem__被调用)

my_list[0] = 100
print(my_list)           # 输出: MyList([100, 20, 30]) (__setitem__被调用)

# for item in my_list:  # 这会报错，因为我们没有实现 __iter__
#     print(item)

三、总结

魔法方法是 Python 面向对象编程的灵魂，它们为你的类赋予了与 Python 核心语法无缝集成的能力。

• 核心思想 ：不是调用方法，而是使用语言本身的语法（如 +, ==, len()），Python 会自动 dispatch 到对应的魔法方法。
• 常见用途 ：
  • 对象生命周期管理 ：__new__, __init__
  • 友好的字符串输出 ：__str__, __repr__
  • 自定义比较逻辑 ：__eq__, __lt__ 等
  • 支持算术运算 ：__add__, __mul__ 等
  • 模拟内置容器 ：__len__, __getitem__, __iter__ 等