第 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__:__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__变得合理又有趣。你的类,从'死数据'变成'活角色'了——这就是魔法方法的威力。"
【皮皮小课堂】本章要点
- 魔法方法 = 双下划线包起来、Python 自动调用的方法,给对象"接入"内置语法。
__init__:创建时初始化。__str__:print(obj)时,打印出友好文字(替代内存地址)。__len__:让len(obj)可用(必须返回非负整数)。__eq__:自定义==,比内容不比地址。__add__:运算符重载,让对象能用+相加(返回新对象)。__del__:销毁前清理(了解即可,别依赖它)。- 思路:想让对象支持什么语法,就实现对应的魔法方法。
【翻车现场】本章的坑
坑 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) 想打印出好看的文字,应该实现哪个魔法方法?
- A.
__init__ - B.
__str__ - C.
__add__ - D.
__del__
2. (★) obj1 == obj2 会触发哪个魔法方法?
- A.
__eq__ - B.
__add__ - C.
__len__ - D.
__str__
3. (★★) 类定义了 __len__,它的返回值应该是什么类型?
- A. 字符串
- B. 整数
- C. 列表
- D. 任意类型
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)
- A.
(1, 2) - B.
(3, 4) - C.
(4, 6) - D. 报错
5. (★★ 多选) 关于魔法方法,下列说法正确的是?
- A. 魔法方法由 Python 自动调用,不需要手动调用
- B. 定义
__add__可以让对象用+运算 - C. 魔法方法名拼错时,Python 会直接报错提示
- D.
__str__和__repr__都影响对象的"显示"
二、判断题
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 章把面向对象三件套(类与对象、继承多态封装、魔法方法)学完了。下一部分,我们冲上高阶:迭代器、装饰器、正则……然后就是毕业项目!"
📖 下一部分,进阶修炼:迭代器与生成器。