面向对象 · 代码界的角色扮演

第25章 活起来的咒语

魔法方法

第 25 章 活起来的咒语:魔法方法

📖 本章目标:认识"魔法方法",学会让对象支持打印美化、相加、比较等"超能力"。
学完本章,你的对象会"活"起来——像内置类型一样能打印、能加、能比大小。
上一章你造了一个"家族"。这一章,给你的家族成员念几段咒语,让他们获得和 int、str 一样的"超能力":能打印得像样、能相加、能比较。


【开场小剧场】打印出一堆地址

学生: 皮皮,我 print(acc) 打印账户对象,结果出来一堆 <__main__.Account object at 0x000002...>,谁看得懂啊!

皮皮: 哈哈,那是电脑在说"这个对象在内存的某处",但人看不懂。想要 print 打得漂漂亮亮?得给类念一段咒语。

学生: 咒语?

皮皮: 就是魔法方法——名字带双下划线、由 Python 自动调用的特殊方法。今天教你几段最实用的咒语。

学生: 学完能不能让我的类跟数字一样相加?

皮皮: (眼睛一亮)能!那就是 __add__,今天压轴教你这个——让对象"活"到可以参与运算。


25.1 魔法方法是什么:Python 自动念的咒语

魔法方法(magic methods) = 双下划线包起来的方法(如 __str__、__init__),不需要你调用,Python 会在特定时刻自动调用。

你已经见过一个:__init__——造对象时自动执行。今天再加几个:

魔法方法 什么时候自动调用
__init__ 创建对象时
__str__ print(obj)、str(obj) 时
__repr__ 交互模式直接敲 obj、repr(obj) 时
__len__ len(obj) 时
__eq__ obj1 == obj2 时
__add__ obj1 + obj2 时
__del__ 对象被销毁前

核心思想:魔法方法 = 给对象"接入" Python 内置语法。 定义了 __len__,你的对象就能被 len() 算长度;定义了 __add__,就能用 +。

逐行拆解这张表怎么用:
- 想让它能被 print 打印好看 → 实现 __str__;
- 想让它能被 len() 算长度 → 实现 __len__;
- 想让它能用 == 比大小 → 实现 __eq__;
- "想让对象支持什么语法,就实现对应的魔法方法"——这是本章唯一的"心法"。

🐍"皮皮注:魔法方法也叫双下划线方法(dunder methods,double underscore 的简称)。别被这名字吓到——它不神秘,就是一张'内置语法接入表'。你需要哪个语法,就填哪一格。"


25.2 str:打印变得好看

class Account:
    def __init__(self, holder, balance):
        self.holder = holder
        self._balance = balance

    def __str__(self):
        return f"账户:{self.holder}  余额:{self._balance}"

acc = Account("小明", 150)
print(acc)    # 账户:小明  余额:150(而不是那一堆地址!)

逐行拆解:
- def __str__(self)::魔法方法,print(obj) 时自动调用;
- return f"账户:{self.holder} 余额:{self._balance}":返回一个字符串——注意必须 return 字符串,不能 print;
- print(acc):Python 自动调 acc.__str__(),拿返回值打印。

没写 __str__ 时,print(acc) 是内存地址;写了之后,是你要的句子。 这就是最常用的咒语。

换例加深:str 里拼多行

class Account:
    def __init__(self, holder, balance):
        self.holder = holder
        self._balance = balance

    def __str__(self):
        return (f"===== 账户信息 =====\n"
                f"户主:{self.holder}\n"
                f"余额:{self._balance}")

acc = Account("小明", 150)
print(acc)
# ===== 账户信息 =====
# 户主:小明
# 余额:150

__str__ 里想打几行都行,只要 return 的是完整字符串(用第 5 章的 \n 换行)。

💡 顺带一提 __repr__:print 优先用 __str__;在交互模式直接敲 acc 回车,或用 repr(acc),优先用 __repr__。开发调试友好用 __repr__,给人看的用 __str__。 新手记住 __str__ 就够。

易错提醒: __str__ 里别写 print。它要 return 一个字符串交给 print(obj) 去打印。写成 print(...) 会导致 print(acc) 打印 None。


25.3 len:让对象能"数长度"

class ShoppingCart:
    def __init__(self):
        self.items = []

    def add(self, item):
        self.items.append(item)

    def __len__(self):
        return len(self.items)      # 返回"购物车里有几件商品"

cart = ShoppingCart()
cart.add("苹果")
cart.add("牛奶")
print(len(cart))    # 2

逐行拆解:
- def __len__(self)::len(cart) 时自动调用;
- return len(self.items):返回购物车里的商品数量;
- print(len(cart)):Python 调 cart.__len__(),得到 2。

定义了 __len__,len(cart) 就能用——哪怕 cart 本身不是列表。

换例加深:len 里可以玩花样

