第 3 章　选语言与环境

3.1为什么推荐 Python

世界上有几百种编程语言，各有各的用武之地。作为零基础成人自学，我们推荐 Python，理由很实在：

但请你记住一个关键观念：学的是「编程的思维」，不是「Python 的语法」。变量、循环、函数这些概念，几乎在所有语言里都存在，只是写法略有不同。用 Python 入门，是为了让你把精力花在「理解原理」上，而不是跟语法符号较劲。

为什么「语法接近人话」对入门如此重要

这背后有个朴素的心理事实：人的工作记忆容量有限，一次只能同时握住几个信息块。学编程时，你真正要装进去的是「变量、循环、函数」这些概念；如果语言还要求你同时记住「每行结尾要写分号、代码块要用花括号包住、变量必须先声明类型」这些仪式，工作记忆就被仪式挤占了——概念反而学不进去。仪式感重的语言自有它的道理（后面辨析里会替它们说句公道话），但对零基础的学习者，仪式是纯负担。

Python 的选择是把这些仪式几乎全部删掉：没有分号、没有花括号、很多场合连类型都不用声明。你在第 1 章写的伪代码「合格数 = 合格数 + 1」，到 Python 里原样能跑（ok = ok + 1）。语言贴近你的思考，而不是让你贴近语言——这是「适合入门」的全部秘密。同时它还附带一个工程红利：代码即文档，几个月后回读自己脚本时，贴近人话的代码几乎不用注释也能读懂。

「少仪式」还直接关系到自学能不能坚持下来。零基础学编程的流失高峰，恰恰在最初两周——不是内容有多难，而是挫败感来得太快：满屏报错、程序跑不起来、不知道错哪了。此时语言每多一分仪式，就多一个「卡住你」的机会：漏个分号报错、花括号不配对报错、类型没声明报错……而 Python 把这些「非智力性障碍」降到最低，让你把有限的耐心花在真正值得的地方——理解变量、循环、函数这些会陪伴你整个编程生涯的概念。学习工具的意义，就是把挫折留给该有的难，而不是语法题。

for i in range(1, 6):    # 对 i 从 1 数到 5（不含 6）
    print(i * i)         # 每轮打印 i 的平方

1
4
9
16
25

放到工程现场看，这套特性恰好命中工程人员的日常需求：整理一批试验数据、批量重命名上百个文件、从传感器日志里筛异常值——这类任务用 Python 往往十几行、半小时就能交付一个能跑的小工具，而开发同样的工具用仪式感重的语言可能要多花数倍时间。对以「解决本岗位问题」为目标的工程学习者，上手快、生态全、立刻有用，比什么都重要。

再把镜头拉远一点，看看 Python 在整个语言谱系里的位置。从第 2 章你已经知道，「离机器近」和「离人近」是两端：机器码与汇编贴着硬件，写起来痛苦但控制力最强；Python 站在「离人近」的一端，把硬件细节全部藏起；C、C++、Java、Go 等则散布在中间地带，各有各的取舍。谱系没有高下，只有位置不同——就像民航客机与直升机不是谁更先进，而是任务剖面不同。入门从「离人近」的一端起步，先建立编程思维的全景；将来如果岗位需要贴硬件的功力（比如嵌入式、实时仿真），再沿着谱系向机器那端走，此时你会发现循环、条件、函数这些概念原封不动，变的只是「仪式」的多少。

辨析环节，替「仪式感重」的语言说句公道话：显式的类型声明、严格的语句结构并非繁文缛节——类型声明让编译器在运行前就拦下一大类错误，严格结构让大型工程的多人协作有章可循。大型机载软件、实时控制系统偏爱这类「啰嗦但严谨」的语言，看中的正是「编译期把问题揪出来」的能力。所以请建立平衡的认知：仪式有仪式的岗位，简洁有简洁的岗位；入门选简洁是为了快速建立思维，思维立住之后，第二门语言随岗位需要再学，成本会低得多——因为概念是通用的，变的只是写法。

3.2编译 vs 解释：代码怎么变成机器码

