Skip to content

第 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) 这行做了两件事:

  1. 造出一个空对象。
  2. 自动调用 __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.nameStudent.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、构造函数与访问控制 ​

本质问题:两种语言都要把「数据 + 行为」打包,并且回答「哪些部分允许外面碰」。打包的语法不同,「允许碰」的实现方式更是两种思路。

对比点PythonC++
类的关键字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())  # 输出 -50
text
-50

单下划线只是写给程序员看的提示,Python 解释器不强制。C++ 的 private 是编译器强制执行的规则,写 ming.chinese = -50 连编译都过不了。一个靠自觉,一个靠制度——这正是两册对照里反复出现的设计分歧。