引言：让对象行为更自然

在前面的章节中，我们学习了如何创建类、定义方法和实现面向对象的基本特性。但当我们使用Python内置类型时，会发现它们有一些非常自然的行为：我们可以用len()获取列表的长度，用for循环遍历字典的键，用print()输出有意义的对象描述。这些自然的行为是如何实现的呢？

答案就是魔术方法（Magic Methods），也称为特殊方法或双下方法（Dunder Methods）。这些方法以双下划线开头和结尾（如__init__），它们让我们的自定义对象能够像内置类型一样自然地与Python语言特性交互。

在本节中，我们将深入探讨三个最常用的魔术方法：__str__、__len__和__iter__，并通过银行账户管理系统的实战示例展示它们的强大威力。

---

第一部分：__str__ 和 __repr__ —— 对象的字符串表示

1.1 为什么需要字符串表示？

当我们创建一个自定义对象并尝试打印它时，默认的输出可能不太友好：

class BankAccount:
    def __init__(self, account_holder, balance=0):
        self.account_holder = account_holder
        self.balance = balance

account = BankAccount("Alice", 1000)
print(account)  # 输出: <__main__.BankAccount object at 0x7f8c1d3e7d00>

这种默认表示只告诉我们对象的类和内存地址，对于调试和日志记录几乎没有帮助。我们需要一种方式来提供更有意义的字符串表示。

1.2 __str__ 与 __repr__ 的区别

Python提供了两个魔术方法来控制对象的字符串表示：

• __str__：返回对象的"非正式"或可读性好的字符串表示，主要用于显示给最终用户
• __repr__：返回对象的"正式"字符串表示，通常是一个有效的Python表达式，可以用于重新创建该对象

class BankAccount:
    def __init__(self, account_holder, balance=0, account_id=None):
        self.account_holder = account_holder
        self.balance = balance
        self.account_id = account_id or f"ACC{random.randint(100000, 999999)}"
    
    def __str__(self):
        return f"账户 {self.account_id} - {self.account_holder}: ${self.balance:.2f}"
    
    def __repr__(self):
        return f"BankAccount('{self.account_holder}', {self.balance}, '{self.account_id}')"

# 使用示例
account = BankAccount("Alice", 1000)
print(str(account))   # 输出: 账户 ACC123456 - Alice: $1000.00
print(repr(account))  # 输出: BankAccount('Alice', 1000, 'ACC123456')

1.3 最佳实践

• 总是实现__repr__，因为它是最低要求（当__str__未定义时，会回退到使用__repr__）
• __repr__应该尽可能返回一个能重新创建对象的表达式
• __str__应该提供对人类友好的输出
• 在交互式环境中输入变量名时，会调用__repr__

---

第二部分：__len__ —— 定义对象的长度

2.1 为什么需要定义长度？

len()是Python中最常用的内置函数之一，它可以用于列表、字典、字符串等内置类型。通过实现__len__方法，我们可以让自定义对象也支持这个操作。

2.2 实现__len__方法

在我们的银行账户示例中，可以有多种方式定义"长度"：

class BankAccount:
    def __init__(self, account_holder, balance=0):
        self.account_holder = account_holder
        self.balance = balance
        self.transactions = []  # 交易记录列表
        
    def deposit(self, amount):
        self.balance += amount
        self.transactions.append(('deposit', amount))
        
    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
            self.transactions.append(('withdraw', amount))
            return True
        return False
    
    def __len__(self):
        # 定义账户的"长度"为交易次数
        return len(self.transactions)
    
    def __str__(self):
        return f"{self.account_holder}'s Account: ${self.balance:.2f}"

# 使用示例
account = BankAccount("Bob", 500)
account.deposit(200)
account.withdraw(100)
account.deposit(50)

print(len(account))  # 输出: 3 (因为有3笔交易)

2.3 更复杂的长度计算

我们还可以实现更复杂的长度概念，比如基于账户活动：

def __len__(self):
    # 综合考虑交易次数和余额
    base_length = len(self.transactions)
    if self.balance > 1000:
        # 高余额账户有更大的"长度权重"
        return base_length + 1
    return base_length

---

第三部分：__iter__ 和 __next__ —— 使对象可迭代

3.1 迭代协议

Python的for循环依赖于迭代协议。任何实现了__iter__方法的对象都是可迭代的。__iter__方法应该返回一个迭代器对象，该对象实现了__next__方法。

3.2 实现迭代器

有两种方式使对象可迭代：

1. 同时实现__iter__和__next__（对象自身就是迭代器）
2. 只实现__iter__，返回一个单独的迭代器对象

class BankAccount:
    def __init__(self, account_holder, balance=0):
        self.account_holder = account_holder
        self.balance = balance
        self.transactions = []
        self._interest_rate = 0.03
        
    # ... 其他方法 ...
    
    def __iter__(self):
        # 返回一个迭代器，用于遍历交易记录
        return iter(self.transactions)
    
    def transaction_details(self):
        """生成器函数，返回交易的详细信息"""
        for transaction in self.transactions:
            action, amount = transaction
            if action == 'deposit':
                yield f"存入: ${amount:.2f}"
            else:
                yield f"取出: ${amount:.2f}"