class ShoppingCart:
    def __init__(self):
        self.items = []

    def add(self, item):
        self.items.append(item)

    def __len__(self):
        return len(set(self.items))     # 只算不重复的商品种类

cart = ShoppingCart()
cart.add("苹果")
cart.add("苹果")
cart.add("牛奶")
print(len(cart))    # 2(苹果算一种,牛奶算一种)

__len__ 返回什么由你定义——数量、种类数、长度,都行,只要是个整数。

💡 len() 对结果有要求:必须是非负整数。返回字符串或负数会报 TypeError。想清楚"这个对象的长是什么"再写。


25.4 eq:自定义"相等"

默认情况下,两个对象比较 == 比的是内存地址(是不是同一个对象),两个内容相同的对象也不相等:

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

p1 = Point(1, 2)
p2 = Point(1, 2)
print(p1 == p2)    # False(默认比地址,两个不同的对象)

想让"坐标相同就算相等",用 __eq__:

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

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

p1 = Point(1, 2)
p2 = Point(1, 2)
print(p1 == p2)    # True!(现在比坐标,不比地址)

逐行拆解:
- def __eq__(self, other)::p1 == p2 时,Python 调 p1.__eq__(p2),self = p1、other = p2;
- return self.x == other.x and self.y == other.y:两边坐标都相等才算相等;
- 于是 p1 == p2 → True。

__eq__(self, other) 里的 other 是"和自己比的那个人"。 返回 True/False。

换例加深:eq 里防类型混乱

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

    def __eq__(self, other):
        if not isinstance(other, Point):     # 不是 Point,直接不相等
            return False
        return self.x == other.x and self.y == other.y

p = Point(1, 2)
print(p == 5)          # False(不会崩)
print(p == Point(1, 2))  # True

没有类型判断时,p == 5 会尝试 5.x,直接 AttributeError。 加上 isinstance 判断就稳了(翻车现场坑 2)。


25.5 add:运算符重载,让对象能相加

运算符重载(operator overloading):给 + - * == 这些运算符定义"自己类型怎么算"。Python 最酷的魔法之一。

向量类,+ 表示对应坐标相加:

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

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

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

v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2            # 触发了 __add__!
print(v3)               # (4, 6)

逐行拆解:
- def __add__(self, other)::v1 + v2 时自动调用,self = v1、other = v2;
- return Vector(self.x + other.x, self.y + other.y):返回一个新的 Vector,坐标相加;
- v3 = v1 + v2:v3 就是那个新向量 (4, 6);
- print(v3):__str__ 生效,打印 (4, 6)。

看到魔法了吗?v1 + v2 不是报错,而是 Python 去调用 v1.__add__(v2),返回一个新向量 (4, 6)。 这就是让自定义类型"内置类型化"——和 int、str 一样能运算。

换例加深:多个向量连加

v1 = Vector(1, 1)
v2 = Vector(2, 2)
v3 = Vector(3, 3)
result = v1 + v2 + v3      # 从左往右:(v1+v2)+v3
print(result)              # (6, 6)

+ 从左往右计算,每加一次调一次 __add__——和数字连加是一个道理。

配套代码文件:code/ch25/vector.py。

🐍"皮皮注:这就是'运算符重载'——不是改 Python 的 +,而是给你的类型定义'遇到 + 该怎么算'。从此你的对象不只是数据,它会运算了。帅吧?"


25.6 del:最后告别时(了解即可)

__del__ 在对象即将被销毁时调用,常用于"清理":

class FileWrapper:
    def __init__(self, name):
        self.name = name
        print(f"打开文件 {name}")

    def __del__(self):
        print(f"关闭文件 {self.name}")

f = FileWrapper("data.txt")
print("工作中...")
# 程序结束时,对象被销毁,__del__ 被调用

输出:

打开文件 data.txt
工作中...
关闭文件 data.txt

逐行拆解:
- __init__:创建时打印"打开文件";
- __del__:销毁前打印"关闭文件";
- 程序运行到最后,f 这个对象没了,__del__ 自动执行。

🐍"皮皮注:__del__ 的调用时机依赖垃圾回收,不保证马上执行,别把重要清理指望它。文件该关还是用 with(第 19 章)。这里了解有这回事就行。"


25.7 综合:花式打印的账户

把 __str__、__eq__、__add__ 组合起来,账户类瞬间"高级":

class Account:
    def __init__(self, holder, balance=0):
        self.holder = holder
        self._balance = balance

    def __str__(self):
        return f"账户[{self.holder}]:{self._balance}元"

    def __add__(self, other):
        """两个账户合并(比如家庭共同账户)"""
        return Account(self.holder + "+" + other.holder,
                       self._balance + other._balance)

    def __eq__(self, other):
        return self._balance == other._balance

