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

第23章 说明书与商品

类与对象

第 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 就是"正在造的这只狗自己"。

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 的函数)、封装(数据只能走方法改)。下一章,再加两招:继承和多态。"


【皮皮小课堂】本章要点


【翻车现场】本章的坑

坑 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)和对象(对象)的关系,下面比喻正确的是?

2. (★) def __init__(self, name): 里的 self 指的是?

3. (★★) 下面代码输出什么?

class Cat:
    def __init__(self, name):
        self.name = name

a = Cat("咪咪")
b = Cat("花花")
print(a.name, b.name)

4. (★★) 下面代码输出什么?

class Dog:
    count = 0
    def __init__(self, name):
        self.name = name
        Dog.count += 1

d1 = Dog("旺财")
d2 = Dog("小白")
print(Dog.count)

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

二、判断题

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 了吗?密码、余额这些'敏感数据',都被方法'罩住'了——外人不能直接改,必须走'柜台窗口'(方法)验证。这就叫封装。下一章,我们让类之间也有'家族关系'——继承。"


📖 下一章,家族传承:继承、多态与封装。

📦 本章配套代码

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