# 使用示例
account = BankAccount("Charlie", 1000)
account.deposit(200)
account.withdraw(50)
account.deposit(300)

# 使用for循环遍历交易
print("交易记录:")
for transaction in account:
    print(f"  {transaction}")

# 使用生成器获取详细交易信息
print("\n详细交易记录:")
for detail in account.transaction_details():
    print(f"  {detail}")

3.3 实现完整的迭代器协议

如果想让对象自身成为迭代器，需要同时实现__iter__和__next__：

class TransactionIterator:
    """交易记录迭代器"""
    def __init__(self, transactions):
        self._transactions = transactions
        self._index = 0
        
    def __iter__(self):
        return self
        
    def __next__(self):
        if self._index < len(self._transactions):
            result = self._transactions[self._index]
            self._index += 1
            return result
        raise StopIteration

class BankAccount:
    # ... 其他代码不变 ...
    
    def __iter__(self):
        # 返回一个专门的迭代器对象
        return TransactionIterator(self.transactions)

---

第四部分：其他常用魔术方法

除了上述三个方法，Python还提供了许多其他有用的魔术方法：

4.1 比较运算符

class BankAccount:
    # ... 其他代码 ...
    
    def __eq__(self, other):
        """定义 == 操作符的行为"""
        if isinstance(other, BankAccount):
            return self.balance == other.balance
        return NotImplemented
    
    def __lt__(self, other):
        """定义 < 操作符的行为"""
        if isinstance(other, BankAccount):
            return self.balance < other.balance
        return NotImplemented
    
    def __gt__(self, other):
        """定义 > 操作符的行为"""
        if isinstance(other, BankAccount):
            return self.balance > other.balance
        return NotImplemented

4.2 算术运算符

class BankAccount:
    # ... 其他代码 ...
    
    def __add__(self, other):
        """定义 + 操作符的行为"""
        if isinstance(other, (int, float)):
            new_balance = self.balance + other
            return BankAccount(self.account_holder, new_balance)
        return NotImplemented

4.3 属性访问

class BankAccount:
    # ... 其他代码 ...
    
    def __getattr__(self, name):
        """访问不存在的属性时调用"""
        if name == 'balance_in_euros':
            return self.balance * 0.85  # 假设汇率是0.85
        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
    
    def __setattr__(self, name, value):
        """设置属性时调用"""
        if name == 'balance' and value < 0:
            raise ValueError("余额不能为负数")
        super().__setattr__(name, value)

---

第五部分：综合实战 —— 增强银行账户系统

现在，让我们将所有魔术方法整合到一个完整的银行账户系统中：

import random
from datetime import datetime

class BankAccount:
    """银行账户类，实现了多种魔术方法"""
    
    # 类属性
    total_accounts = 0
    _next_id = 1000
    
    def __init__(self, account_holder, initial_balance=0):
        # 输入验证
        if not isinstance(account_holder, str) or not account_holder.strip():
            raise ValueError("账户持有人必须是非空字符串")
        if initial_balance < 0:
            raise ValueError("初始余额不能为负数")
            
        # 属性初始化
        self._account_holder = account_holder
        self._balance = initial_balance
        self._account_id = self._generate_account_id()
        self._created_date = datetime.now()
        self._transactions = []
        
        BankAccount.total_accounts += 1
        
    def _generate_account_id(self):
        account_id = BankAccount._next_id
        BankAccount._next_id += 1
        return f"ACC{account_id}"
        
    # 属性访问器
    @property
    def account_holder(self):
        return self._account_holder
        
    @property
    def balance(self):
        return self._balance
        
    @property
    def account_id(self):
        return self._account_id
        
    @property
    def created_date(self):
        return self._created_date
        
    # 业务方法
    def deposit(self, amount, description="存款"):
        if amount <= 0:
            raise ValueError("存款金额必须为正数")
            
        self._balance += amount
        self._record_transaction(amount, description)
        return True
        
    def withdraw(self, amount, description="取款"):
        if amount <= 0:
            raise ValueError("取款金额必须为正数")
        if amount > self._balance:
            return False
            
        self._balance -= amount
        self._record_transaction(-amount, description)
        return True
        
    def _record_transaction(self, amount, description):
        transaction = {
            "date": datetime.now(),
            "amount": amount,
            "description": description,
            "balance_after": self._balance
        }
        self._transactions.append(transaction)
        
    # 魔术方法
    def __str__(self):
        return f"账户 {self._account_id} - {self._account_holder}: ${self._balance:.2f}"
    
    def __repr__(self):
        return f"BankAccount('{self._account_holder}', {self._balance}, '{self._account_id}')"
    
    def __len__(self):
        return len(self._transactions)
    
    def __iter__(self):
        return iter(self._transactions)
    
    def __getitem__(self, index):
        """支持索引访问交易记录"""
        return self._transactions[index]
    
    def __contains__(self, amount):
        """支持in操作符检查是否有特定金额的交易"""
        return any(t['amount'] == amount for t in self._transactions)
    
    def __eq__(self, other):
        """比较两个账户的余额是否相等"""
        if isinstance(other, BankAccount):
            return self._balance == other._balance
        return NotImplemented
    
    def __lt__(self, other):
        """比较两个账户的余额大小"""
        if isinstance(other, BankAccount):
            return self._balance < other._balance
        return NotImplemented
    
    def __add__(self, other):
        """支持账户余额相加"""
        if isinstance(other, (int, float)):
            return self._balance + other
        elif isinstance(other, BankAccount):
            return self._balance + other._balance
        return NotImplemented
    
    def __radd__(self, other):
        """支持右加（其他类型 + 账户）"""
        return self.__add__(other)
    
    def __bool__(self):
        """账户的布尔值（是否有余额）"""
        return self._balance > 0
    
    # 上下文管理器方法（为后续章节做准备）
    def __enter__(self):
        """进入上下文时调用"""
        print(f"开始处理账户 {self._account_id}")
        return self
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        """退出上下文时调用"""
        print(f"完成处理账户 {self._account_id}")
        if exc_type is not None:
            print(f"处理过程中发生错误: {exc_val}")
        return False  # 不抑制异常