上一章说过，高级语言写的源代码最终要翻译成机器码才能运行。翻译这件事，有两种截然不同的做法：编译（compilation）和 解释（interpretation）。

编译：先整本翻译，再交给机器

编译型语言（如 C、C++、Rust）的工作方式是：写完全部代码后，用一个叫 编译器（compiler）的程序，把整份源代码一次性翻译成机器码，生成一个可执行文件。以后每次运行，直接跑这个机器码文件，翻译只需做一次。

解释：一句一句翻译，翻一句执行一句

解释型语言（如 Python）的工作方式是：一个叫 解释器（interpreter）的程序，读一行、翻译一行、执行一行，边读边做。没有「整份提前翻译」这一步。

两种方式带来的工程差异，比「快慢」二字丰富得多。编译型的产物是独立的可执行文件：交付给用户后，对方机器上既不需要源代码、也不需要编译器，装上就能跑——但代价是每次改动哪怕一行，都要重新走一遍完整编译。解释型的源代码永远需要解释器在场：把 .py 文件拷给同事，对方机器上必须装有 Python 才能运行；好处是改完即跑，翻译成本被摊薄到几乎为零。这个差异直接决定了两类语言各自适合的交付形态，下一道例题会把这笔账算成数字。

先把两个隐含量级说透，再看数字。「2 秒编译」在真实项目里可不是常数：一个几万行的大项目，完整编译动辄几分钟到几十分钟，正因为贵，大团队才发明了「增量编译」——只重编改动过的部分。而「每次 0.5 秒」也不只是慢：解释执行意味着运行期还要现场翻译，同样的算法，解释型语言的总耗时通常比编译型高一个量级。所以真实的取舍是「开发节奏」与「运行极限」的交换：要改得快，就接受跑得慢一点；要跑得极致，就接受编译等待。数据脚本几乎永远选前者，机载实时控制几乎永远选后者。

两种翻译时机还带来一个初学阶段就能感知的差异：错误被发现的时机不同。编译型语言在「整体翻译」时就把全文件的语法问题兜底查一遍——还没运行，一大类错误就被编译器点名批评；解释型语言是「执行到哪行才翻到哪行」，一个埋在第 200 行的笔误，只要程序前 199 行还没跑完，它就安静地躺着。这呼应第 1 章讲过的三类错误：语法错误编译器能拦、解释器要跑到了才报；而逻辑错误，无论哪种语言、哪种时机，机器都永远发现不了——只能靠人。第 6 章会专门展开「调试」这门手艺。

for n in (1, 5, 10, 100):
    print(n, round(2 + 0.01 * n, 3), 0.5 * n)   # 次数, 编译型总秒, 解释型总秒
print(2 / 0.49)                                  # 4.08... 临界运行次数

把这道题的结论放进工程语境：地面试验的数据处理脚本，一天改二十遍、每版跑一次，解释型语言让工程师的节奏不被「等编译」打断；而装机交付的成品控制软件，固化后要在设备上连续运行几年——编译一次、终身全速，编译型的账算得漂亮。「选语言」的第一问从来不是「哪个好」，而是「这个东西改得勤不勤、跑得久不久」。

辨析一个进阶事实：编译与解释的边界并不是非黑即白。现代 Python 其实内部有「字节码」中间层——解释器先把源码快速编译成一种中间形态（字节码文件），再由内置的虚拟机逐条执行；Java、C# 更是「半编译半解释」的典型。所以严谨的说法是：两种「翻译时机策略」构成一个光谱，多数语言各取所需。入门阶段你只需抓住本质模型——先翻后跑 vs 边翻边跑——其余细节等你真正需要时自然会回来补。

翻译时机之外，选语言还有第二把尺子：动态类型 vs 静态类型。C、Java 这类静态类型语言要求写代码时就声明每个变量的类型（如 int x;），翻译阶段就逐行核对「类型对不对」，错误在程序跑起来之前就被拦住；Python 这类动态类型语言不写声明，变量的类型是运行到那一刻「实际装了什么」就是什么——写起来轻快、改起来灵活，但类型错误会藏到运行时才爆出来。取舍很务实：改得勤、试得快的探索型工作，动态类型省事；几十万行、要跑十年的大系统，静态类型把错误提前到上线之前。有趣的是两个世界正在互相取经：Python 3.5 起支持「类型注解」——下面代码里冒号后的 int 和箭头后的 int 就是，给动态语言补上人和工具都能检查的类型提示，却不改变运行方式。第 5 章会正面讲类型系统，到时候值得回来重读这一段。

