第 4 章　变量与内存

4.1为什么需要变量：数据要先「住下来」

回顾上一章的程序 print("Hello, World!")：它把一段文字直接显示出来，然后这段文字就「用完即弃」了。但真实程序里，数据往往要先存起来，之后反复用。

比如你要算「小明有 5 个苹果，又买了 3 个，现在几个？」如果写成：

print(5 + 3)

确实能算出 8。但问题是：那个「5」和「3」是「一次性」的——算完就没了。如果之后你还想用「小明的苹果数」去算别的东西（比如分给 2 个人每人几个），你就得把 5 重新写一遍。数据越多、步骤越复杂，这种「用完即弃」就越要命。

所以我们需要一个东西，能把数据存起来、起个名字、随时取用。这个东西，就是 变量（variable）。

apples = 5        # 把 5 存进名为 apples 的变量
apples = apples + 3   # 苹果数变成 8
print(apples)     # 输出 8

更深一层：数据为什么要「住」进内存

「把数据存起来」这句话，还可以再往下问一层：存到哪？为什么非得有个「地方」？CPU 里真正干活的部件叫寄存器（register），可以把它想象成工匠手边的小工具架——数量极少（常见 CPU 只有几十个），取用飞快，但一放下就会被下一个任务占用。而程序要处理的数据动辄成百上千：一次试验的几百条读数、一份名单、一串中间计算结果，工具架根本摆不下。所以数据必须住进大仓库——内存，CPU 每次要用，再按地址来取。变量，就是程序跟这座仓库打交道时的「把手」：起名字＝给货位贴标签，赋值＝把货存进货位，用名字＝按标签取货。

把数据安顿进变量之后，能拿到三样「直接把数字写进算式」永远拿不到的东西。第一是复用：一次存储，处处引用——「备件总数」存进 total，后面十处计算都用这个名字，不必把数字抄十遍。第二是更新：变量永远反映最新状态，新数据一到，覆盖写进去就行，账目始终是活的。第三是可读：算式里出现的是「库存数 + 入库数」而不是两个光秃秃的数字，别人（以及三个月后的你）一眼能看懂每一步在算什么——在工程语境里，这就是计算过程的「可追溯」。

# 版本一：数字直接写死在算式里
print(5 + 3)        # 当前总数：8
print(5 + 3 - 4)    # 剩余数：4

# 版本二：数据进变量，算式引用名字
spare = 5                    # 现有备件数
incoming = 3                 # 今日入库数
issue = 4                    # 今日领用数
total = spare + incoming     # 当前总数
print(total)                 # 8
remaining = total - issue    # 剩余数
print(remaining)             # 4

放到工程现场，这个模式无处不在：传感器每秒读一次温度，读到的值必须先存进变量 temp，才能既拿去判断「是否超温」、又拿去写入记录、还能参与后续统计——一次采集，多处使用。如果每个用途都现场重读一次传感器，不仅浪费，而且三次读数可能各不相同，前后账就对不上了。「先存后用」是数据处理的通用节拍：读入 → 存进变量 → 反复引用。

至此，「为什么要有变量」说透了：数据要有地方住、要有名字找、要改得起、要看得懂。下一节把「住处」解剖开看——变量住的那块内存到底长什么样，名字又是怎么跟它挂上钩的。

4.2变量 = 一块命名的内存

很多教材说「变量是一个盒子」。这个比喻对直觉有帮助，但不够。要打地基，我们得知道盒子到底对应现实里的什么。

回到「计算机软硬件」那门课：计算机里有一块叫 内存（memory，RAM）的地方，它由海量的小格子组成，每个格子能存一个 0 或 1（一个 bit）。这些格子被编号，就像一排储物柜，每个柜子有个门牌号（地址）。

那么「变量」是什么？

把「内存」再往下分一层，还得跟另一座仓库划清界限：内存（RAM）和硬盘是两种不同的存储。内存读写极快——CPU 取一次数据按纳秒计，但断电即失；硬盘慢上百倍——按毫秒计，但断电不丢。变量住的是内存：程序运行时，CPU 先把代码和数据装进内存再加工，程序一结束（或一断电），变量连同里面的数据一起蒸发——就像没点保存就关掉的文档。想长期保存的数据必须另走一条路：写进硬盘上的文件，这是第 11 章的主题。今天先记牢这条边界：变量活在内存里，文件躺在硬盘上；内存是工作台，硬盘是档案柜——工作台上东西再顺手，下班也得归档。