# 演示使用
if __name__ == "__main__":
    # 创建账户
    account1 = BankAccount("Alice", 1000)
    account2 = BankAccount("Bob", 500)
    
    # 进行交易
    account1.deposit(200, "工资")
    account1.withdraw(150, "房租")
    account2.deposit(300, "兼职收入")
    
    # 测试魔术方法
    print(account1)  # 调用 __str__
    print(repr(account1))  # 调用 __repr__
    
    print(f"交易次数: {len(account1)}")  # 调用 __len__
    
    print("\n交易记录:")
    for transaction in account1:  # 调用 __iter__
        print(f"  {transaction['date'].strftime('%Y-%m-%d')}: {transaction['description']} ${transaction['amount']:.2f}")
    
    print(f"\n第一笔交易: {account1[0]}")  # 调用 __getitem__
    print(f"是否有金额为200的交易: {200 in account1}")  # 调用 __contains__
    
    print(f"\n账户比较: account1 > account2 = {account1 > account2}")  # 调用 __lt__
    print(f"账户相加: account1 + account2 = {account1 + account2}")  # 调用 __add__
    print(f"右加: 100 + account1 = {100 + account1}")  # 调用 __radd__
    
    print(f"\n账户布尔值: {bool(account1)}")  # 调用 __bool__
    
    # 使用上下文管理器
    print("\n使用上下文管理器:")
    with BankAccount("Charlie", 800) as account3:
        account3.deposit(100, "测试存款")
        print(f"新余额: ${account3.balance:.2f}")

输出结果：

账户 ACC1000 - Alice: $1050.00
BankAccount('Alice', 1050, 'ACC1000')
交易次数: 2

交易记录:
  2023-07-15: 工资 $200.00
  2023-07-15: 房租 $-150.00

第一笔交易: {'date': datetime.datetime(2023, 7, 15, 12, 34, 56, 789000), 'amount': 200, 'description': '工资', 'balance_after': 1200}
是否有金额为200的交易: True

账户比较: account1 > account2 = True
账户相加: account1 + account2 = 1550
右加: 100 + account1 = 1150

账户布尔值: True

使用上下文管理器:
开始处理账户 ACC1002
新余额: $900.00
完成处理账户 ACC1002

---

第六部分：常见面试题深度解析

1. Q：__str__和__repr__有什么区别？应该优先实现哪一个？
   A：__str__用于用户友好的输出，__repr__用于开发者调试和重新创建对象。应该优先实现__repr__，因为当__str__未定义时，Python会使用__repr__作为备选。

2. Q：如何使自定义对象支持with语句？
   A：需要实现__enter__和__exit__方法。__enter__在进入上下文时调用，返回一个对象（通常是self）；__exit__在退出上下文时调用，负责清理资源。

3. Q：__getitem__和__iter__有什么关系？
   A：__getitem__使对象支持索引访问，__iter__使对象可迭代。如果只实现了__getitem__，Python可以自动使对象成为可迭代的（从索引0开始，直到IndexError）。

4. Q：什么时候应该使用魔术方法？
   A：当希望自定义对象的行为更像内置类型，或者希望提供更自然的API时，应该使用魔术方法。但要避免过度使用，只有在确实能提高代码可读性和可用性时才使用。

---

结语与思考

魔术方法是Python面向对象编程中非常强大和灵活的特性。通过实现这些方法，我们可以让自定义对象的行为与内置类型一样自然，大大提高了代码的可读性和可用性。

在本节中，我们重点学习了__str__、__len__和__iter__这三个最常用的魔术方法，并通过银行账户系统的实战示例展示了它们的应用。我们还简要介绍了其他有用的魔术方法，如比较运算符、算术运算符和属性访问控制。

思考题：

1. 如果我们要实现一个银行账户的切片操作（例如获取最近N条交易记录），应该如何实现？
2. 如何实现__call__方法，使银行账户对象可以像函数一样被调用？
3. 如果希望账户对象支持Pickle序列化，需要实现哪些魔术方法？