Python-01-环境与基础语法
本篇讲什么
这是 Python 系列的第一篇,解决两个问题:把环境装对、把语法写对。
内容包括:Python 的定位与设计哲学、CPython 从源码到执行的完整链路、Windows/Linux/macOS 多版本管理、变量与对象的绑定模型、内置类型概览、数字与字符串的常见精度陷阱、运算符与优先级、流程控制、
input()与类型转换、PEP 8 代码风格。读完后你应该能独立写出一个带输入、判断、循环、格式化输出的命令行脚本,并解释"为什么
0.1 + 0.2 != 0.3"这类问题。
一、是什么:Python 的定位
Python 是一门动态类型、强类型、面向对象、解释执行的通用编程语言,由 Guido van Rossum 于 1991 年发布。它的官方格言是"优雅、明确、简单",设计目标排第一位的是可读性,而不是极致性能。
理解 Python 的三个关键定语:
| 定语 | 含义 | 反例对照 |
|---|---|---|
| 动态类型 | 类型信息附着在对象上,不附着在变量名上;同一个名字可先后绑定不同类型的对象 | C#/Java 中 int x = 1 后 x 永远是 int |
| 强类型 | 不同类型之间不会悄悄做"看起来合理"的隐式转换 | JavaScript 中 "1" + 1 == "11"、[] + {} == "[object Object]" |
| 解释执行 | 源码先编译成字节码,再由虚拟机逐条执行,没有独立的可执行文件产物 | C# 编译为 IL 后由 CLR 执行,但会生成程序集文件 |
动态 + 强类型意味着什么
动态类型让写法灵活(不用声明类型、可以写"鸭子类型"的代码),强类型让错误更早暴露:Python 里
"1" + 1直接抛TypeError,而不是给你一个含义不明的结果。灵活性的代价是类型错误只能在运行时发现,所以工程上要靠类型注解与单元测试补回来,见 Python-07-进阶特性 与 工具-04-测试基础。
设计哲学:Zen of Python
在解释器里执行 import this 会打印 Tim Peters 写下的 19 条格言(第 20 条"命名空间是个绝妙的主意"是后来补的玩笑)。其中对日常写代码影响最大的几条:
- 优美胜于丑陋(Beautiful is better than ugly)
- 显式胜于隐式(Explicit is better than implicit)
- 简单胜于复杂(Simple is better than complex)
- 可读性很重要(Readability counts)
- 错误不应该被悄悄忽略(Errors should never pass silently)
- 应该有一种——最好只有一种——显而易见的方式来做一件事
这些句子不是文学装饰,它们直接解释了很多语言设计决策:为什么不支持 ++、为什么缩进是语法的一部分、为什么 list.sort() 返回 None(避免你以为它返回了新列表)。
二、为什么这样设计
| 设计决策 | 动机 | 代价 |
|---|---|---|
| 用缩进划分代码块 | 强制所有 Python 代码视觉结构一致,"可读性"从语法层面保证 | 缩进错就是语法错误;不能像 C 一样压缩成一行 |
| 变量无需声明类型 | 降低入门门槛,便于写脚本、做数据处理 | 大型项目需要类型注解 + 静态检查工具(mypy/pyright) |
| 名字只是"贴纸" | 赋值语义简单统一:一切都是引用绑定,没有值拷贝的隐式行为 | 初学者容易误以为 b = a 复制了数据,实际是共享对象 |
| 内置"电池齐全" | 标准库覆盖 json、re、datetime、sqlite3、http 等,装完即用 | 标准库风格不统一,部分模块较老 |
用缩进替代花括号的另一种体现:显式 self、显式 import | 阅读代码时不需要猜名字来自哪里 | 写起来略啰嗦 |
核心结论
Python 的设计取舍是"用一点运行性能换大量人的时间"。它不追求跑得最快,而追求写得快、读得快、改得快。需要性能时走的是"把热点交给 C 扩展/NumPy/JIT"的路线,而不是把语言本身变复杂。
三、核心内容
3.1 解释型与编译型:其实是光谱
"解释型 vs 编译型"是一个过于简化的二分法。真实情况是:任何语言实现都要做"翻译",区别在于翻译发生的时机、产物形态与优化程度。
| 维度 | 典型编译型(C/C#/Rust) | Python(CPython) | JIT 实现(PyPy) |
|---|---|---|---|
| 翻译时机 | 运行前一次性完成 | 每次运行前把源码编译成字节码 | 运行中边执行边编译热点 |
| 产物 | 机器码 / 程序集 / 可执行文件 | .pyc 字节码缓存(可删除) | 无独立产物 |
| 跨平台方式 | 重新编译 | 同一份 .py 到处跑(需目标机有解释器) | 同 CPython |
| 启动速度 | 快 | 中等(需解析 + 编译) | 慢(要热身) |
| 峰值速度 | 快 | 慢(纯 Python 循环通常慢 10~100 倍) | 可能反超 C 实现 |
3.2 CPython 执行流程
CPython 是官方实现(也是绝大多数人说的"Python")。它执行一个 .py 文件的过程:
源码 file.py
│ ① 词法分析 + 语法分析(tokenize / parser)
▼
抽象语法树 AST ← 可用 ast 模块查看
│ ② 编译(compile)
▼
代码对象 code object ← 可用 dis 模块反汇编看字节码
│ ③ 写入 __pycache__/file.cpython-312.pyc(缓存,下次跳过 ①②)
▼
字节码 bytecode
│ ④ PVM(Python Virtual Machine,ceval.c 里的大循环)逐条执行
▼
执行结果
关键点:
- 第 ④ 步的 PVM 是一个用 C 写的
for循环 + 巨型switch,每条字节码都要在这个循环里过一次,所以"解释执行"的开销主要在这里。 .pyc缓存只缓存编译结果,不缓存运行结果;源码改动或解释器版本变化都会让它失效。- 每条字节码对应一次"取值 → 分派 → 执行",因此同样逻辑的 Python 代码行数越少、内建函数用得越多,通常越快(因为循环下沉到了 C 层)。
3.3 安装与多版本管理
| 场景 | 推荐做法 | 注意事项 |
|---|---|---|
| Windows 学习/开发 | 从 python.org 下载官方安装器 | 勾选 Add python.exe to PATH,否则命令行找不到 python |
| Windows 多版本共存 | 使用官方 py 启动器(launcher):py -0 列出已装版本,py -3.12 -m pip ... 指定版本 | 启动器由安装器安装,见官方文档 |
| Linux | 用发行版包管理器或 pyenv;命令通常是 python3 | 很多发行版默认没有 python(只有 python3),因为 python 曾指向 Python 2 |
| macOS | Homebrew 或 python.org 安装器,命令是 python3 | 系统自带的 /usr/bin/python3 由 Xcode 提供,不要往里装包 |
| 项目隔离 | python -m venv .venv | 详见 [[Python-08-虚拟环境与包管理]] |
| 包安装 | python -m pip install xxx | 用 python -m pip 而不是裸 pip,可保证装到"当前解释器"里 |
三个启动命令的区别:
| 命令 | 来自哪里 | 说明 |
|---|---|---|
python | 环境变量 PATH 中找到的第一个 python.exe | Windows 上若未正确安装,可能命中微软商店的"应用执行别名"占位程序 |
python3 | 通常来自微软商店版本 / Linux / macOS | Linux/macOS 的规范写法;Windows 官方安装器不保证提供 |
py | Windows 专属启动器 py.exe | 支持 py -3.12、py -0、读取 shebang,是多版本共存的正确姿势 |
Windows 上"运行 python 却打开了微软商店"
Windows 10/11 预置了一个名为
python.exe/python3.exe的应用执行别名(App Execution Aliases),它只是跳转到微软商店的占位程序。当你没有安装 Python、或安装时没把 Python 加入 PATH 时,敲python就会弹出商店页面。处理办法:安装官方 Python 并勾选 Add to PATH;或到「设置 → 应用 → 高级应用设置 → 应用执行别名」里关闭
python.exe/python3.exe两个开关。用where python可以看到 PATH 中到底命中了哪个文件。官方正在推进新的 Windows 安装管理器(PEP 773),相关行为以官方最新文档为准。
3.4 交互式解释器与脚本
| 方式 | 命令 | 适合 |
|---|---|---|
| REPL(交互式) | python | 试验语法、算一个表达式、查看对象属性 |
| 执行脚本 | python script.py | 正式程序 |
| 执行一次性代码 | python -c "print(1+1)" | 命令行小工具、CI 里的一行脚本 |
| 执行模块 | python -m json.tool data.json | 把包当脚本运行(-m 会把当前目录加入 sys.path) |
| 执行后进入 REPL | python -i script.py | 调试:脚本跑完后变量还在,可继续检查 |
| 交互式加载模块 | python -m pdb script.py | 断点调试,见 [[工具-07-调试技巧]] |
3.5 变量的本质:名字绑定到对象
Python 里没有"变量盒子"模型,只有名字(name)→ 对象(object)的绑定。
a = [1, 2, 3]
b = a # 不是复制列表,而是让 b 也指向同一个列表对象
b.append(4)
print(a) # [1, 2, 3, 4]:a 和 b 是同一个对象的两个名字
print(a is b) # True
三个必须分清的概念:
| 概念 | 函数/运算符 | 含义 |
|---|---|---|
| 身份(identity) | id(obj)、is | 对象在内存中的唯一标识;CPython 里 id() 返回对象地址 |
| 类型(type) | type(obj)、isinstance() | 对象所属的类 |
| 值(value) | == | 由 __eq__ 决定的相等性 |
is与==的分工
is比较身份(是不是同一个对象),==比较值(内容是否相等)。判断"是不是 None / True / False"用
is(单例对象,最快且不会被重载的__eq__干扰);判断数值、字符串内容一律用==。不要用
is比较整数和字符串——小整数(-5~256)和部分字符串会被缓存/驻留,导致"有时为 True 有时为 False"的诡异现象。
3.6 七类内置类型概览
按官方文档「内置类型」的类别归纳成七类,先建立地图,细节在后面几篇展开:
| # | 类别 | 具体类型 | 可变性 | 典型用途 |
|---|---|---|---|---|
| 1 | 数字(Numeric) | int、float、complex | 不可变 | 计算;int 任意精度 |
| 2 | 序列(Sequence) | list、tuple、range | list 可变,其余不可变 | 有序集合 |
| 3 | 文本序列(Text Sequence) | str | 不可变 | 文本处理 |
| 4 | 二进制序列(Binary Sequence) | bytes、bytearray、memoryview | bytes 不可变,bytearray 可变 | 网络/文件字节流 |
| 5 | 集合(Set) | set、frozenset | set 可变,frozenset 不可变 | 去重、成员判断、集合运算 |
| 6 | 映射(Mapping) | dict | 可变 | 键值查找 |
| 7 | 布尔与空值 | bool、NoneType | 不可变 | 逻辑判断、缺省占位 |
补充三点:bool 是 int 的子类(True + True == 2);NoneType 只有一个实例 None;函数、类、模块本身也是对象,所以"一切皆对象"。
3.7 数字类型与精度陷阱
整数 int 是任意精度的,不会溢出(代价是大数运算变慢)。浮点 float 是 IEEE 754 双精度,共 64 位:1 位符号、11 位指数、52 位尾数,表示为
因此只有分母是 2 的幂的分数能被精确表示,、、 都不能。它们各自带上舍入误差后再相加,结果就落在 的最近可表示值之外:
print(0.1 + 0.2) # 0.30000000000000004
print(0.1 + 0.2 == 0.3) # False
print(f"{0.1:.20f}") # 0.10000000000000000555:0.1 本身就不精确
需要精确十进制(金额、会计)时用 decimal.Decimal;需要精确分数时用 fractions.Fraction。
整除与取模的正负号规则(唯一需要背的规则:// 向下取整,% 的结果符号与除数一致):
| 表达式 | 结果 | 说明 |
|---|---|---|
7 / 2 | 3.5 | 真除法永远返回 float |
7 // 2 | 3 | 向下取整 |
-7 // 2 | -4 | 向下取整,不是向零截断 |
7 // -2 | -4 | 同上 |
-7 // -2 | 3 | 同上 |
-7 % 3 | 2 | 结果符号与除数 3 相同 |
7 % -3 | -2 | 结果符号与除数 -3 相同 |
divmod(-7, 3) | (-3, 2) | 恒等式 |
3.8 字符串
str 是不可变的 Unicode 码点序列,所以"修改字符串"的每一步都在创建新对象:
s = "Python"
s2 = s.upper() # 新对象
print(s, s2) # Python PYTHON:原字符串没变
切片规则 s[start:stop:step]:取头不取尾,负索引表示从右往左数(-1 是最后一个),步长为负时反向取值。
| 表达式 | 结果 | 说明 |
|---|---|---|
"Python"[1:3] | 'yt' | 下标 1、2 |
"Python"[-3:] | 'hon' | 后三个 |
"Python"[:3] | 'Pyt' | 省略 start 即从头 |
"Python"[::-1] | 'nohtyP' | 反转(返回新串) |
"Python"[5:1:-1] | 'noht' | 从 5 倒着取到 2 |
"Python"[10:20] | '' | 越界不报错 |
常用格式化方式三代同堂,新代码一律用 f-string:
| 方式 | 写法 | 引入版本 | 备注 |
|---|---|---|---|
% 格式化 | "%s: %d" % (name, age) | 远古 | 只读老代码时需要认识 |
str.format | "{}: {}".format(name, age) | 2.6 | 需要复用参数/复杂对齐时仍有价值 |
| f-string | f"{name}: {age}" | 3.6(PEP 498) | 最快、最直观,支持表达式与格式说明符 |
| t-string | t"{name}" | 3.14(PEP 750) | 模板字符串,主要用于安全拼接,以官方最新文档为准 |
3.9 布尔与真值测试
if x: 会调用 x.__bool__()(没有则退回 __len__())。假值(falsy)只有这些,其余都是真:
False, None, 0, 0.0, 0j, "", b"", [], (), {}, set(), range(0)
这带来两个高频坑:空列表被当成"没有数据"(通常是好事),而 0 和 "" 作为合法数据时会被误判为"没有数据"。
3.10 运算符与优先级
优先级从高到低(不必背全,记住"算术 > 比较 > not > and > or"并用括号消歧即可):
| 优先级 | 运算符 | |
|---|---|---|
| 1(最高) | ** | |
| 2 | 一元 +x、-x、~x | |
| 3 | *、@、/、//、% | |
| 4 | +、- | |
| 5 | <<、>> | |
| 6 | & | |
| 7 | ^ | |
| 8 | `\ | ` |
| 9 | 比较:in、not in、is、is not、<、<=、>、>=、!=、== | |
| 10 | not x | |
| 11 | and | |
| 12 | or | |
| 13 | 条件表达式 a if c else b | |
| 14 | lambda | |
| 15 | 海象运算符 := |
| 运算符 | 含义 | 易错点 |
|---|---|---|
/ | 真除法,返回 float | 4 / 2 == 2.0 而不是 2 |
// | 向下取整除法 | 负数上不是截断 |
% | 取模 | 符号随除数 |
** | 幂 | 2 3 2 == 2 ** 9(右结合) |
and / or | 返回操作数本身,不是布尔值 | "" or "默认" 得到 "默认" |
:= | 表达式内赋值 | 3.8+,见 PEP 572 |
| 链式比较 | 1 < x < 10 | 等价于 1 < x and x < 10,且 x 只求值一次 |
3.11 流程控制
| 结构 | 语法 | 说明 |
|---|---|---|
| 条件 | if / elif / else | 没有 switch,3.10+ 可用 match(软关键字) |
| 前测循环 | while cond: | 条件为假时一次都不执行 |
| 迭代循环 | for x in iterable: | 只能用于"可迭代对象",没有 C 风格三段式 |
| 计数循环 | for i in range(n): | range 是惰性序列,不占内存 |
| 提前结束 | break | 跳出最近一层循环 |
| 跳过本次 | continue | 进入下一轮 |
循环 else | for ... else: | 没被 break 中断时执行,适合"查找未命中"场景 |
range 的三种形态与复杂度:
| 写法 | 生成 | 成员判断 x in range(...) |
|---|---|---|
range(5) | 0,1,2,3,4 | (数学判定,不遍历) |
range(2, 10, 3) | 2,5,8 | |
range(10, 0, -1) | 10..1 |
range是惰性的
range(109)不占 10 亿个整数的内存,它只存 start/stop/step 三个数字,迭代时按需生成。所以list(range(109))才会真的吃掉内存。
3.12 input() 与类型转换
input() 永远返回 str,想要数字必须显式转换。int() 是向零截断(不是四舍五入),round() 用的是"银行家舍入"(.5 时取偶):
| 表达式 | 结果 | 说明 |
|---|---|---|
int("42") | 42 | 十进制解析 |
int("0x1f", 16) / int("1f", 16) | 31 | 指定进制 |
int(3.9) | 3 | 向零截断 |
int("3.9") | 报 ValueError | int() 不吃小数字符串,要 float() 中转 |
round(0.5) / round(1.5) / round(2.5) | 0 / 2 / 2 | 银行家舍入:取最近的偶数 |
round(2.675, 2) | 2.67 | 因为 2.675 实际是 2.67499… |
3.13 代码风格 PEP 8 要点
| 项目 | 规范 |
|---|---|
| 缩进 | 4 个空格,不要混用 Tab 和空格 |
| 行长 | 一般 79 字符;团队可约定 99(PEP 8 明确允许团队统一放宽) |
| 命名 | 变量/函数 snake_case;类 CapWords;常量 UPPER_CASE;内部用 _前缀 |
| 空行 | 顶层函数/类之间 2 行,类内方法之间 1 行 |
| 导入 | 文件顶部,标准库 / 第三方 / 本地 三组,组间空行;一行一个模块;禁止 from x import * |
| 空格 | 运算符两侧加空格;但默认参数、关键字实参的 = 两侧不加:def f(x=1)、f(x=1) |
| 比较 | is None 而不是 == None;布尔值不要写 if x == True: |
| 工具 | ruff(快,推荐)或 flake8 + black 自动格式化,见 [[工具-06-编辑器与IDE]] |
四、怎么用(可运行示例)
4.1 第一个脚本:三种运行方式
# demo.py —— 保存后用 python demo.py 运行
"""最小可运行的脚本:演示入口、导入与格式化输出。"""
import sys # 标准库位于文件顶部
def main() -> None:
# sys.version_info 让我们能根据解释器版本调整行为(版本敏感分支的标准写法)
major, minor = sys.version_info[:2]
print(f"运行在 Python {major}.{minor}")
print(f"解释器路径:{sys.executable}")
# 只有被直接执行时才运行 main(),被 import 时不会运行
# 原理见 Python-03-函数与模块
if __name__ == "__main__":
main()
命令行对照:
python demo.py # 执行脚本
python -c "print(1 + 1)" # 执行一行代码,输出 2
python -i demo.py # 跑完后进入交互式解释器,变量仍在
python -m json.tool data.json # 把标准库模块当命令用
4.2 交互式解释器里最常用的几件事
>>> 2 ** 100 # 大整数不溢出
1267650600228229401496703205376
>>> _ * 2 # 下划线保存上一个结果
2535301200456458802993406410752
>>> help(str.split) # 查看文档(q 退出)>> dir("") # 列出字符串所有方法>> exit() # 退出(Windows 也可 Ctrl+Z 回车,Unix 是 Ctrl+D)
4.3 变量、id()、is 与 ==
a = [1, 2, 3]
b = a # 绑定同一个对象
c = list(a) # 浅拷贝:新列表,元素仍共享
d = a[:] # 同样是浅拷贝
print(a is b, a is c) # True False —— is 比较身份
print(a == c, a == b) # True True —— == 比较内容
print(id(a) == id(b)) # True
# 小整数缓存:CPython 预建了 -5..256 的整数对象
print(int("256") is int("256")) # True
# 257 不在缓存里:同一条语句内可能被常量折叠成同一个对象,
# 分成两次编译(如 REPL 里逐行输入)就是两个对象
ns = {}
exec("x = 257", ns)
exec("y = 257", ns)
print(ns["x"] is ns["y"]) # False —— 所以永远不要用 is 比较整数
4.4 数字:精确计算与负数取模
from decimal import Decimal
from fractions import Fraction
# 1) 浮点误差:比较浮点数要用容差,而不是 ==
import math
print(0.1 + 0.2 == 0.3) # False
print(math.isclose(0.1 + 0.2, 0.3)) # True(相对容差 1e-9)
# 2) 需要精确十进制时用 Decimal,注意必须用字符串构造
print(Decimal("0.1") + Decimal("0.2") == Decimal("0.3")) # True
print(Decimal(0.1)) # 0.1000000000000000055511151231257827021181583404541015625
# 3) 精确分数
print(Fraction(1, 3) + Fraction(1, 6)) # 1/2
# 4) 整除/取模恒等式:a == (a // b) * b + (a % b)
for a, b in [(-7, 3), (7, -3)]:
q, r = divmod(a, b)
# 断言恒等式,顺便验证 % 的符号跟除数走
assert a == q * b + r
print(f"{a} = {q} * {b} + {r}")
4.5 字符串:切片、方法与 f-string
name, age = "Ada", 36
city = "London"
# f-string 支持任意表达式、格式说明符、以及 3.8+ 的 = 调试写法
print(f"{name} is {age} years old, living in {city}.")
print(f"{name=}, {age * 2=}") # 变量名也打印出来,排查问题很方便
print(f"{3.14159:.2f} | {1234567:,} | {0.256:.1%}") # 3.14 | 1,234,567 | 25.6%
# 常用方法(全部返回新字符串,原字符串不变)
s = " Hello, World "
print(s.strip()) # 去两端空白
print(s.strip().lower()) # 转小写
print("-".join(["a", "b", "c"])) # a-b-c:join 是"用分隔符拼接"
print("a,b,,c".split(",")) # ['a', 'b', '', 'c']:split 保留空字段
print("a b".split()) # ['a', 'b']:不带参数时按任意空白切且丢空串
print("file.tar.gz".removesuffix(".gz")) # 3.9+,比 rstrip 安全
print("3".zfill(3)) # 003
# 多行字符串:三引号保留换行,textwrap.dedent 去掉缩进
import textwrap
sql = textwrap.dedent("""
SELECT id, name
FROM users
WHERE age > :age
""").strip()
print(sql)
4.6 真值测试与 and/or 的返回值
items = []
# 推荐:直接用真值测试
if not items:
print("列表为空")
# and / or 返回的是操作数本身,可用来给默认值(注意 0 与 "" 也会被替换掉)
def greet(name: str | None) -> str:
return f"Hello, {name or 'guest'}"
print(greet(None)) # Hello, guest
print(greet("Ada")) # Hello, Ada
# 更精确的默认值写法:区分"没传"和"传了 0/空串"
def retry(times: int | None = None) -> int:
times = 3 if times is None else times # 显式 is None 判断,不会被 0 干扰
return times
print(retry(0), retry(None))
4.7 流程控制:for、while 与循环 else
# for + range:打印乘法表的一行
for i in range(1, 4):
print(" ".join(f"{i}x{j}={i * j}" for j in range(1, 4)))
# while + break:带最大重试次数的轮询
attempt = 0
while True:
attempt += 1
if attempt >= 3: # 模拟"第三次成功"
print(f"第 {attempt} 次尝试成功")
break
print(f"第 {attempt} 次失败,重试")
# for ... else:查找未命中时才走 else,不需要 flag 变量
target = 7
for n in [1, 3, 5, 9]:
if n == target:
print("找到了", n)
break
else:
print(f"列表里没有 {target}") # 会被执行
# continue:跳过偶数
odds = []
for n in range(10):
if n % 2 == 0:
continue
odds.append(n)
print(odds) # [1, 3, 5, 7, 9]
4.8 input() 与健壮的输入转换
def ask_int(prompt: str, default: int = 0) -> int:
"""读取一个整数:非法输入时提示重来,空输入时用默认值。"""
while True:
raw = input(prompt).strip()
if not raw: # 直接回车 → 用默认值
return default
try:
return int(raw)
except ValueError: # int() 失败说明不是合法整数
print("请输入整数,例如 42")
if __name__ == "__main__":
n = ask_int("请输入一个整数(直接回车默认 0):")
print(f"你输入的是 {n},它的平方是 {n ** 2}")
4.9 端到端小例子:成绩统计
"""读取一组 '姓名,分数' 文本,输出统计结果。"""
raw = """Ada,92
Bob,78
Cindy,85
Dan,59"""
rows = [line.split(",") for line in raw.splitlines()]
scores = {name: int(score) for name, score in rows} # 字典推导式,详见 Python-02
total = sum(scores.values())
average = total / len(scores)
passed = [name for name, s in scores.items() if s >= 60]
print(f"人数:{len(scores)}")
print(f"总分:{total},平均分:{average:.2f}") # 保留两位小数
print(f"及格:{', '.join(passed)}")
print(f"最高分:{max(scores.items(), key=lambda kv: kv[1])}")
五、注意事项与常见坑
坑 1:用
is比较数字和字符串
is比较的是身份。CPython 会缓存小整数(-5~256)并驻留部分字符串,导致a = 256; a is 256为True、a = 257时结果取决于是否被常量折叠——同一行代码里是 True,REPL 分两次输入是 False。判断None/True/False用is,其余一律==。
坑 2:浮点数用
==比较
0.1 + 0.2 == 0.3是False。原因是 IEEE 754 双精度无法精确表示这些十进制小数,误差在运算后没有抵消。比较浮点要用math.isclose(a, b, rel_tol=..., abs_tol=...);涉及金额用Decimal(必须用字符串构造,Decimal(0.1)会把误差一起装进去)。
sum()在 3.12+ 变准了,但手工累加没变实测(CPython 3.12):
sum([0.1] * 10)返回1.0,而手工循环acc += 0.1十次得到0.9999999999999999。原因是 3.12 起sum()对浮点使用 Neumaier 补偿求和,而+=仍是逐次舍入。结论不变:不要依赖浮点等值比较,需要高精度就换Decimal或math.fsum(),详见 <https://docs.python.org/3/whatsnew/3.12.html>(以官方最新文档为准)。
坑 3:
//和%在负数上的行为
-7 // 2 == -4(向下取整,不是 -3),-7 % 3 == 2(符号跟除数)。做"分页""分桶""时间取整"时,如果可能出现负数(例如跨时区偏移),一定要用divmod()并断言 。
坑 4:
input()返回字符串
input()永远返回str,input() + 1会抛TypeError。而且用户可能输入3.5、abc、空串,所以真实程序里int(input())必须包try/except ValueError或循环重试。
坑 5:
round()不是"四舍五入"
round(0.5) == 0、round(2.5) == 2,因为 CPython 用的是银行家舍入(.5 取偶)。另外round(2.675, 2) == 2.67,这是浮点表示误差造成的,不是 bug。需要"商业四舍五入"时用Decimal配合ROUND_HALF_UP。
坑 6:
range(5)不包括 5所有切片与
range都是"取头不取尾"。写"1 到 100 的和"应是sum(range(1, 101))。同理s[1:3]只有两个字符。
坑 7:字符串不可变,别在循环里
+=拼接
s += x每次都创建新字符串,循环 次的成本是 (更准确地说,每次都要复制已累计的全部字符)。应先把片段放进列表再"".join(parts),整体 。相关复杂度分析见 算法-复杂度分析。
坑 8:Windows 控制台编码报错
在中文 Windows 上,默认控制台编码是 GBK,
"İ".casefold()的输出)会抛UnicodeEncodeError。解决办法:chcp 65001切 UTF-8、设置环境变量PYTHONIOENCODING=utf-8、或换 Windows Terminal。源码文件本身默认按 UTF-8 解码(PEP 3120),所以问题出在输出环节而不是源码。
坑 9:缩进混用与"看不见"的语法错误
Tab 与空格混用在不同编辑器里显示宽度不同,Python 3 直接报
TabError。统一 4 个空格,并让编辑器"按 Tab 插入空格"。另外if x:后面漏冒号、elif写成else if,都会在运行前就报SyntaxError。
实践建议
1. 项目一律用
python -m venv .venv建虚拟环境,避免污染全局(见 Python-08-虚拟环境与包管理)。2. 装完立刻跑
python -m pip install -U pip ruff,用 ruff 统一风格。3. 脚本开头写
if __name__ == "__main__":,让文件既能被导入也能被执行。4. 用
python -X dev打开开发模式,它会把部分警告升级为错误,提前暴露问题。
六、练习题
- 基础题:不使用循环,用一行表达式完成——给定
s = "hello world",输出首字母大写、其余小写、空格替换为下划线、并在末尾拼接当前长度(例如Hello_world_11)。
提示:str.title() 与 str.capitalize() 的行为差异自己试一下。
- 基础题:写一个函数
safe_div(a, b),返回a / b,当b == 0时返回None并打印一条提示;再写一段代码验证safe_div(1, 0)与safe_div(10, 4)的输出。
- 进阶题:给定总秒数(可能为负,表示"提前量"),用
divmod()转换成时:分:秒格式,要求负数也输出正确(-3661→-1:01:01,90061→25:01:01)。说明为什么不能直接把负数丢给divmod()再拼字符串。
- 进阶题:分别用 ①手工循环
acc += 0.1十次、②sum([0.1] 10)、③sum([Decimal("0.1")] 10)、④sum([Decimal(0.1)] * 10)求"十个 0.1 之和",用repr()打印每一项并解释差异;再给出"判断两个金额是否相等"的正确写法。
- 思考题:为什么 Python 把缩进变成语法的一部分,而 C#/JavaScript 用花括号?这种设计在团队协作、代码审查、自动化格式化(black/ruff)三方面分别带来什么好处与限制?结合 编程语言对比 谈谈你的结论。
七、常见问题(FAQ)
Q1:现在还要不要学 Python 2?
A:不要。Python 2 已于 2020-01-01 停止支持(EOL),且 Python 2/3 在字符串、整除、print 等基础语义上不同,混学只会制造混乱。遇到老代码时再针对性了解 from __future__ import、unicode 等差异即可。
Q2:敲 python 没反应、或者弹出了微软商店,怎么排查?
A:按顺序检查:① where python(PowerShell 用 Get-Command python)看命中的是哪个文件;② 若是 WindowsApps 下的占位程序,说明是"应用执行别名",去「设置 → 应用 → 高级应用设置 → 应用执行别名」关掉;③ 确认安装时勾选了 Add python.exe to PATH,或改用 py 启动器(py -0 列出已装版本、py -3.12 --version 验证)。
Q3:python 和 python3 到底有什么区别?
A:它们只是命令名,不是语言版本。Windows 官方安装器主要提供 python 和 py;Linux/macOS 上 python3 是规范名,很多发行版故意不提供 python。所以跨平台脚本用 python3 更保险,Windows 上则推荐 py。
Q4:我需要装 Anaconda 吗?
A:做数据科学/机器学习、需要 conda 管理非 Python 依赖(如 CUDA 库)时值得;日常开发与学习用官方 CPython + venv + pip 更轻、更贴近生产环境,也更容易排查"为什么换台机器跑不起来"。
相关笔记
- Python-02-内置数据结构 —— 下一步:列表、元组、字典、集合与推导式
- Python-03-函数与模块 —— 函数定义、作用域、模块与包
- Python-08-虚拟环境与包管理 —— venv、pip、依赖锁定与项目结构
- 编程语言对比 —— Python / C# / JavaScript 的类型系统与运行方式差异
- 算法-复杂度分析 —— 为什么循环里拼接字符串是
- 工具-02-命令行与Shell —— PATH、环境变量与命令行运行脚本
- 00-索引 —— 返回全库导航
参考来源
- Python 官方教程:<https://docs.python.org/3/tutorial/index.html>
- 流程控制与函数定义:<https://docs.python.org/3/tutorial/controlflow.html>
- 浮点数的表示与限制:<https://docs.python.org/3/tutorial/floatingpoint.html>
decimal模块(精确十进制运算):<https://docs.python.org/3/library/decimal.html>- 数据模型(对象、身份、类型、特殊方法):<https://docs.python.org/3/reference/datamodel.html>
- 词法分析(缩进、字符串字面量、f-string 语法):<https://docs.python.org/3/reference/lexical_analysis.html>
- Windows 上的 Python(安装器、py 启动器、应用执行别名):<https://docs.python.org/3/using/windows.html>
- 命令行与环境变量(
-c、-m、-i):<https://docs.python.org/3/using/cmdline.html> dis模块(查看字节码):<https://docs.python.org/3/library/dis.html>- PEP 20 The Zen of Python:<https://peps.python.org/pep-0020/>
- PEP 8 Style Guide for Python Code:<https://peps.python.org/pep-0008/>
- PEP 498 Literal String Interpolation(f-string,3.6+):<https://peps.python.org/pep-0498/>
- PEP 701 Syntactic formalization of f-strings(3.12+ 支持嵌套同类引号):<https://peps.python.org/pep-0701/>
- PEP 3120 源码默认 UTF-8:<https://peps.python.org/pep-3120/>
- PEP 750 Template Strings(3.14+,以官方最新文档为准):<https://peps.python.org/pep-0750/>
- PEP 773 A Python Installation Manager for Windows(Windows 安装方式演进,以官方最新文档为准):<https://peps.python.org/pep-0773/>
- Python for Windows 下载页:<https://www.python.org/downloads/windows/>
- 说明:3.12 / 3.13 / 3.14 的语言与 REPL 变更请以 <https://docs.python.org/3/whatsnew/3.12.html>、<https://docs.python.org/3/whatsnew/3.13.html>、<https://docs.python.org/3/whatsnew/3.14.html> 为准。