用 id() 亲眼看「名字挂着哪块内存」

上面的说法再顺，也还是推理。好在 Python 提供了一个观测窗口：内建函数 id()。把一个值交给它，它返回这个值所属对象在本次运行中的身份编号；在最常见的 CPython 实现里，这个编号正是对象在内存中的地址。换句话说，id() 能让你「看见」图 4-1 里画的那块格子：两个名字是不是挂着同一块格子，一查便知。

顺带认一认地址的「长相」。内存按字节编号，一根几 GB 的内存条要编到几十亿号，写成十进制又长又难念，所以工程师习惯把地址写成十六进制——每 4 个二进制位恰好并成 1 个十六进制字符，长度立刻缩短一半以上，书写时前面加 0x 标记进制。比如十进制的 2026，写成十六进制就是 0x7EA。你将来在调试工具、报错信息里看到的 0x 开头的一长串，多半都是地址。

x = 5
print(id(x))            # 一串很大的数字（每次运行都不同）

y = x                   # 让 y 也挂上 x 挂着的那块内存
print(id(y) == id(x))   # True：两个名字、同一块内存

x = 10                  # 重新赋值：x 改挂一块存着 10 的新内存
print(id(x) == id(y))   # False：x 搬走了
print(y)                # 5：y 挂的那块内存没动过

运行几遍例题 2 你会发现：id 打印出的数字每次都不一样，甚至同一段代码在不同电脑上跑出的结果完全不同。这不是 bug——内存地址由系统「现场分配」：程序启动时，系统看哪片内存空着就把哪片给你，下次启动空着的区域不同，地址自然不同。由此得出一条使用纪律：id 只用来做「相等与否」的比较，绝不能把具体数字写死进代码或文档。「地址是 140232852871376」这种话离开那次运行就作废，而「两者 id 相等」在任何一次运行里都成立。

现在可以把三层概念正式拆开——这是本章最重要的一组辨析：变量名是给人看的标签；对象（内存块）是真正存数据的地方；地址（id）是机器找对象用的编号。三者关系是「名字 —挂在→ 地址 —里面装→ 值」。新手很多困惑的根源，是把「名字」当成了「盒子本身」——名字不是盒子，是贴在盒子上的纸条；把纸条撕下来贴到另一个盒子上（重新赋值），原来的盒子纹丝不动。

再补一个幕后设定：Python 内部维护着一张「名字 → 对象」的登记表（术语叫命名空间，namespace）。写 x = 5 就是在表里登记「x → 存 5 的那个对象」；执行 print(x) 就是按名字查表、取出对象。这张表的存在解释了两件事：为什么同一个名字可以反复重新登记（赋值就是改表）；为什么两个名字可以登记到同一个对象上（y = x 就是照抄一条登记）。第 9 章讲函数时你会看到，这张表还会按「局部 / 全局」分成几片——现在先记住一句话：查名字，就是查表。

最后再揭一层「幕后的幕后」：这些对象的本体到底住在内存的哪个区？程序运行时，把内存分成两片各司其职的区域。堆是一片自由堆放的大仓库——Python 里你写下的每个整数、每个字符串，本体都存放在堆里，由运行环境按需申请空间、用完自动回收；栈则是层层叠放的托盘架——后进先出，专门记录「程序走到哪了、谁在调用谁」：每进入一层调用，架上就叠起一层新托盘，托盘里放着这层调用的现场信息和它的局部名字登记表；调用返回，整层托盘弹掉，登记表随之清空。一句话分工：栈管流程，堆管数据；栈上的纸条（名字）指向堆里的盒子（对象）。现在不必深究细节，只需建立一个直觉——内存不是一片平坦的大盒子，而是分区管理；第 9 章讲函数时你会亲眼看到：栈的层层托盘，就是函数「跳出去还能跳回来」的全部秘密。