def double(x: int) -> int:   # 冒号后是「类型注解」：提示但不强制
    return x * 2
print(double(21))            # 42：注解帮人和工具看懂代码，不改变运行方式

3.3安装 Python 解释器

要跑 Python 代码，电脑上必须装一个 Python 解释器。安装很简单，分三步：

1. 打开 Python 官网 python.org，进入 Downloads（下载）页面。
2. 下载适合你系统的安装包（Windows 用户下载 Windows installer，Mac 用户下载 macOS installer）。
3. 运行安装程序。注意：Windows 上务必勾选「Add Python to PATH」（把 Python 加入系统路径）这一项，否则后面在命令行里会找不到 Python。

分系统看一眼：三种平台各自的路

Windows：官网下载 installer，双击运行。安装界面第一屏的最下方就有「Add Python to PATH」复选框——默认不勾，请务必亲手勾上。想更稳妥，可点「Customize installation」自定义安装，确认勾选 pip（包管理器）与 py launcher（Python 启动器）等组件，再一路下一步。装完后在命令行验证（见下）。

macOS：官网提供 pkg 安装包，双击安装即可；会用终端的开发者也可以选择包管理器（如 Homebrew），在终端执行 brew install python 后由其统一管理升级。要留意一点：部分 macOS 自带一个仅供系统使用的旧版本，直接敲 python 可能唤起它——用 python3 这个名字调用新装的版本更保险。

Linux：多数发行版出厂已预装 Python（系统组件依赖它），但未必是你要的版本。终端里用包管理器即可安装或升级，例如 Debian/Ubuntu 系执行 sudo apt install python3，Fedora 系执行 sudo dnf install python3。Linux 上命令名几乎总是 python3 而不是 python——历史上后者曾被留给 Python 2。

装完后，要验证一下是否成功。打开「命令行」或「终端」（Windows 上可按 Win + R 输入 cmd 回车），输入：

python --version

如果屏幕上出现类似 Python 3.12.x 的字样，说明解释器装好了。这个命令的意思就是「问解释器：你是什么版本？」（macOS 与 Linux 用户如遇不识别，请改试 python3 --version。）

PATH：为什么漏勾一个复选框，命令行就「找不到 Python」

那个加粗提醒的「Add Python to PATH」到底勾的是什么？要理解它，先认识 PATH（系统路径）：它是操作系统维护的一张「目录清单」——你在命令行敲下 python 时，系统不会满盘乱找，而是按这张清单的顺序，逐个目录翻找有没有一个叫 python（或 python.exe）的可执行文件：找到就启动，清单翻完还没有，就报「不是内部或外部命令」。安装程序勾选「Add Python to PATH」，本质就是把 Python 安装目录登记进这张清单。漏勾的后果很好预见：Python 明明装了，清单里却没有它——系统自然「找不到」。

补救办法有两条路：一是重跑一遍安装程序，在「Modify（修改）」模式下补勾 PATH 那一项，最省心；二是手动把安装目录（形如 C:\Users\你的用户名\AppData\Local\Programs\Python\Python312）追加进系统环境变量的 Path 里。理解了 PATH 的机制，你还能顺手理解一类工程常见问题：「工具明明装了、命令行就是找不到」，八成是同一张清单出了岔子——排查思路完全一样。

顺带解开一个 Windows 特有的疑惑：装完 Python，命令行里有时能用的不止一个名字——python 和 py。py 是安装包附带的「启动器」，它像一个总调度：查一遍系统里装了哪些 Python 版本，默认挑最新的给你，也可以用 py -3.8 这样的写法点名某个版本。而 python 这个名字则完全交给 PATH 清单决定，指向谁就是谁。所以「py 能用、python 不能用」在 Windows 上非常常见——不是装坏了，是两个名字走的是两条查找路径。搞清这点，你能少走很多弯路。

