《Python 从入门到精通》077|封装:为什么说“隐藏细节”很重要

今日分享：

夏虫不可语冰，井蛙不可语海。

想想改变自己有多难，你就会明白想改变别人有多愚蠢。

学到这里，你已经能写类、能创建对象、能用 __init__ 初始化数据，也能分清实例方法、类方法、静态方法了。接下来，我们要进入面向对象里一个非常核心、但一开始很容易被误解的概念：封装。

很多人第一次听到“封装”这个词，会觉得特别抽象，好像是什么很高级的架构思想。其实你把它翻译成人话，就会发现一点都不玄。

封装，说白了，就是：

把数据和操作数据的方法放在一起，并且尽量不要让外部随便乱动对象内部的细节。

你先别急着背定义。我们从现实场景开始看，会顺很多。

一、为什么要封装

想象一下，你买了一台洗衣机。

你平时怎么使用它？

按下电源 选择模式 点击开始

你会不会先打开洗衣机外壳，然后自己去拨动电机、控制水流、调节转速？当然不会。你根本不需要知道里面每一根线怎么接，也不应该让你直接碰那些内部零件。

你真正需要的，是一个清晰、简单、安全的使用接口。

这就是封装最直观的味道。

外部只需要知道怎么用。 内部怎么实现，尽量藏起来。 这样更安全，也更清晰。

程序里的类，其实也很像这样。

二、如果没有封装，代码会怎样

先看一个很常见、但不太理想的写法。

classBankAccount:def__init__(self, owner, balance):        self.owner = owner        self.balance = balance

创建对象：

acc1 = BankAccount('张三', 1000)print(acc1.balance)

这看起来没问题，但危险点也很明显。

因为外部可以直接这样改：

acc1.balance = -999999

这显然不合理。

现实里的银行账户，余额当然不能随便改成一个离谱的负数。 你应该通过存钱、取钱这些合理动作去改变它，而不是谁都能在外面一把把余额改掉。

这时候你就会发现，只把属性裸露出来，其实是不够稳的。

这也正是封装要解决的问题之一。

三、封装的第一层理解：把数据和行为绑在一起

这是最基础的一层。

比如银行账户这个对象，不只是有余额这个数据，它还应该有：

存钱 取钱 查看余额

也就是说，不应该让外部直接乱改 balance，而应该让对象自己提供方法来管理这个数据。

比如：

classBankAccount:def__init__(self, owner, balance):        self.owner = owner        self.balance = balancedefdeposit(self, amount):        self.balance += amount        print(f'{self.owner} 存入了 {amount} 元，当前余额是 {self.balance} 元')defwithdraw(self, amount):if amount <= self.balance:            self.balance -= amount            print(f'{self.owner} 取出了 {amount} 元，当前余额是 {self.balance} 元')else:            print('余额不足，取款失败')

使用时：

acc1 = BankAccount('张三', 1000)acc1.deposit(200)acc1.withdraw(500)

这就比“外部直接改余额”合理多了。

因为对象不只是被动存数据，而是主动管理自己的数据。 这其实就是封装的第一层价值。

四、封装的第二层理解：隐藏不该随便碰的细节

光把数据和方法放一起，还只是开始。更重要的一层是：

有些内部细节，不应该让外部直接干预。

还是洗衣机的例子。

你知道“开始洗衣”这个动作就够了。 至于先注水、再滚动、再排水、再甩干，这些内部细节，应该由机器自己处理。

程序也是一样。

比如你有一个订单类，外部最关心的是：

支付 取消 发货

但一个订单状态在内部怎么流转，哪些步骤先发生、哪些后发生，最好由类自己控制，不要把这些细节暴露得太乱。

这就是封装为什么和“隐藏细节”紧密相关。

五、为什么“能直接改”不代表“应该直接改”

Python 这门语言有一个特点：它整体上比较灵活，不像有些语言那样会对访问权限做得非常死。