4.3赋值语句：内存里发生了什么

现在，我们放慢镜头，看这一行代码执行时，内存里到底发生了什么：

x = 5

这条语句叫 赋值语句（assignment）。注意 = 在这里不是「相等」，而是「把右边的值，存进左边的名字」。它执行时，内存里发生三步：

1. 分配空间：计算机在内存里找到一块空闲的格子（或几格），划给这个变量。
2. 写入值：把右边「5」转换成二进制 0000 0101，写进这块格子里。
3. 绑定名字：把变量名 x 和这块内存地址「绑定」起来，建立一张「名字 → 地址」的对照表。

两个关键细节：重新赋值与「复制」

细节一：重新赋值是「覆盖」，不是「塞第二个」。如果接着写 x = 10，不是把 10 塞进旁边新格子，而是把原来的格子里的 5 擦掉、写成 10。名字还是那个 x，指向的还是那块地址，只是里面的值变了。

细节二：「=」右边的值先算出来，再存进去。看这两行：

x = 5
y = x        # y 变成 5，是把 x 当前的值「复制一份」给 y
x = 10       # 之后 x 变成 10，但 y 仍是 5

执行到 y = x 时，计算机先读出 x 的值（5），再把这个 5 复制一份存进 y。之后 x = 10 改的是 x 自己的格子，y 的格子不受影响。这是新手最容易搞错的地方，务必记住：对于数字这类简单数据，赋值是「复制值」，不是「建立联动」。

「先算右边」为什么是铁律

细节二说「= 右边的值先算出来，再存进去」。这个顺序值得追问一句：为什么非这样不可？看这行最典型的代码：apples = apples + 3。它的右侧引用了左侧的变量自己——计算机必须先按名字查到旧值 5，算出 8，然后才覆盖写回。假如反过来「先存再算」，赋值的第一步就把旧值 5 冲掉了，右边再想取 apples 时已经面目全非。所以顺序只能是：读旧值 → 算表达式 → 覆盖写回。

这类「自己更新自己」的写法，含义是「在旧值的基础上更新」，工程上俯拾皆是：库存数 = 库存数 + 入库数；合格数 = 合格数 + 1；总里程 = 总里程 + 本段里程。注意一个耐人寻味的反差：数学里 x = x + 3 是无解方程（哪个数会比自己大 3？），编程里它却是出现频率最高的语句之一。这个反差恰恰是提醒——= 是动作（存入），不是关系（相等）。把数学直觉原样搬进赋值，就会在这里摔跟头。

a = 3
print("第1步后:", a)      # 第1步后: 3
b = a
print("第2步后:", a, b)   # 第2步后: 3 3
a = 7
print("第3步后:", a, b)   # 第3步后: 7 3

用工程现场的语言再翻译一遍：变量是一块写着「当前状态」的白板。库存白板每天更新（覆盖写），看到的永远是最新数；如果哪天需要留档「库存的每日变化」，就把历史值抄到别处——另一个变量，或第 11 章要讲的文件。白板养「现在」，档案养「过去」：覆盖写不保留历史，需要追溯的数据必须另行留痕，这是工程数据管理的基本意识。

n = 5
m = n               # m 与 n 挂同一块内存（存 5 的那块）
n = n + 1           # 算出 6 → 存进新内存 → n 改挂新内存
print(m)            # 5：n 搬家了，m 还挂着原来的内存

a = [1, 2, 3]
b = a               # b 与 a 挂同一个列表对象
a.append(4)         # 原地往这块内存里添加 4，a 没有搬家
print(b)            # [1, 2, 3, 4]：同一块内存的内容变了，b 看到的也变了
print(id(a) == id(b))   # True：从头到尾都是同一块内存

热身小魔术：交换两个变量的值

快照模型还能解释一个经典小戏法——交换两个变量的值。最朴素的做法是找「第三只杯子」当 中转站：先把 a 的值倒进 temp 保住，再把 b 倒进 a，最后把 temp 倒回 b。三步顺序错一步，某个值就会被覆盖丢失——因为覆盖写是「毁旧存新」：