再补一个工程视角：正式的工程交付讲究环境一致性——同一份脚本，在你机器上跑得好好的，换台机器报错，多半是两边 Python 版本或依赖库不同。所以从今天起养成一个习惯：给别人脚本时，顺带注明「用什么版本跑过」；接手别人的脚本时，先查 python --version。这个习惯将来对接正式的数据交付与追溯时，价值巨大。

再往前预告半步：当你的项目越攒越多，会发现不同项目想要不同版本的 Python 或不同版本的库——它们挤在同一台机器上难免打架。业界的解法叫「虚拟环境」：给每个项目单独圈一块互不干扰的运行环境。这个概念现在不用动手，知道「有这么个东西、它解决什么问题」即可；等第 11、12 章项目实战需要时，我们会正式把它请出来。工具总是在问题出现时学最快，提前死记反而记不住。

辨析一组容易张冠李戴的东西：解释器、编辑器、IDE。解释器负责「翻译并执行」你的代码，是今天的主角；编辑器（记事本、Notepad++、VS Code 等）只负责「把代码写出来、存成文件」，自己不运行任何代码；IDE（集成开发环境）则是「编辑器 + 调试器 + 各种辅助工具」的套装。初学阶段不需要 IDE：一个解释器加任意文本编辑器就能完成本课程全部练习——少一层工具，就少一层与学习无关的干扰。等你写到几十行的多文件项目时，再自然过渡到 IDE。

3.4你的第一个程序：Hello, World!

几乎所有编程教程的第一个程序，都是让计算机打印一句 Hello, World!。这已经成了程序员的「成人礼」。我们来写它，并逐字理解。

先新建一个文本文件，命名为 hello.py（.py 是 Python 代码文件的扩展名），在文件里写入这一行：

print("Hello, World!")

然后在命令行里，切换到文件所在目录，运行：

python hello.py

屏幕上会显示：

Hello, World!

这一行代码，逐字拆解

别看只有一行，它里面藏着好几个关键概念，我们一个个看：

整句话翻译成大白话就是：「调用名为 print 的功能，把引号里的文字显示到屏幕上」。

Hello, World 的两个幕后细节

第一个细节：这句话的「祖师爷」。1972 年前后，贝尔实验室的教程文档第一次用「让机器打个招呼」当作示例；后来一本影响深远的 C 语言教材沿用它开篇，从此「新语言的第一课 = Hello, World」成了全球惯例。它被选中的理由很实在：一行代码，就能同时验证「环境装好了、能建文件、能运行、能输出」四件事——本质上是一次最小化的全链路自检。你以后每到一个新环境（新电脑、新服务器、新容器），跑通它的第一个程序都应该是这句老话。

第二个细节：保存文件时的编码。源代码文件是纯文本，中文注释能否正常显示取决于文件用什么编码保存——请把编辑器的默认编码设为 UTF-8。要是你在别人电脑上打开代码看到满屏乱码，第一反应就该是「查编码」，而不是怀疑代码坏了。这个话题在第 5 章讲字符与字符串时会正式展开。

还有一个值得知道的演化细节：print 后面的括号并不是从来就有的。早年的 Python 2 里，print 是一种「语句」，写 print "Hello" 不带括号也能跑；Python 3 把它统一改成了函数，必须写括号。这次改动当年引发不少争论，但方向是对的：「显示数据」和「计算数据」一样，都规规矩矩走「名字 + 括号」的调用格式，整个语言的一致性更好了。你在网上查资料时如果撞见不带括号的 print，多半是 Python 2 时代的老代码——认得出它，也是一种本领。

print(123 * 456)      # 数值：56088
print("2" + "3")      # 字符串拼接：23
print(2 + 3)          # 数值加法：5

把例题 4 的发现放大成工程习惯：REPL 就是一台随身的工程计算器。现场要验算一个单位换算、心算没把握的一笔数、想快速试一下「这个函数到底返回什么」——开个 REPL 敲一行，答案立刻回来，比掏手机计算器还快，而且能连着上一步的结果继续算。工程师的键盘上，这个「问一句答一句」的窗口，是最高频打开的工具之一。