所以很多时候，你当然“可以”直接改对象属性。 但问题不在于你能不能，而在于你该不该。

比如：

acc1.balance = -5000

语法能不能跑？可能能。 逻辑合不合理？明显不合理。

所以封装从来不只是语法问题，更是设计问题。

也就是说：

封装不是单纯为了防访问，而是为了让对象的状态变化更可控。

这一点你一定要尽早建立起来。

六、一个更贴近现实的例子：学生成绩

看这个类：

classStudent:def__init__(self, name, score):        self.name = name        self.score = score

外部完全可以这样写：

stu1 = Student('张三', 95)stu1.score = 1000

这当然不合理。成绩通常应该有范围，比如 0 到 100。

这时更合理的做法，是让对象自己提供一个“修改成绩”的方法，并且在方法里做检查。

classStudent:def__init__(self, name, score):        self.name = name        self.score = scoredefset_score(self, score):if0 <= score <= 100:            self.score = score            print(f'{self.name} 的成绩已更新为 {self.score}')else:            print('成绩必须在 0 到 100 之间')

使用时：

stu1 = Student('张三', 95)stu1.set_score(88)stu1.set_score(1000)

输出结果：

张三 的成绩已更新为 88成绩必须在 0 到 100 之间

你看，这就是封装在起作用。

不是谁想怎么改就怎么改。 而是通过类提供的合法入口去修改数据。

七、这时候你会发现，方法不只是“做事”，还是“守门”

前面我们学实例方法时，很多人会把方法理解成“对象能做什么”。

这没错，但还不够完整。

从封装开始，你要再加一层理解：

方法不仅是在做事，也是在控制哪些事能做、哪些事不能做。

比如：

deposit() 控制存钱逻辑withdraw() 控制取钱逻辑set_score() 控制成绩是否合法charge() 控制电量变化pay() 控制订单支付状态

也就是说，方法很多时候就是对象的“官方入口”。

外部想操作对象，不应该瞎碰对象内部，而应该通过这些入口。

这就是封装特别重要的一个思想升级。

八、封装为什么能让代码更安全

因为它减少了外部乱改内部状态的机会。

还是银行账户这个例子。

如果外部能直接改余额，那程序里任何地方都可能把余额改坏。 可如果你规定只能通过 deposit() 和 withdraw() 来变动余额，那很多非法情况就能被挡在门外。

例如：

classBankAccount:def__init__(self, owner, balance):        self.owner = owner        self.balance = balancedefdeposit(self, amount):if amount > 0:            self.balance += amount            print(f'存款成功，当前余额是 {self.balance}')else:            print('存款金额必须大于 0')defwithdraw(self, amount):if amount <= 0:            print('取款金额必须大于 0')elif amount > self.balance:            print('余额不足')else:            self.balance -= amount            print(f'取款成功，当前余额是 {self.balance}')

这里对象自己已经把很多边界条件管起来了。

这就比让外部随便赋值强得多。

九、封装为什么还能让代码更容易用

安全只是一个方面，另一个很重要的价值是：好用。

你作为类的使用者，根本不想每次都知道内部细节。你只想知道：

这个类有哪些功能 我该怎么调用 我传什么参数进去 会得到什么结果

比如如果一个账户类只提供：

deposit(amount)withdraw(amount)show_balance()

那别人一看就明白怎么用。

如果没有封装，外部可能得自己手动改余额、手动检查合法性、手动考虑边界，那类的价值就会被大大削弱。

所以封装本质上也在做一件事：

把复杂留在内部，把简单留给使用者。

这句话非常值钱。

十、封装和函数封装，有什么联系

前面我们学函数时，也讲过“封装”这个词。

比如把重复逻辑写进函数里，本质上也是一种封装。 因为你把内部步骤包起来了，外部只要调用函数名就行。

类里的封装和这个是同一条思想，只不过更进一步。

函数封装，主要是在封装一段流程。 类的封装，主要是在封装一个对象的状态和行为。