a = 1
b = 2
temp = a      # 先把 a 的值存进「第三只杯子」
a = b         # b 的值倒进 a
b = temp      # 中转站里的旧 a 值倒进 b
print(a, b)   # 2 1：交换完成

而 Python 提供了一步到位的写法：a, b = b, a。这行代码正是「先算右边」铁律的漂亮应用——右边先把 b、a 当前的值按顺序打包成一份新值清单，然后才解包分给左边的两个名字；因为是先打包后分发，任何旧值都不会中途丢失。（打包—解包机制的完整原理，第 10 章讲列表时会正式揭开，今天先用起来。）

a = 1
b = 2
a, b = b, a   # 右边先打包成 (2, 1)，再解包给左边的 a、b
print(a, b)   # 2 1

对照着看很有意思：三行版要小心翼翼安排顺序，一行版把「顺序问题」交给了语言机制本身。这也是好语言的样子——把容易出错的细节收编成一句直观的语法，让人腾出脑力去想真正重要的事。往后你会无数次用到 a, b = b, a 这个惯用法，现在就把它的原理记牢。

4.4变量名：名字的规则与意义

变量名是你给内存格子贴的标签。名字起得好，代码读起来像文章；起得烂，三天后你自己都看不懂。Python 对变量名有几条硬规则：

除了「合法」，更要「有意义」。给变量起名，要让它自己会说话：

a = 5              # 不好：a 是什么？过几天就忘
apple_count = 5     # 好：一看就知道是「苹果的数量」
total_price = 9.9   # 好：总价
is_student = True   # 好：是不是学生

关键字为什么碰不得

表格里「不能用关键字」这条规则，值得追问一句为什么。if、for、and、class 这些词是 Python 语法的「骨架」——解释器一读到它们，就走专门的流程：if 开始一次判断，for 开始一轮循环。如果允许把它们当变量名，解释器读到 for = 5 就彻底懵了：这是循环开始，还是取一个叫 for 的变量的值？整套语法都会瘫痪。所以关键字被语言绝对保留，永远不能挪作他用。

这里有一个值得较真的细节：表格把 print 也列进了「错误示例」，但严格来说 print 不是关键字，而是「内建功能名」——它是 Python 出厂自带的打印功能的名字，不走特殊语法流程。机制上你甚至可以写 print = 5（语言允许），但这行会把打印功能的名字占用掉，之后 print(...) 就失灵了——「合法，但致命」。所以「别用 if」和「别用 print」结论相同、性质不同：一个是绝对禁止（关键字），一个是强烈不建议（内建名）。用两行代码可以实测两者的身份差异：

import keyword                     # 引入 Python 自带的「关键字名单」模块
print(keyword.iskeyword('for'))     # True ：for 是关键字，绝对不能用
print(keyword.iskeyword('print'))   # False：print 是内建名，能占但千万别占

import keyword
names = ["user_name", "_hidden", "2score", "user-name",
         "class", "Class", "print", "for"]
for name in names:
    print(name, "是关键字:", keyword.iskeyword(name))

规则之上还有「风格」。同一个合法的名字，Python 社区有统一的书写习惯：变量名全小写，单词之间用下划线连接（如 user_name、max_retry、total_price）——这套写法叫 snake_case（蛇形命名），名字里的下划线像蛇在地上爬出一节一节的印子，它是 Python 官方风格指南 PEP 8 的明确建议。有些语言流行 userName 这种「驼峰式」，在 Python 里虽然完全合法，却会让代码在社区里显得格格不入。风格为什么重要？因为代码首先是写给人看的：统一的风格让任何一位 Python 工程师打开你的代码都能零成本上手——在多人协作的工程里，这就是实打实的生产力。

再往工程现场走一步，看两条行业通行的命名习惯。其一，让量纲进名字：长度就叫 length_mm，压强就叫 pressure_kpa——读代码的人不必翻文档就知道单位。工程计算里最危险的事故之一是「无单位数字」：同一根管的长度，一份文档写 3.2（米），另一份写 3200（毫米），混在一起算必错；把单位写进名字，等于让每个数字随身携带身份说明。其二，不该变的量用全大写：如 MAX_LOAD_KPA = 8.0——Python 其实没有「常量」这个语法（你仍然能覆盖它），全大写只是行业约定，提醒读代码的人「别动它」。这两条不是 Python 的规则，是工程行业的规则，今天养成，终身受益。