a1 = Account("小明", 100)
a2 = Account("小红", 100)
print(a1)               # 账户[小明]:100元
print(a1 == a2)         # True(余额相同)
merged = a1 + a2
print(merged)           # 账户[小明+小红]:200元

逐行拆解:
- __str__:打印好看;
- __eq__:比余额,不比地址——两个余额 100 的账户相等;
- __add__:两个账户"合并"成一个新账户,户主拼起来、余额加起来。

是不是感觉像在"发明新的数字"? 这正是魔法方法的魅力——让程序里的对象,拥有和数学概念一样自然的行为。

配套代码文件:code/ch25/pretty_account.py。

🐍"皮皮注:看到没,a1 + a2 这种本来'应该报错'的运算,因为 __add__ 变得合理又有趣。你的类,从'死数据'变成'活角色'了——这就是魔法方法的威力。"


【皮皮小课堂】本章要点


【翻车现场】本章的坑

坑 1:忘写 str,打印出一堆地址

print(acc)   # <__main__.Account object at 0x0000024...>

这是最常见的"诡异现象"之一。 原因:类没定义 __str__,print 只能打内存地址。想在 print 里看到正常内容,必须写 __str__。

坑 2:eq 忘了考虑 other 类型

def __eq__(self, other):
    return self.x == other.x     # 如果 other 不是 Point,会 AttributeError!

p == 5 时 5.x 直接崩。先判断类型再比:

def __eq__(self, other):
    if not isinstance(other, Point):
        return False
    return self.x == other.x and self.y == other.y

坑 3:魔法方法名拼错,静默失效

def __str__():      # 对了,但写在类外,没生效
    ...
# 或
def __StR__(self):  # 大小写错了,Python 不认,静默失效
    ...

魔法方法名拼错不报错,只是不生效——最坑。写错 __str__,print 还是内存地址,还查不出原因。检查魔法方法时,先核对名字:双下划线 + 全小写。

坑 4:add 忘了返回新对象

def __add__(self, other):
    self.x += other.x      # ❌ 直接改了 self,而不是返回新对象
    self.y += other.y
    return self

v1 + v2 把 v1 自己改坏了。+ 应该是"算个新的",原对象不该变。 正确:创建一个新实例返回。

坑 5:str 里写了 print

class Vector:
    def __str__(self):
        print(f"({self.x}, {self.y})")   # ❌ 应该是 return,不是 print!

print(v) 会打印一次 (1,2) 然后再打印一个 None——因为 __str__ 要 return 字符串,你却让它 print。__str__ 永远 return,绝不 print。

坑 6:len 返回非整数

def __len__(self):
    return len(str(self.items)) + "个"    # ❌ 字符串!len() 要整数

len(obj) 要求 __len__ 返回非负整数。返回字符串会报 TypeError: 'str' object cannot be interpreted as an integer。数长度,就是数个数,返回整数。


【本章习题】

一、选择题

1. (★) print(obj) 想打印出好看的文字,应该实现哪个魔法方法?

2. (★) obj1 == obj2 会触发哪个魔法方法?

3. (★★) 类定义了 __len__,它的返回值应该是什么类型?

4. (★★) 下面代码,print(v1 + v2) 的输出是?

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    def __str__(self):
        return f"({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)

5. (★★ 多选) 关于魔法方法,下列说法正确的是?

二、判断题

1. (★) 不写 __str__,print(对象) 会打印内存地址。( )

2. (★★) __add__ 应该返回一个新对象,而不是修改原来的对象。( )

3. (★★) __del__ 保证在对象销毁时立刻执行。( )

4. (★★) __str__ 方法里应该用 print 输出,而不是 return 返回。( )

三、代码纠错题

1. (★★) 下面代码 print(v) 想打印 (1, 2),但打印出一堆地址,请改正:

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

v = Vector(1, 2)
print(v)

2. (★★) 下面代码想比较两个分数是否相等,但 f1 == f2 结果不对,请指出原因并改正:

class Fraction:
    def __init__(self, num, den):
        self.num = num
        self.den = den

f1 = Fraction(1, 2)
f2 = Fraction(2, 4)
print(f1 == f2)     # 期望 True(1/2 == 2/4),实际 False

四、编程实战题

1. (基础 ★) 定义一个 Book 类(书名、作者),实现 __str__ 让它打印 《书名》- 作者。

2. (基础 ★★) 定义一个 Duration(时长)类,有属性 minutes,实现 __add__ 让两个时长相加返回新 Duration,实现 __str__ 打印 X小时Y分。测试 d1 + d2。

3. (基础 ★★) 定义一个 Temperature(温度)类,有属性 celsius,实现 __str__ 打印 X°C,实现 __eq__(摄氏温度相同则相等),实现 __add__(两温度相加返回新 Temperature)。测试一下。