所以你可以理解成：

函数是在封装动作。 类是在封装角色。

这两个封装方向并不冲突，反而经常一起用。

十一、Python 里“隐藏”通常怎么做

讲到这里，很多人会问：

那 Python 里到底怎么“隐藏”？

这里要说明白一点。Python 并不是那种靠非常严格访问控制来做封装的语言。它更强调一种约定，而不是强制锁死。

最常见的做法是，给“不想让外部直接用”的属性或方法，前面加一个下划线。

比如：

classBankAccount:def__init__(self, owner, balance):        self.owner = owner        self._balance = balance

这里的 _balance，前面的单下划线，通常是在表达一种意思：

这是内部属性，外部最好不要直接碰。

注意，是“最好不要”，不是“绝对不能”。

这是一种约定式的提醒。

十二、单下划线的意义，到底是什么

很多新手会误以为，前面加一个 _，这个属性就真的被锁住了。其实不是。

比如：

acc1 = BankAccount('张三', 1000)print(acc1._balance)

很多时候你仍然是能访问到的。

那为什么还要加？

因为它在表达设计意图。

就像你在门上贴了一个“工作人员通道，闲人勿入”的牌子。门也许没上锁，但大家一看就知道，这不是给普通使用者随便进的。

所以单下划线更像一种“轻提醒”。

它在告诉别人：

这个东西属于内部实现细节 你不是绝对不能碰 但正常使用时不应该依赖它

这在 Python 里非常常见。

十三、双下划线是什么

除了单下划线，你还可能见到双下划线开头的写法。

例如：

classBankAccount:def__init__(self, owner, balance):        self.owner = owner        self.__balance = balance

这时候，外部直接写：

print(acc1.__balance)

通常就访问不到了。

这是因为 Python 会对双下划线开头的名字做一种特殊处理，目的是尽量避免外部直接访问。

你现在不用深挖底层名字改写规则。 先记住一个够用的结论：

单下划线是约定式内部使用，双下划线是更强一点的“不要直接碰”。

不过初学阶段，你不要把重点全放在这些语法技巧上。 封装更重要的是思想，不是把属性藏得多严。

十四、真正重要的不是“藏”，而是“通过合理入口操作”

这句话特别关键。

很多人一学封装，就以为重点是把属性名改成 _xxx 或 __xxx。这当然是手段之一，但不是核心。

核心其实是：

外部想操作对象，应该通过对象提供的方法，而不是直接乱改内部状态。

比如下面这个账户类，封装味道就很完整：

classBankAccount:def__init__(self, owner, balance):        self.owner = owner        self._balance = balancedefdeposit(self, amount):if amount > 0:            self._balance += amount            print(f'存款成功，当前余额是 {self._balance}')else:            print('存款金额必须大于 0')defwithdraw(self, amount):if amount <= 0:            print('取款金额必须大于 0')elif amount > self._balance:            print('余额不足')else:            self._balance -= amount            print(f'取款成功，当前余额是 {self._balance}')defshow_balance(self):        print(f'当前余额是 {self._balance}')

使用时：

acc1 = BankAccount('张三', 1000)acc1.deposit(200)acc1.withdraw(300)acc1.show_balance()

这里外部根本不需要知道余额内部怎么保存，也不应该直接去改。 它只需要通过公开方法正常使用。

这才是封装真正成熟的样子。

十五、封装为什么能让以后改代码更轻松

这是很多新手一开始体会不到，但以后会越来越重要的一点。

假设你最初把余额保存成 _balance。 后来你想在取款时额外记录日志，或者增加手续费，甚至把余额改成别的内部存储方式。

如果外部一直都是通过：

deposit()withdraw()show_balance()

这些公开方法来用，那你完全可以在类内部改实现，而不影响外部调用方式。

这就很像你换了洗衣机内部零件，但用户还是照样按开始键就能用。

所以封装还有一个很大的价值：

把“怎么实现”和“怎么使用”分开。