4.5变量与「类型」的初识

还记得 4.2 说的「格子」吗？一个关键问题是：不同的数据，占的格子数量不一样，存的方式也不一样。

整数 5，存成二进制 0000 0101 就行；但一段文字 "Hello"，存的是每个字符对应的编码，占的格子更多、方式也完全不同。计算机必须知道这块内存里存的是「什么种类」的数据，才能正确地读它、用它。这个「种类」，就是 数据类型（data type），简称类型。

Python 会自动判断类型：

age = 5            # 整数类型（int）
price = 9.9        # 小数类型（float）
name = "小明"       # 字符串类型（str）
flag = True        # 布尔类型（bool）

为什么类型这么重要？因为同样一个二进制串，按不同类型去解读，结果完全不同。就像一串数字「0101」，它到底是数字 5，还是别的什么东西，取决于你「约定」它是什么。类型就是这个约定。

同一段字节，两种读法

「类型决定解读方式」这句话可以亲眼看到。拿一个字节 0100 0001 来说：如果它属于一个整数变量，就按位权读，128+1=65；如果它属于一个字符串变量，就按编码表读，查 ASCII 表（下一章的主角）——编号 65 对应字符 'A'。字节一个不差，读出的东西却完全不同。你甚至可以让 Python 亲手演示这两个方向：

print(int("01000001", 2))   # 65：按二进制位权读这串 0/1
print(chr(65))              # A：按 ASCII 表把编号 65 翻译成字符

第一行把 0/1 串当「数」读，第二行把同一串当「文」读。所以前面说「类型是约定、是说明书」，现在可以说得更透：说明书不改字节，只改读法。内存里从来没有凭空多出一个「A」，只是解释的方式换了。

再打一个比方收束这一节。想象一张 Excel 表：同一列数字「36866」，在「编号」列里它是个编号，在「字符串」列里它是五个字符的文字，导出成文本文件后还可能是若干字节——列头，就是这张表的「类型」。数据的「身份」从来不取决于它长什么样，而取决于它所在的列。变量也一样：值到底按什么读，看的是变量登记的类型，不是字节本身的样子。

还有一件新手常惊讶的事：Python 里同一个名字可以先后挂不同类型的对象——x = 5 之后紧接着 x = "hello"，程序完全合法。类型不在名字身上，在对象身上；名字只是登记表的条目，想让条目改指一个字符串对象，随时可以。这种风格叫动态类型。它写起来爽快，代价是「看名字猜类型」不再可靠，所以工程社区约定：要么让名字自带类型暗示（user_name、count），要么临时验证（用 type()、isinstance() 这类工具）。另外值得对照的是：不少老牌语言（如 C）把类型绑在名字上——声明「x 是整数」之后 x 终身只能挂整数，这叫静态类型，好处是编译器提前替你把关。动态与静态各有立场，但两者的底层事实一致：值总是带着类型的，只是「谁负责检查类型」不同。

顺带一提：现代 Python 还允许在赋值时给名字加类型提示，写成 x: int = 5。这叫「类型标注」——注意它不改变动态类型的本质：就算标了 int，之后照样可以 x = "hello"，解释器一概不管。它的价值是写给读代码的人看的路标，让团队伙伴不必追进每一处代码就知道「这里应该放什么类型」。工程代码里类型标注越来越常见，将来读到不必惊讶，今天的你只要看懂「: int」是个提示、不改变任何行为就够了。

print(type(5))       # <class 'int'>：整数
print(type("5"))     # <class 'str'>：字符串
print(type(2.5))     # <class 'float'>：浮点数
print(type(True))    # <class 'bool'>：布尔值

print(5 * 2)         # 10：整数乘法，算的是「五的二倍」
print("5" * 2)       # 55：字符串重复，得到两份并排的文字

下一章，我们会把每种类型「是什么、怎么在内存里存、会出什么坑」讲透。这一章你只要记住：变量有类型，类型决定内存怎么解读。