w wyl123ly 的博客
MD

Python-01-环境与基础语法

34 KB 2026.10.11 原文件

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
macOSHomebrew 或 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.exeWindows 上若未正确安装,可能命中微软商店的"应用执行别名"占位程序
python3通常来自微软商店版本 / Linux / macOSLinux/macOS 的规范写法;Windows 官方安装器不保证提供
pyWindows 专属启动器 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)
执行后进入 REPLpython -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、rangelist 可变,其余不可变有序集合
3文本序列(Text Sequence)str不可变文本处理
4二进制序列(Binary Sequence)bytes、bytearray、memoryviewbytes 不可变,bytearray 可变网络/文件字节流
5集合(Set)set、frozensetset 可变,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 / 23.5真除法永远返回 float
7 // 23向下取整
-7 // 2-4向下取整,不是向零截断
7 // -2-4同上
-7 // -23同上
-7 % 32结果符号与除数 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-stringf"{name}: {age}"3.6(PEP 498)最快、最直观,支持表达式与格式说明符
t-stringt"{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、<、<=、>、>=、!=、==
10not x
11and
12or
13条件表达式 a if c else b
14lambda
15海象运算符 :=
运算符含义易错点
/真除法,返回 float4 / 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进入下一轮
循环 elsefor ... 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")报 ValueErrorint() 不吃小数字符串,要 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,print 一个 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 打开开发模式,它会把部分警告升级为错误,提前暴露问题。


六、练习题

  1. 基础题:不使用循环,用一行表达式完成——给定 s = "hello world",输出首字母大写、其余小写、空格替换为下划线、并在末尾拼接当前长度(例如 Hello_world_11)。

提示:str.title() 与 str.capitalize() 的行为差异自己试一下。

  1. 基础题:写一个函数 safe_div(a, b),返回 a / b,当 b == 0 时返回 None 并打印一条提示;再写一段代码验证 safe_div(1, 0) 与 safe_div(10, 4) 的输出。
  1. 进阶题:给定总秒数(可能为负,表示"提前量"),用 divmod() 转换成 时:分:秒 格式,要求负数也输出正确(-3661 → -1:01:01,90061 → 25:01:01)。说明为什么不能直接把负数丢给 divmod() 再拼字符串。
  1. 进阶题:分别用 ①手工循环 acc += 0.1 十次、②sum([0.1] 10)、③sum([Decimal("0.1")] 10)、④sum([Decimal(0.1)] * 10) 求"十个 0.1 之和",用 repr() 打印每一项并解释差异;再给出"判断两个金额是否相等"的正确写法。
  1. 思考题:为什么 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> 为准。