使用方式稳定，内部实现可以逐步优化。 这对后期维护特别重要。

十六、一个非常典型的封装案例：电风扇

看这个类：

classFan:def__init__(self):        self._speed = 0defturn_on(self):        self._speed = 1        print('风扇已打开，当前风速为 1 档')defspeed_up(self):if self._speed < 3:            self._speed += 1            print(f'风速已提升到 {self._speed} 档')else:            print('已经是最高档了')defturn_off(self):        self._speed = 0        print('风扇已关闭')

这里 _speed 就是内部状态。 外部最合理的使用方式不是直接改 _speed，而是：

fan1 = Fan()fan1.turn_on()fan1.speed_up()fan1.speed_up()fan1.speed_up()fan1.turn_off()

输出结果：

风扇已打开，当前风速为 1 档风速已提升到 2 档风速已提升到 3 档已经是最高档了风扇已关闭

你看，这样就很像真实世界的设备。

你不去直接摆弄内部风速变量，而是通过“打开、加速、关闭”这些动作来控制它。

这就是封装非常接地气的样子。

十七、封装不是为了防自己，而是为了防混乱

这一点特别值得理解。

很多人一看到封装，会想：我自己写的类，我当然知道怎么用，为什么还要这么麻烦。

问题就在于，代码一旦变多，或者项目里不止你一个人，甚至连未来的你自己都会忘记当初内部细节是怎么设计的。

封装的意义，就是提前把边界画清楚：

哪些是给外部用的 哪些是内部实现 外部该通过什么方式与对象交互

这不是为了“防人”，而是为了“防乱”。

你可以把它理解成给代码立规矩。 规矩一立，类就不容易被用坏。

十八、封装和“高内聚、低耦合”有什么关系

这个词你以后会经常听到，现在先有个印象就够。

高内聚，意思是相关的东西尽量放在一起。 低耦合，意思是外部不要过度依赖内部细节。

而封装，本质上就在推动这件事。

比如账户的余额变化规则、合法性检查，都尽量放在账户类内部。 外部不要直接知道内部每一步怎么算，而是通过方法调用。

这就是：

内部更集中 外部依赖更少

所以封装不是孤立概念，它其实和后面很多设计思想都连在一起。

十九、本章小练习

你可以做两个很适合巩固的练习。

第一个练习，定义一个 Student 类。

要求：

有 name 和 _score 两个属性 提供 set_score(score) 方法，只有分数在 0 到 100 之间才允许修改 提供 show_score() 方法，用来查看成绩

参考代码：

classStudent:def__init__(self, name, score):        self.name = name        self._score = scoredefset_score(self, score):if0 <= score <= 100:            self._score = score            print(f'{self.name} 的成绩已更新为 {self._score}')else:            print('成绩必须在 0 到 100 之间')defshow_score(self):        print(f'{self.name} 的成绩是 {self._score}')

第二个练习，定义一个 WaterBottle 类。

要求：

有 _water 属性表示当前水量 提供 drink(amount) 方法，喝水后减少水量 提供 fill(amount) 方法，加水后增加水量 如果喝得太多或者加负数，都要给出提示

这个练习非常适合体会“对象通过方法管理内部状态”这件事。

二十、本章总结

这一章最重要的，不是记住单下划线和双下划线，而是理解封装背后的思路。

封装，就是把数据和操作数据的方法组织在一起，并尽量隐藏不该暴露的内部细节。 它的价值，一是提高安全性，二是降低外部使用复杂度，三是让内部实现以后更容易修改。 外部不应该随便乱改对象内部状态，而应该通过对象提供的公开方法来操作。 单下划线通常表示“内部使用，请不要随便碰”。 双下划线是一种更强一点的隐藏方式。 但真正重要的不是把属性藏起来，而是让对象拥有清晰、合理、可控的操作入口。

下一章我们继续往前走，进入面向对象里另一个非常强大的能力：078｜继承：如何复用已有类的能力。