Python中的魔术方法（Magic Methods）

魔术方法（也称为特殊方法或双下方法）是Python中一种强大的特性，它们允许你在类中定义特定的行为，以响应内置操作。这些方法的名字以双下划线开头和结尾（例如 __init__）。

1. 核心概念：运算符重载与协议

魔术方法的本质是“运算符重载”和“协议实现”。它们让你自定义的类对象能够使用Python的固有语法，比如 +（__add__），len()（__len__），for循环（__iter__）等。

2. 最基础的魔术方法：__init__ 与 __new__

• __init__(self, ...)：这是最常见的魔术方法，称为初始化方法。它在对象实例被创建之后调用，用于初始化对象的属性。

  • 关键点：它并不创建对象，只是对已经创建好的对象进行初始设置。

  • class Student:
        def __init__(self, name, age):
            self.name = name  # 初始化实例属性 name
            self.age = age    # 初始化实例属性 age
    
    # 创建对象时，`__init__` 被自动调用
    stu = Student("Alice", 20)
    print(stu.name)  # 输出: Alice
    

• __new__(cls, ...)：这是一个更底层的方法，称为构造方法。它负责创建并返回一个类的实例对象。它会在 __init__ 之前被调用。

  • 关键点：__new__ 是一个静态方法（虽然不需要显式声明），第一个参数是类本身 cls。
  • 通常不需要重写，除非你在进行元编程或继承自不可变类型（如 str, tuple）。

  • class MyClass:
        def __new__(cls, *args, **kwargs):
            print("__new__ is called. Creating instance.")
            # 必须调用父类的 __new__ 来创建实例
            instance = super().__new__(cls)
            return instance
    
        def __init__(self):
            print("__init__ is called. Initializing instance.")
    
    obj = MyClass()
    # 输出:
    # __new__ is called. Creating instance.
    # __init__ is called. Initializing instance.
    

3. 对象表示方法：__str__ 与 __repr__

这两个方法决定了对象的“字符串表示形式”，对调试和日志记录至关重要。

• __str__(self)：当使用 print(obj) 或 str(obj) 时被调用。目标是返回一个可读性好、对用户友好的字符串描述。
• __repr__(self)：当在交互式命令行中直接输入对象名时，或被 repr(obj) 调用时触发。目标是返回一个明确无歧义、对开发者友好的字符串，理想情况下应该是一个可以用于重新创建该对象的代码表达式。
• 最佳实践：至少定义 __repr__。因为如果 __str__ 未定义，Python 会使用 __repr__ 作为备选。

  • class Point:
        def __init__(self, x, y):
            self.x = x
            self.y = y
    
        def __str__(self):
            return f"Point(x={self.x}, y={self.y})"
    
        def __repr__(self):
            # 返回的字符串通常看起来像创建对象的代码
            return f"Point({self.x}, {self.y})"
    
    p = Point(1, 2)
    print(p)        # 调用 __str__: 输出 Point(x=1, y=2)
    print(str(p))    # 调用 __str__: 输出 Point(x=1, y=2)
    print(repr(p))   # 调用 __repr__: 输出 Point(1, 2)
    # 在交互式环境中直接输入 `p` 会输出：Point(1, 2)
    

4. 富比较魔术方法

这些方法用于重载比较运算符（<, <=, ==, !=, >, >=）。

• __lt__(self, other)： < (less than)
• __le__(self, other)： <= (less than or equal)
• __eq__(self, other)： == (equal)
• __ne__(self, other)： != (not equal)
• __gt__(self, other)： > (greater than)
• __ge__(self, other)： >= (greater than or equal)
• 注意：在Python 3中，如果只定义了 __eq__ 而没有定义 __ne__，Python会自动提供 __ne__ 作为 __eq__ 的反义。对于其他运算符，没有自动推导关系。

  • class Salary:
        def __init__(self, amount):
            self.amount = amount
    
        def __lt__(self, other):
            # 定义 < 运算符的行为
            return self.amount < other.amount
    
        def __eq__(self, other):
            # 定义 == 运算符的行为
            if not isinstance(other, Salary):
                return NotImplemented  # 遇到无法处理的类型时返回 NotImplemented
            return self.amount == other.amount
    
    s1 = Salary(50000)
    s2 = Salary(60000)
    print(s1 < s2)   # True, 调用 s1.__lt__(s2)
    print(s1 == s2)  # False
    

5. 算术运算魔术方法

让你自定义对象如何响应数学运算符，如 +, -, *, /。

• __add__(self, other)： +
• __sub__(self, other)： -
• __mul__(self, other)： *
• __truediv__(self, other)： /
• 还有对应的反向方法（当左操作数不支持运算时尝试右操作数，如 __radd__）和就地赋值方法（如 __iadd__ 对应 +=）。

  • class Vector:
        def __init__(self, x, y):
            self.x = x
            self.y = y
    
        def __add__(self, other):
            # 定义 + 运算：向量加法
            if isinstance(other, Vector):
                return Vector(self.x + other.x, self.y + other.y)
            return NotImplemented
    
        def __str__(self):
            return f"Vector({self.x}, {self.y})"
    
    v1 = Vector(1, 2)
    v2 = Vector(3, 4)
    v3 = v1 + v2  # 等价于 v1.__add__(v2)
    print(v3)  # 输出: Vector(4, 6)
    

6. 使对象表现得像容器：__len__ 和 __getitem__

通过实现这些方法，可以让你的自定义对象支持 len() 函数和下标索引 []，使其行为类似于列表或字典。

• __len__(self)： 当调用 len(obj) 时被调用，应返回容器的“长度”（一个非负整数）。
• __getitem__(self, key)： 当使用 obj[key] 进行索引操作时被调用。它应该实现基于 key 返回对应值的逻辑。

• class BookShelf:
      def __init__(self, books):
          self.books = books  # books 是一个列表
  
      def __len__(self):
          return len(self.books)
  
      def __getitem__(self, index):
          # 支持索引，如 shelf[0]
          return self.books[index]
  
      # 还可以实现 __setitem__ 和 __delitem__ 来支持赋值和删除
  
  shelf = BookShelf(["Book A", "Book B", "Book C"])
  print(len(shelf))    # 输出: 3, 调用 __len__
  print(shelf[1])      # 输出: "Book B", 调用 __getitem__
  for book in shelf:    # 因为实现了 __getitem__，它也自动支持迭代！
      print(book)
  

总结
魔术方法是Python面向对象编程的基石之一。它们通过实现特定的协议，将自定义类无缝地融入到Python的语言生态中。理解并熟练运用常见的魔术方法，能够极大地提升代码的表现力和可读性。学习路径通常是从 __init__, __str__, __repr__ 开始，然后逐步掌握比较、运算、容器模拟等更高级的方法。