深色模式
第 13 章:类与对象(上)——为什么要面向对象
本章能学到什么
- 字典「只管数据不管行为」带来的麻烦
- 类 = 数据 + 行为的打包
- 构造函数
__init__ - 成员函数(方法)和普通函数的区别
- 单下划线与双下划线的命名约定
知识链位置:第 12 章用字典把学生的数据捆成了一包。本章再进一步:把操作这些数据的函数也装进包里。这是编程思想的一次升级。
场景:数据和操作分家的麻烦
第 12 章的程序里,字典管数据,函数管操作,两边是分开的:
python
ming = {"name": "小明", "chinese": 88, "math": 92}
def total(stu): # 操作写在字典外面
return stu["chinese"] + stu["math"]程序小的时候没问题。程序变大后,麻烦出现了:
- 项目里有十几种字典,几十个散落的函数。
total到底接收哪种包,只能靠约定和记忆区分。 - 任何地方都能写
ming["chinese"] = -50,没人拦得住。负数分数是非法数据,但字典不会自我保护。 - 键名写错成
ming["chinees"],写程序时没有任何提示,运行到那一行才报错。
问题的根源:数据和它的操作分家了。它们明明是一体的,却住在两个地方。
类:把数据和行为装进同一个包
类(class)就是升级版的字典:除了数据,还能装函数。装进类的函数叫方法(成员函数),表示「这个数据包自己会做的事」。
python
class Student:
def __init__(self, name, chinese, math): # 构造函数,造对象时自动执行
self.name = name # self 指「正在造的这个对象」
self.chinese = chinese
self.math = math
def total(self): # 方法:算总分
return self.chinese + self.math
def introduce(self): # 方法:自我介绍
print("我是" + self.name + ",两科总分" + str(self.total()))
ming = Student("小明", 88, 92) # 造出一个学生对象
ming.introduce() # 让小明这个包自己介绍自己text
我是小明,两科总分180变化是本质性的:total() 不再是「外面的函数接过一包数据」,而是「小明这个包自己会算总分」。数据和操作住在同一个家里了。
| 概念 | 含义 | 类比 |
|---|---|---|
| 类(class) | 数据 + 行为的图纸 | 月饼模具 |
| 对象(object) | 照图纸造出的一个具体实例 | 压出来的一块月饼 |
| 属性(成员变量) | 对象里的数据 | 月饼的馅料 |
| 方法(成员函数) | 对象会做的事 | 月饼自带的本领 |
一个月饼模具能压出无数块月饼。一个 Student 类也能造出无数个学生对象,每个对象有自己的姓名和分数。
构造函数 init:对象出生时的准备
Student("小明", 88, 92) 这行做了两件事:
- 造出一个空对象。
- 自动调用
__init__,把三个值填进去。
__init__ 的第一个参数固定写成 self,它就是「刚造出来的这个对象自己」。self.name = name 读作「把参数 name 存进我自己的 name 格里」。
定义了 __init__ 之后,造对象就必须给齐数据——Student("小明") 会直接报错。非法的「半成品对象」从源头上被杜绝了。
Python 里也有一个和析构对应的 __del__ 方法,在对象被回收时执行。但 Python 自动管理内存,回收时机不确定,入门阶段知道它的存在即可。
方法 vs 普通函数
| 对比点 | 普通函数 | 方法(成员函数) |
|---|---|---|
| 住在哪里 | 类的外面 | 类的里面 |
| 怎么调用 | total(ming),数据当参数传进去 | ming.total(),对象自己调用 |
| 第一个参数 | 没有特殊参数 | 固定是 self,指调用者自己 |
| 数据从哪来 | 参数 | 自己包里的属性,写 self.xxx |
| 属于谁 | 谁也不属于 | 属于这个类的每一个对象 |
ming.total() 的时候,Python 自动把 ming 塞进 self。方法里写 self.chinese,指的就是「调用我的这个对象的 chinese」。小明调 total() 算的一定是小明的分,不会拿错包。
命名约定:Python 式的「请勿乱碰」
回到开头的麻烦:ming.chinese = -50 这种乱写没人拦得住。Python 的处理方式不是上锁,而是挂牌子:
| 写法 | 约定含义 | 实际约束力 |
|---|---|---|
name | 公开属性,随便用 | — |
_name | 「内部使用,请勿乱碰」的提示 | 没有强制力,靠自觉 |
__name | 更强的提示,Python 会改名成 _类名__name 增加误碰难度 | 仍能绕过,不是真锁 |
python
class Student:
def __init__(self, name):
self.name = name
self._chinese = 0 # 单下划线:提示「内部使用」
def set_chinese(self, score):
if 0 <= score <= 100:
self._chinese = score # 合法才收
else:
print("分数必须在 0~100 之间!")
def get_chinese(self):
return self._chinese
ming = Student("小明")
ming.set_chinese(-50) # 走窗口:被拒绝
ming.set_chinese(88) # 走窗口:合法,收下
print(ming.get_chinese())text
分数必须在 0~100 之间!
88想改分数,推荐走 set_chinese 这个「窗口」,窗口里有检查。这就是封装的雏形:数据藏在约定后面,只留几个安全的窗口。第 14 章还会专门讲它的意义。
self 到底是什么
ming.total() 和 hong.total() 调用的是同一个方法,算出的却是各自的总分。秘密在于:调用方法时,Python 自动把对象本身塞进第一个参数 self。
下面两种写法完全等价:
python
ming.total() # 常用写法
Student.total(ming) # 等价写法:用类名调用,对象手动传入self.chinese 就是「传进来的这个对象的 chinese」。self 不是关键字,叫别的名字也能运行,但全 Python 世界都约定叫 self,照做即可。
类属性:属于全班的共享数据
属性除了挂在每个对象身上,还能挂在类身上,被所有对象共享。比如统计一共造了多少个学生:
python
class Student:
count = 0 # 类属性:属于整个类,大家共享
def __init__(self, name):
self.name = name # 实例属性:属于各自的对象
Student.count += 1 # 每造一个对象,计数加一
a = Student("小明")
b = Student("小红")
print("学生总数:" + str(Student.count))text
学生总数:2| 对比点 | 实例属性 | 类属性 |
|---|---|---|
| 写在哪 | __init__ 里,self.xxx | 类里、方法外 |
| 属于谁 | 每个对象各有一份 | 全类共享一份 |
| 怎么访问 | ming.name | Student.count |
构造函数的默认参数
和普通函数一样,__init__ 的参数可以有默认值:
python
class Student:
def __init__(self, name, chinese=0, math=0): # 成绩默认 0
self.name = name
self.chinese = chinese
self.math = math
ming = Student("小明", 88, 92) # 信息齐全
temp = Student("插班生") # 只给姓名,成绩自动是 0
print(temp.name + "的数学:" + str(temp.math))text
插班生的数学:0成绩还没录入的新生,可以先造出来再补数据。
完整例子:班级花名册
把本章学到的东西合起来:一个类,一群对象,放在列表里统一管理。
python
class Student:
def __init__(self, name, chinese, math): # 构造函数:出生即合法
self.name = name
self.set_scores(chinese, math) # 走检查窗口,非法分进不来
def set_scores(self, chinese, math):
if 0 <= chinese <= 100 and 0 <= math <= 100:
self._chinese = chinese
self._math = math
else:
print("分数必须在 0~100 之间!")
self._chinese = 0
self._math = 0
def total(self):
return self._chinese + self._math
def introduce(self):
print("我是" + self.name + ",两科总分" + str(self.total()))
cls = [ # 对象组成的列表
Student("小明", 88, 92),
Student("小红", 95, 81),
Student("小刚", 70, 85),
]
for stu in cls:
stu.introduce()
best = cls[0] # 找总分最高者
for stu in cls[1:]:
if stu.total() > best.total():
best = stu
print("总分最高的是" + best.name)text
我是小明,两科总分180
我是小红,两科总分176
我是小刚,两科总分155
总分最高的是小明和第 12 章的字典版本相比:分数按约定藏在下划线后面,构造函数保证没有半成品对象,total() 跟着数据走。类的三大好处——打包、初始化、约定保护——在这个不到 40 行的程序里全部用上了。
什么该放进类里
设计一个类时,一个简单判断:
| 候选内容 | 放不放 | 理由 |
|---|---|---|
| 描述对象本身的数据(姓名、分数) | 放,作属性 | 数据属于对象 |
| 只用到自己数据的操作(算总分) | 放,作方法 | 行为贴着数据走 |
| 和具体某个学生无关的操作(比较两个学生谁高) | 可放可不放 | 写成普通函数也合理 |
| 临时计算用的中间变量 | 不放 | 用完就扔,留在函数里 |
【跨语言对照】class、构造函数与访问控制
本质问题:两种语言都要把「数据 + 行为」打包,并且回答「哪些部分允许外面碰」。打包的语法不同,「允许碰」的实现方式更是两种思路。
| 对比点 | Python | C++ |
|---|---|---|
| 类的关键字 | class Student:(用缩进划界) | class Student { ... };(结尾有分号) |
| 构造函数 | 固定名字 __init__(self, ...) | 与类同名的函数 Student(...) |
| 析构对应物 | __del__(self),对象被回收时执行,时机不确定 | ~Student(),对象销毁时自动执行 |
| 成员函数的第一参数 | 显式写出 self,属性要写成 self.name | 隐含的(叫 this),函数里直接用成员名 |
| 私有成员 | 约定俗成:_name 提示「内部使用」,__name 触发名称改写增加误碰难度,但都能绕过 | private: 真隔离,外面访问会编译报错 |
class 定义写法对照。Python:
python
class Student:
def __init__(self, name): # 构造函数
self.name = name
def hello(self):
print("我是" + self.name)C++:
cpp
class Student {
public:
string name;
Student(string n) { // 构造函数
name = n;
}
void hello() {
cout << "我是" << name << endl;
}
};等价代码:造一个学生,让他自我介绍。
Python 版:
python
class Student:
def __init__(self, name, chinese, math): # 构造函数:出生时填好数据
self.name = name
self.chinese = chinese
self.math = math
print("创建了学生:" + self.name)
def total(self): # 方法:算总分
return self.chinese + self.math
def introduce(self): # 方法:自我介绍
print("我是" + self.name + ",两科总分" + str(self.total()))
a = Student("小明", 88, 92)
a.introduce()C++ 版(详见 《C++ 从入门到精通》第 13 章):
cpp
#include <iostream>
#include <string>
using namespace std;
class Student {
public:
string name;
int chinese;
int math;
Student(string n, int c, int m) { // 构造函数:出生时填好数据
name = n;
chinese = c;
math = m;
cout << "创建了学生:" << name << endl;
}
int total() { // 成员函数:算总分
return chinese + math;
}
void introduce() { // 成员函数:自我介绍
cout << "我是" << name << ",两科总分" << total() << endl;
}
};
int main() {
Student a("小明", 88, 92);
a.introduce();
return 0;
}两段程序的输出完全一致:
text
创建了学生:小明
我是小明,两科总分180为什么设计不一样:Python 的选择是「我们都是成年人」:用下划线命名约定表达意图,信任程序员不去乱碰,换来的是写法和运行时机制的简单。C++ 把「隔离」做成语言规则,private 成员从外面访问,编译器直接拒绝——规则在程序运行前就生效。Python 把 self 摆在明面上,C++ 的 this 藏在幕后——一个选择少藏东西,一个选择少写字。两种取向各有适用的场合,下一章还会继续看到这条设计思路的分歧。
动手实验
实验 1:给 Student 类加一个方法 average(),返回两科平均分。造出小明并打印他的平均分。
💡 查看答案
python
class Student:
def __init__(self, name, chinese, math):
self.name = name
self.chinese = chinese
self.math = math
def average(self): # 新增的方法
return (self.chinese + self.math) / 2
ming = Student("小明", 88, 92)
print(ming.name + "的平均分是" + str(ming.average()))text
小明的平均分是90.0实验 2:用同一个类造出三个学生对象(小明 88/92、小红 95/81、小刚 70/85),放在一个列表里,循环调用 introduce()。
💡 查看答案
python
class Student:
def __init__(self, name, chinese, math):
self.name = name
self.chinese = chinese
self.math = math
def total(self):
return self.chinese + self.math
def introduce(self):
print("我是" + self.name + ",两科总分" + str(self.total()))
cls = [ # 对象列表:一个月饼模具压三块月饼
Student("小明", 88, 92),
Student("小红", 95, 81),
Student("小刚", 70, 85),
]
for stu in cls:
stu.introduce() # 每个对象各自介绍自己text
我是小明,两科总分180
我是小红,两科总分176
我是小刚,两科总分155实验 3:用单下划线约定改写 Student,配上 set_chinese 检查。试着直接写 ming._chinese = -50,观察结果,想想这和 C++ 的 private 有什么区别。
💡 查看答案
python
class Student:
def __init__(self, name):
self.name = name
self._chinese = 0
def set_chinese(self, score):
if 0 <= score <= 100:
self._chinese = score
else:
print("分数必须在 0~100 之间!")
def get_chinese(self):
return self._chinese
ming = Student("小明")
ming._chinese = -50 # 能执行!Python 不会拦,只违反了约定
print(ming.get_chinese()) # 输出 -50text
-50单下划线只是写给程序员看的提示,Python 解释器不强制。C++ 的 private 是编译器强制执行的规则,写 ming.chinese = -50 连编译都过不了。一个靠自觉,一个靠制度——这正是两册对照里反复出现的设计分歧。