关于 print 再透露一个马上会用到的小本领：它一次不止能显示一样东西。试试 print("合格数：", 8)——用逗号把文字和数字隔开传给它，输出会是 合格数： 8，中间自动补了一个空格。这样一来，「给人看的报告」就不必把数字硬拼进文字里。为什么会有这个效果、逗号在这里叫什么名字，第 4 章讲函数参数时会正面回答——现在你只需知道：print 的本领比初见时大。

3.5程序从代码到输出的完整旅程

现在我们把整条链串起来，看你在命令行敲下 python hello.py 回车后，一分钟内发生了什么：

1. 启动解释器：命令 python 让系统找到并启动 Python 解释器。
2. 读取源码：解释器打开 hello.py，读入里面的文字 print("Hello, World!")。
3. 逐行翻译执行：解释器把这行代码翻译成机器能懂的指令，交给 CPU 执行。
4. 执行 print：CPU 执行后，效果是把 "Hello, World!" 这串文字送到屏幕。
5. 程序结束：没有更多代码了，解释器退出，命令行重新等你输入。

REPL vs 脚本：一对分工不同的搭档

其实从上一节开始，你已经在两种「使用 Python 的方式」之间穿行了，现在正式把它们摆上台面。脚本方式：把代码写进 .py 文件，用 python 文件名 整份执行——上面五步旅程说的就是它。REPL 方式（Read-Eval-Print Loop，读取-求值-打印循环）：在命令行只敲 python 不带文件名，解释器打开一个交互窗口，出现 >>> 提示符，你敲一行、它应答一行，直到你退出。两者跑的是同一个解释器，差别只在「喂代码的方式」：脚本是一口气喂整份，REPL 是一口一口喂。

逐行执行还有一个对日常开发影响很大的推论：错误在哪一行，程序就停在哪一行。脚本从头跑到出事的那行为止，前面的行已经执行完毕、效果保留；REPL 则更宽容——上一行敲错了，改掉重敲就行，不用从头来过。这就是为什么试错、探索用 REPL 舒服：每一次「改一点、再看一眼」的循环都最短。

这也带出了本书从头到尾的练习方法：凡是新概念，先扔进 REPL 里戳一戳。学到一个新函数，别急着写进大程序，先在 REPL 里喂它两三个不同的输入，看它吐什么——像做小规模试验一样做「概念试验」。一次 REPL 探索，比读三遍文字描述更能建立直觉；等你能在 REPL 里预测出它的行为，再把它正式写进脚本也不迟。这个「先试验、后组装」的节奏，正是工程师面对陌生设备的标准姿势，用在语言学习上同样有效。

# 文件一 a.py 的内容只有一行：
1 + 2

# 运行 python a.py —— 屏幕无任何输出，直接结束

# 文件二 b.py 的内容只有一行：
print(1 + 2)

# 运行 python b.py —— 屏幕显示：3

给这对搭档一张分工对照表，替你未来的日常工作做决定：

工程数据工作里有一条不成文的铁则：「试验型」的探索进 REPL，「交付型」的计算进脚本。凡是将来要给别人看、要复现、要追溯的计算，哪怕只有五行，也写成 .py 文件保存——因为脚本连同它的运行结果一起构成「计算留痕」；REPL 里算出的东西，关掉窗口就散了。第 11 章讲文件读写时，这条铁则会升级成完整的工程实践。

最后把这一章放进整本书的路线图里：到这里，你的「环境」已经完全就绪——解释器会装会验、代码会写会跑、REPL 会问会答、出错知道从哪查起。从第 4 章开始，我们将正式进入编程的核心内容：变量与内存。写作策略也会升级：每章的例题会越来越像真实的工程任务，而不再只是演示概念的小实验。请保持本章建立的动手习惯——每段代码都亲手跑一遍，每个结果都自己预测一遍再验证——它比任何阅读技巧都更能让你把这门手艺学到手。