第 23 章 说明书与商品:类与对象
📖 本章目标:理解"类"和"对象",学会用 class 定义自己的类型。
学完本章,你的程序就不再只是"按部就班的流水线",而是一个能"创造角色"的世界。
从本章开始,你从"写流程的人"升级成"设计世界的人"。前面学的都是"怎么做一件事",现在开始学"造一个东西"。
【开场小剧场】商品说明书
学生: 皮皮,我越来越觉得程序像个流水线,一条路走到黑。
皮皮: 因为前面的章节都是面向过程——关心"怎么做"。今天换个大招:面向对象——关心"世界里有谁"。
学生: 有谁?
皮皮: 就拿冰箱举例。海尔有一张"冰箱设计图",照着这张图,能造出一万台冰箱。设计图 = 类(class),造出来的每一台真冰箱 = 对象(对象,也叫实例)。今天,我们就来当"设计图纸"的人。
学生: 那我先画狗还是先画猫?
皮皮: (笑)随你,但你得想清楚狗都有什么、狗会干什么——这就是设计类的思路:先列属性,再列方法。
23.1 类 vs 对象:图纸 vs 商品
类(class):一张"商品说明书/设计图",描述这一类东西长什么样、能干什么。
对象(instance/对象):照着图纸造出来的具体一个。
| 类(设计图) | 对象(真商品) | |
|---|---|---|
| 好比 | 狗狗的品种说明 | 楼下那只叫"旺财"的狗 |
| 有几个 | 只有一个 | 可以有无数个 |
| 谁在画 | 程序员(你) | 程序运行时自动"造" |
用代码说话:
class Dog:
"""狗的说明书"""
pass
# 照着图纸造出两只狗
dog1 = Dog() # 对象 1
dog2 = Dog() # 对象 2
print(dog1) # <__main__.Dog object at 0x...>
print(dog2)
输出(地址每次不同):
<__main__.Dog object at 0x000001F6...>
<__main__.Dog object at 0x000001F6...>
逐行拆解:
- class Dog::定义类(设计图),行末有冒号,下面的内容要缩进;
- """狗的说明书""":docstring,描述这个类(第 15 章学的);
- pass:先空着,占个位置;
- dog1 = Dog():造第一只狗——Dog() 就是"照着图纸造一台";
- print(dog1):打印出来是 Dog object at 0x...——0x... 是它在内存里的门牌号(地址)。
两个对象的地址不同——它们是两只不同的狗,互不干扰。
🐍"皮皮注:看到
0x000...那个地址没?每次运行地址都变,别背它。你只需要记住:地址不同 = 是两个不同的对象。"
易错提醒: dog1 = Dog(不带括号)是把"类本身"塞给 dog1,不会造对象;dog1 = Dog()(带括号)才是造对象。和调用函数一个道理——要运行,必带括号。
23.2 init 构造方法:造出来时先"初始化"
空狗没意思。我们希望造狗的时候,顺便给它起名字。这个"造出来时自动执行"的特殊方法,叫 __init__(init = initialize,初始化):
class Dog:
def __init__(self, name):
self.name = name # 把名字挂到这只狗身上
dog = Dog("旺财")
print(dog.name) # 旺财
逐行拆解:
- def __init__(self, name)::构造方法,接收 name;
- self.name = name:把传进来的名字存到对象自己身上;
- dog = Dog("旺财"):造狗,自动把 "旺财" 传给 __init__;
- print(dog.name):从对象身上取名字。
看到神奇的地方了吗? 调用时写 Dog("旺财"),没写 __init__ 却触发了它——这是 Python 的魔法:Dog(...) 会自动调用 __init__,并把你传的参数送进去。
换例加深:给构造方法配默认参数
class Dog:
def __init__(self, name, age=0):
self.name = name
self.age = age
dog1 = Dog("旺财") # age 用默认 0
dog2 = Dog("小白", 3) # age = 3
print(dog1.age, dog2.age) # 0 3
第 16 章的默认参数在这里照样能用! 不是每只狗都得有年龄,不给就用默认。
💡
__init__前后的双下划线不是装饰,是有讲究的"魔法方法"名字,Python 认这套。(第 25 章专门讲。)
23.3 self 到底是谁:它自己!
def __init__(self, name) 里的 self 就是"正在造的这只狗自己"。
dog1 = Dog("旺财")执行时,self= dog1;dog2 = Dog("小白")执行时,self= dog2。
self.name = name 的意思是:"把我(这只狗)的名字设为传入的 name"。所以:
dog1 = Dog("旺财")
dog2 = Dog("小白")
print(dog1.name) # 旺财 —— self 是 dog1 时,存到 dog1 上
print(dog2.name) # 小白 —— self 是 dog2 时,存到 dog2 上
逐行拆解:
- dog1 = Dog("旺财"):self 变成 dog1,self.name = "旺财" 存到 dog1 上;
- dog2 = Dog("小白"):self 变成 dog2,存到 dog2 上;
- dog1.name → 旺财,dog2.name → 小白——各存各的,井水不犯河水。
一句话记:self 就是"对象自己"。 调用方法时,Python 会自动把对象塞进 self 的位置,所以方法里访问"自己的属性"都用 self.xxx。
换例加深:方法里的 self 也是它
class Dog:
def __init__(self, name):
self.name = name
def who(self):
print("我是", self.name)
dog = Dog("旺财")
dog.who() # 我是 旺财
who(self) 里的 self 和 __init__ 里的 self 是同一个东西——都是那只狗。方法里想碰自己的属性,一律 self.xxx。
💡
self只是个约定俗成的名字,不是关键字。你写成this、me都能跑。但全世界都写self,你也别搞特殊,免得别人看不懂。
23.4 实例方法:这只狗能干什么
类里不光能存"属性"(名字、年龄),还能定义方法——就是"这类东西能做的事":
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print(f"{self.name}:汪!")
def introduce(self):
print(f"我是{self.name},今年{self.age}岁")
dog = Dog("旺财", 3)
dog.bark() # 旺财:汪!
dog.introduce() # 我是旺财,今年3岁
逐行拆解:
- def bark(self)::定义一个方法,第一个参数是 self;
- 方法体里 self.name、self.age:用对象自己的属性;
- dog.bark():调用。self 自动= dog,不用你传。
注意:定义方法时第一个参数是 self(表示"谁在调用"),调用时不用传。dog.bark() 调用时,Python 自动把 dog 传进 self。
换例加深:方法里调用另一个方法
class Dog:
def __init__(self, name):
self.name = name
def bark(self):
print("汪!")
def speak(self):
print(f"{self.name} 说:", end=" ")
self.bark() # 方法里也能调用自己的其他方法
dog = Dog("旺财")
dog.speak() # 旺财 说: 汪!
方法内部 self.方法名() 就能调用自己的另一个方法——代码不重复,各管一事。
23.5 多个实例,互不干扰
再造一只狗,它有自己的名字和年龄,和旺财井水不犯河水:
dog1 = Dog("旺财", 3)
dog2 = Dog("小白", 1)
print(dog1.name, dog1.age) # 旺财 3
print(dog2.name, dog2.age) # 小白 1
dog1.bark() # 旺财:汪!
dog2.bark() # 小白:汪!
逐行拆解:
- 两个对象,各带各的属性;
- dog1.bark() 里 self = dog1 → 打印"旺财:汪!";
- dog2.bark() 里 self = dog2 → 打印"小白:汪!"。
每个对象自己带一份数据,改 dog1 不影响 dog2。这正是"面向对象"的核心好处:数据和操作数据的代码,打包在一起。
换例加深:先改 dog1,看 dog2 是否被影响
dog1 = Dog("旺财", 3)
dog2 = Dog("小白", 1)
dog1.age = 10 # 只改 dog1
print(dog1.age) # 10
print(dog2.age) # 1,狗没事
改一只狗,另一只毫发无损——这就是"对象各自独立"的直观证明。
配套代码文件:code/ch23/dog.py。
23.6 类变量 vs 实例变量(初体验)
前面 self.xxx 存的叫实例变量(每个对象各有一份)。还有一种类变量,写在类里面、方法外面,所有对象共享一份:
class Dog:
species = "中华田园犬" # 类变量:所有狗共享
def __init__(self, name):
self.name = name # 实例变量:每只狗各自有
dog1 = Dog("旺财")
dog2 = Dog("小白")
print(dog1.species) # 中华田园犬(从类上拿)
print(dog2.species) # 中华田园犬(同一份)
print(dog1.name, dog2.name) # 旺财 小白(各归各的)
逐行拆解:
- species = "中华田园犬":写在类顶层、方法外面 → 类变量;
- self.name = name:写在 __init__ 里、带 self. → 实例变量;
- dog1.species 和 dog2.species:拿到的都是同一份(存在类上);
- dog1.name 和 dog2.name:各是各的。
规律:写在 __init__ 里、带 self. 的是实例变量;写在类顶层的是类变量。 初学者先用实例变量即可,类变量知道存在就行。
换例加深:类变量的经典用法——计数
class Dog:
count = 0 # 记录一共造了几只狗
def __init__(self, name):
self.name = name
Dog.count += 1 # 每造一只,全局计数 +1
a = Dog("旺财")
b = Dog("小白")
c = Dog("豆豆")
print(Dog.count) # 3
所有对象共享 Dog.count,所以能统计"这个类一共造了几个对象"。
💡 记忆口诀: "类变量全村共享,实例变量各归各家。"
23.7 实战:银行账户类
把"商品说明书"的套路用到银行:
class Account:
"""银行账户:能存钱、取钱、查余额"""
def __init__(self, holder, balance=0):
self.holder = holder # 户主
self.balance = balance # 余额
def deposit(self, amount):
"""存款"""
if amount <= 0:
print("金额必须大于 0!")
return
self.balance += amount
print(f"{self.holder} 存入 {amount},余额 {self.balance}")
def withdraw(self, amount):
"""取款(余额不足则拒绝)"""
if amount > self.balance:
print("余额不足!")
return
self.balance -= amount
print(f"{self.holder} 取出 {amount},余额 {self.balance}")
def show(self):
print(f"{self.holder} 的余额:{self.balance}")
使用:
acc = Account("小明", 100)
acc.deposit(50) # 小明 存入 50,余额 150
acc.withdraw(200) # 余额不足!
acc.withdraw(30) # 小明 取出 30,余额 120
acc.show() # 小明 的余额:120
逐行拆解:
- def __init__(self, holder, balance=0)::构造方法,balance 默认 0(默认参数!);
- deposit:先验证金额大于 0,再 self.balance += amount;
- withdraw:先验证余额够不够,再减;
- show:只读余额,不碰数据。
看到了吗? 余额是"私房钱",只有通过 deposit/withdraw 这个"柜台窗口"才能改——数据被方法保护起来,这就是封装的雏形(第 24 章细讲)。
配套代码文件:code/ch23/account.py。
🐍"皮皮注:写完这个类,你已经掌握 OOP 最核心的三板斧:属性(
self.xxx)、方法(带self的函数)、封装(数据只能走方法改)。下一章,再加两招:继承和多态。"
【皮皮小课堂】本章要点
- 类(class) = 设计图/说明书;对象(实例) = 造出来的具体一个。
class Dog:定义类;Dog()造对象。__init__(self, ...):造对象时自动执行的初始化,给对象"装属性"。self= 对象自己;方法里访问自己的属性用self.xxx,调用方法时 self 自动传入、不用写。- 实例变量(
self.name,每对象一份)vs 类变量(写在类顶层,全体共享)。 - 实例方法:第一个参数是
self,定义的是"这类东西能做的事"。 - 多个对象互不干扰,各自带自己的数据。
【翻车现场】本章的坑
坑 1:方法定义漏了 self
class Dog:
def bark(): # ❌ 缺 self!
print("汪!")
dog = Dog()
dog.bark() # TypeError: bark() takes 0 arguments but 1 was given
定义实例方法,第一个参数必须写 self(虽然调用时不用传)。忘了它,Python 会报"给了 1 个参数但你只要 0 个"。
坑 2:访问属性写成局部变量
class Dog:
def __init__(self, name):
self.name = name
def introduce(self):
print(f"我是{name}") # ❌ name 没定义!应该是 self.name
__init__ 里的 name 只是参数,想让它跟着对象走,必须存成 self.name,用的时候也写 self.name。
坑 3:没写 init 也想有属性
class Dog:
pass
dog = Dog()
dog.name = "旺财" # 这样其实也能加属性,但不推荐
print(dog.name) # 旺财
Python 允许对象"随时加属性",但乱加会让代码难懂。规范做法:在 __init__ 里统一初始化,一看就明白这对象有哪些属性。
坑 4:构造方法参数和属性名搞混
class Dog:
def __init__(self, name):
name = name # ❌ 少了 self.,存不到对象上!
name = name 只是在方法里创建局部变量,用完就没了。想存到对象上,左边必须写 self.xxx。
坑 5:类名和变量名撞车
Dog = Dog("旺财") # ❌ 把类覆盖成了对象!
变量 Dog 一旦被赋成对象,Dog("另一个") 就会报"Dog 不是可调用对象"。类名用大写开头(约定),别拿它当变量名。
坑 6:忘了 docstring,类看不懂
class Account:
def __init__(self, holder, balance=0):
...
类开头写一句 """银行账户:能存钱、取钱、查余额""",别人(和几天后的你)一眼知道这玩意是干嘛的。类越大,docstring 越重要。
【本章习题】
一、选择题
1. (★) 类(class)和对象(对象)的关系,下面比喻正确的是?
- A. 类是房子,对象是房子里的家具
- B. 类是设计图,对象是照图造出来的房子
- C. 类是工人,对象是工具
- D. 类和对象是一回事
2. (★) def __init__(self, name): 里的 self 指的是?
- A. 类本身
- B. 正在创建的那一个对象
- C. 传给构造方法的第一个参数
- D. Python 关键字,没有含义
3. (★★) 下面代码输出什么?
class Cat:
def __init__(self, name):
self.name = name
a = Cat("咪咪")
b = Cat("花花")
print(a.name, b.name)
- A.
咪咪 咪咪 - B.
咪咪 花花 - C.
花花 花花 - D. 报错
4. (★★) 下面代码输出什么?
class Dog:
count = 0
def __init__(self, name):
self.name = name
Dog.count += 1
d1 = Dog("旺财")
d2 = Dog("小白")
print(Dog.count)
- A.
0 - B.
1 - C.
2 - D. 报错
5. (★★ 多选) 关于类,下列说法正确的是?
- A. 一个类可以创建很多个互不干扰的对象
- B.
self.name = name是把名字存到对象自己身上 - C. 调用
dog.bark()时,Python 会自动把 dog 传给 self - D. 类变量写在大括号里
二、判断题
1. (★) Dog() 会自动调用 __init__ 方法。( )
2. (★★) 类变量是所有对象共享的一份数据。( )
3. (★★) 定义实例方法时,第一个参数必须写成 self。( )
4. (★★) dog1 = Dog(不带括号)和 dog1 = Dog()(带括号)效果一样,都是造对象。( )
三、代码纠错题
1. (★★) 下面的 Dog 类想打印"我叫旺财",但报错,请改正:
class Dog:
def __init__(self, name):
self.name = name
def introduce():
print(f"我叫{self.name}")
dog = Dog("旺财")
dog.introduce()
2. (★★) 下面的代码,学生以为 name 已经存到对象上了,但输出报错,请改正:
class Dog:
def __init__(self, name):
name = name # 想存到对象上
dog = Dog("旺财")
print(dog.name)
四、编程实战题
1. (基础 ★) 定义一个 Cat 类,有属性 name 和 age,有方法 meow()(打印"喵!")和 introduce()(打印"我是咪咪,2岁")。创建两只猫测试。
2. (基础 ★★) 定义一个 Student 类,属性有 name 和 score,方法 pass_or_not() 打印"及格"或"不及格"(score ≥ 60 及格)。
3. (基础 ★★) 定义一个 Rectangle(矩形)类,属性 width 和 height,方法 area() 返回面积、perimeter() 返回周长。创建两个不同尺寸的矩形测试。
4. (挑战 ★★★) 完善 BankCard(银行卡)类:属性有卡号、密码、余额;方法有存钱、取钱、验证密码后取钱(密码对才让取),再补一个"改密码"方法。
【参考答案与解析】
一、选择题
1. 答案:B
类是设计图,对象是照图造出来的实例。
2. 答案:B
self 指的是正在创建的那一个具体对象,dog = Dog("旺财") 时 self 就是 dog。
3. 答案:B
两个对象各存各的名字:a.name 是咪咪,b.name 是花花。
4. 答案:C
Dog.count 是类变量,造两只狗各 += 1 一次,结果是 2。
5. 答案:A、B、C
A 对:一个类可造无数对象;B 对:self.name = name 存到对象上;C 对:Python 自动传 self;D 错:类不是大括号写的,Python 用缩进。
二、判断题
1. 正确(√)。Dog(...) 自动触发 __init__。
2. 正确(√)。类变量定义在类顶层,所有实例共享同一份。
3. 正确(√)。实例方法的第一个参数约定是 self。
4. 错误(×)。dog1 = Dog(无括号)只是把"类本身"赋给变量,不会造对象;dog1 = Dog()(有括号)才真正创建对象。和函数一样,调用要带括号。
三、代码纠错题
1. 解析: 两个错:①introduce 方法漏了 self;②方法里用 self.name,但 self 没传进来,会 NameError。改正:
class Dog:
def __init__(self, name):
self.name = name
def introduce(self): # 补上 self
print(f"我叫{self.name}") # 用 self.name
dog = Dog("旺财")
dog.introduce()
2. 解析: name = name 少了 self.,创建的是局部变量,对象上根本没有 name 属性,dog.name 报 AttributeError。改正:
class Dog:
def __init__(self, name):
self.name = name # 左边必须写 self.name
dog = Dog("旺财")
print(dog.name) # 旺财
四、编程实战题
1. 参考代码:
class Cat:
def __init__(self, name, age):
self.name = name
self.age = age
def meow(self):
print("喵!")
def introduce(self):
print(f"我是{self.name},{self.age}岁")
a = Cat("咪咪", 2)
b = Cat("花花", 1)
a.meow()
a.introduce()
b.introduce()
2. 参考代码:
class Student:
def __init__(self, name, score):
self.name = name
self.score = score
def pass_or_not(self):
if self.score >= 60:
print(f"{self.name} 及格")
else:
print(f"{self.name} 不及格")
s = Student("小明", 75)
s.pass_or_not() # 小明 及格
3. 参考代码:
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
def perimeter(self):
return 2 * (self.width + self.height)
r1 = Rectangle(3, 4)
r2 = Rectangle(5, 6)
print(r1.area(), r1.perimeter()) # 12 14
print(r2.area(), r2.perimeter()) # 30 22
4. 参考代码:
class BankCard:
def __init__(self, card_no, password, balance=0):
self.card_no = card_no
self.password = password
self.balance = balance
def deposit(self, amount):
if amount <= 0:
print("金额必须大于 0!")
return
self.balance += amount
print(f"存入 {amount},余额 {self.balance}")
def check_password(self, pwd):
return pwd == self.password
def withdraw(self, amount, pwd):
if not self.check_password(pwd):
print("密码错误!")
return
if amount > self.balance:
print("余额不足!")
return
self.balance -= amount
print(f"取出 {amount},余额 {self.balance}")
def change_password(self, old, new):
if not self.check_password(old):
print("原密码错误!")
return
self.password = new
print("密码修改成功!")
card = BankCard("6222-001", "1234", 1000)
card.withdraw(500, "1234") # 密码对 → 取出 500,余额 500
card.withdraw(100, "9999") # 密码错 → 密码错误!
card.change_password("1234", "5678")
拆解: 把"验证密码"抽成一个独立方法 check_password,取钱和改密码都复用它——公共逻辑写成方法,别复制粘贴。
🐍"皮皮注:看到
BankCard了吗?密码、余额这些'敏感数据',都被方法'罩住'了——外人不能直接改,必须走'柜台窗口'(方法)验证。这就叫封装。下一章,我们让类之间也有'家族关系'——继承。"
📖 下一章,家族传承:继承、多态与封装。