4. (挑战 ★★★) 实现一个简化版 Fraction(分数)类:属性 numerator(分子)、denominator(分母);实现 __str__ 打印 分子/分母;实现 __add__ 让两个分数相加,结果为 分子=分子交叉相乘求和,分母=两分母相乘(先不约分);再实现 __eq__ 判断两个分数是否相等(提示:交叉相乘判断)。



【参考答案与解析】

一、选择题

1. 答案:B
print(obj) 会调用 __str__,定义它就能打印出友好内容。

2. 答案:A
== 触发 __eq__(self, other)。

3. 答案:B
len() 需要整数结果,__len__ 应返回整数(否则报 TypeError)。

4. 答案:C
v1 + v2 触发 v1.__add__(v2),返回 Vector(1+3, 2+4) = Vector(4, 6);__str__ 打印 (4, 6)。

5. 答案:A、B、D
A 对:自动调用;B 对:__add__ 重载 +;C 错:拼错魔法方法名不报错、只是不生效(最坑);D 对:都影响显示。

二、判断题

1. 正确(√)。没有 __str__,print 打印对象的内存地址。

2. 正确(√)。+ 应该返回新对象,原对象不变。

3. 错误(×)。__del__ 依赖垃圾回收,不保证立刻执行,重要清理别依赖它。

4. 错误(×)。__str__ 必须 return 一个字符串,由 print(obj) 去打印;在里面 print 会导致 print(obj) 输出 None。

三、代码纠错题

1. 解析: 类没定义 __str__,print(v) 打的是内存地址。改正:加一个 __str__:

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

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

v = Vector(1, 2)
print(v)    # (1, 2)

2. 解析: 没写 __eq__,默认按内存地址比较,两个不同对象永远不相等。改正:实现 __eq__,用交叉相乘判断:

class Fraction:
    def __init__(self, num, den):
        self.num = num
        self.den = den

    def __eq__(self, other):
        return self.num * other.den == self.den * other.num

f1 = Fraction(1, 2)
f2 = Fraction(2, 4)
print(f1 == f2)     # True(1*4 == 2*2)

为什么交叉相乘? 1/2 == 2/4 ⇔ 1×4 == 2×2,两边都等于 4——分母交叉相乘相等,分数就相等。这是数学里的经典技巧,拿来当 __eq__ 的判断条件正合适。

四、编程实战题

1. 参考代码:

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

    def __str__(self):
        return f"《{self.title}》- {self.author}"

b = Book("Python魔法入门指南", "皮皮")
print(b)    # 《Python魔法入门指南》- 皮皮

2. 参考代码:

class Duration:
    def __init__(self, minutes):
        self.minutes = minutes

    def __add__(self, other):
        return Duration(self.minutes + other.minutes)

    def __str__(self):
        h = self.minutes // 60
        m = self.minutes % 60
        return f"{h}小时{m}分"

d1 = Duration(90)
d2 = Duration(45)
d3 = d1 + d2
print(d3)    # 2小时15分

3. 参考代码:

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    def __str__(self):
        return f"{self.celsius}°C"

    def __eq__(self, other):
        return self.celsius == other.celsius

    def __add__(self, other):
        return Temperature(self.celsius + other.celsius)

t1 = Temperature(25)
t2 = Temperature(25)
t3 = Temperature(10)
print(t1)                  # 25°C
print(t1 == t2)            # True
print(t1 + t3)             # 35°C

4. 参考代码:

class Fraction:
    def __init__(self, numerator, denominator):
        if denominator == 0:
            raise ValueError("分母不能为 0!")
        self.numerator = numerator
        self.denominator = denominator

    def __str__(self):
        return f"{self.numerator}/{self.denominator}"

    def __add__(self, other):
        # 分子交叉相乘求和,分母相乘
        num = self.numerator * other.denominator + other.numerator * self.denominator
        den = self.denominator * other.denominator
        return Fraction(num, den)

    def __eq__(self, other):
        # 交叉相乘相等,则分数相等
        return (self.numerator * other.denominator
                == self.denominator * other.numerator)

a = Fraction(1, 2)     # 1/2
b = Fraction(1, 3)     # 1/3
print(a + b)           # 5/6
print(Fraction(1, 2) == Fraction(2, 4))   # True(交叉相乘:1*4 == 2*2)

🐍"皮皮注:到这一章,你已经给对象加了'打印咒语'、'相加咒语'、'比较咒语'——你的类型和 int、str 一样'活'了。休息一下!第 23~25 章把面向对象三件套(类与对象、继承多态封装、魔法方法)学完了。下一部分,我们冲上高阶:迭代器、装饰器、正则……然后就是毕业项目!"


📖 下一部分,进阶修炼:迭代器与生成器。

📦 本章配套代码

运行方式:命令行进入目录后执行 py 文件名.py(Windows)或 python3 文件名.py(Mac/Linux)