跳过循环、变量这些你已经懂的概念,直接看 MATLAB / R / VB 与 Python 的映射。
示例右侧点“运行”即可执行,不用装 Python。首次运行需联网加载运行时。
每题即时反馈;每章可标记完成,进度保存在浏览器本地,下次接着学。
Chapter 01 · Mindset
先把脑子切换到 Python
Python 本身不难,难的是旧习惯。先把六个最容易绊倒 MATLAB / R / VB 用户的地方建立成直觉, 后面的语法会顺很多。
1.1 索引从 0 开始,末尾用负数
MATLAB 和 R 的索引从 1 开始;Python 从 0 开始。VB 默认也是 0 起始,所以 VB 用户可能反而更适应。
最后一个元素可以用 -1 取,倒数第二个是 -2。
a = [10, 20, 30, 40]
# 0 1 2 3
print(a[0]) # 10
print(a[2]) # 30
print(a[-1]) # 40(倒数第一个)
print(a[1:3]) # [20, 30](左闭右开)
| 操作 | MATLAB | R | Python |
|---|---|---|---|
| 第一个元素 | a(1) | a[1] | a[0] |
| 最后一个元素 | a(end) | a[length(a)] | a[-1] |
| 第 2 到第 4 个 | a(2:4) | a[2:4] | a[1:4] |
| 倒数第 2 个 | a(end-1) | a[length(a)-1] | a[-2] |
Python 的切片 a[start:stop] 包含 start,不包含 stop。所以 a[1:3] 只有两个元素。想取第 2 到第 4 个,要写 a[1:4]。
1.2 缩进是语法,不是装饰
Python 用缩进表示代码块,不需要 end、花括号或 Next。
统一用 4 个空格,不要混用 Tab。行尾的冒号 : 不能漏。
if x > 0
disp('positive')
else
disp('not positive')
end
if x > 0:
print("positive")
else:
print("not positive")
1.3 变量是标签,不是盒子
你不需要写 Dim x As Double,也不用 x <- 1。直接赋值即可,
变量的类型由它当前指向的值决定,而且可以随时改变。
x = 42 # int
print(type(x))
x = "forty-two" # 同一个名字,现在指向 str
print(type(x))
y = None # 类似 null / NULL / NA 的“空值”
print(y, type(y))
但别误会:Python 是强类型的。字符串和数字不会自动相加,
"3" + 4 会直接抛 TypeError,而不是悄悄变成 "34"。
1.4 list 不是矩阵,这是最大的坑
MATLAB 的默认数据对象就是数值矩阵,所以 a * 2 是对每个元素乘 2。
Python 的 list 是通用容器,* 表示重复:
a = [1, 2, 3]
print(a * 2) # [1, 2, 3, 1, 2, 3] —— 重复,不是每个元素乘 2
import numpy as np
b = np.array([1, 2, 3])
print(b * 2) # [2 4 6] —— 这才是逐元素运算
做数值计算、矩阵运算、信号处理时,先 np.array(...) 转成 NumPy 数组。日常的“装几个东西”用 list,表格数据用 pandas DataFrame。
1.5 生态:标准库 + 第三方包
标准库随 Python 一起安装,用 import 即可;第三方包用 pip install 安装。
这相当于 MATLAB 的 Toolbox、R 的 install.packages()、VB 的 NuGet 包。
| 任务 | MATLAB / R / VB | Python |
|---|---|---|
| 数值数组 | MATLAB 内置矩阵 / R vector | numpy |
| 表格数据 | MATLAB table / R data.frame、dplyr | pandas |
| 绘图 | MATLAB plot / ggplot2 | matplotlib、seaborn |
| 统计与优化 | Statistics Toolbox / R stats | scipy、statsmodels |
| 机器学习 | Statistics & ML Toolbox / caret | scikit-learn |
| 符号计算 | Symbolic Math Toolbox / Ryacas | sympy |
1.6 命名与风格:一开始就写“像 Python”的代码
- 变量和函数用
snake_case(如read_sensor),类名用CapWords(如Sensor)。 - 常量用
UPPER_CASE,注释用#,字符串用双引号或单引号都行,项目内统一即可。 - 句末不需要分号;一行写一条语句,可读性优先。
- 布尔值和空值是
True、False、None,首字母大写。
| 主题 | 旧习惯 | Python 直觉 |
|---|---|---|
| 索引 | a(1) / x[1] | a[0] |
| 代码块 | end / 花括号 | 缩进 + 冒号 |
| 类型 | 先声明变量类型 | 值有类型,变量只是标签 |
| 数值 | 默认就是矩阵 | list 是容器;数值用 NumPy |
| 逻辑 | && || ! | and or not |
| 语句结尾 | 分号 / 换行 | 不需要分号 |
在 Python 中执行 2 ^ 3,结果是什么?
^ 是按位异或,2 ^ 3 得到 1。幂运算要用 **,即 2 ** 3 == 8。MATLAB、R、VB 里 ^ 都是幂,这是迁移时的高频坑。
已知 a = [10, 20, 30],a[-1] 的值是?
-1 是最后一个,-2 是倒数第二个。它等价于 a[len(a) - 1],但更简洁。
Chapter 02 · Basics
基础语法:迁移要点与语法全貌
变量、数字、字符串、输入输出。前四节聚焦你从 MATLAB、R、VB 带来的差异; 2.5 起用精简篇幅补齐 Python 基础语法的全貌——缩进、赋值、运算符、字符串方法和语句清单, 确保没有知识盲区。
2.1 三种运行方式
- 脚本:把代码写进
hello.py,在终端运行python hello.py。适合可重复执行的工程任务。 - REPL:终端输入
python,出现>>>后逐行执行。适合试探语法、验证一个小想法。 - Notebook:Jupyter / VS Code 的交互窗口。适合数据分析、绘图和边看结果边改代码。
$ python hello.py
Hello, Python!
$ python
Python 3.12.0
>>> 2 ** 10
1024
2.2 变量、类型与 f-string
Python 的核心标量类型有 int、float、str、bool 和 NoneType。
整数没有固定位宽,不会像 C / VB 的 Integer 那样溢出。
注意 / 永远返回浮点数,即使能整除;要得到整数商用 //。
Python 的 // 对负数是向下取整(-7 // 2 == -4),这一点和 C 的截断除法不同。
| 运算 | MATLAB | R | VB | Python |
|---|---|---|---|---|
| 幂 | ^ | ^ | ^ | ** |
| 整除 | idivide / floor | %/% | \ | // |
| 取余 | mod | %% | Mod | % |
| 逻辑与 | && | && | And | and |
| 逻辑或 | || | || | Or | or |
| 逻辑非 | ~ | ! | Not | not |
| 不等于 | ~= | != | <> | != |
2.3 字符串与格式化
f-string 是 Python 最常用的格式化方式,相当于 MATLAB 的 sprintf、R 的 sprintf、
VB 的 Format,但变量直接嵌在字符串里,读起来更接近模板。
| 任务 | MATLAB | R | Python |
|---|---|---|---|
| 保留 1 位小数 | sprintf('%.1f', x) | sprintf("%.1f", x) | f"{x:.1f}" |
| 补零 | sprintf('%03d', n) | sprintf("%03d", n) | f"{n:03d}" |
| 拼接 | [a b] | paste0(a, b) | f"{a}{b}" |
| 长度 | strlength(s) | nchar(s) | len(s) |
字符串也可以用单引号 '...';三引号 """...""" 可以写多行文本或函数文档。
字符串不可变,任何“修改”都会产生新字符串,例如 name.replace("P", "J")。
2.4 输入与输出
print() 可以一次输出多个值,默认用空格分隔;input() 返回的永远是字符串,
需要数字时自己转换。下面的代码适合在本地脚本里运行,浏览器示例不建议使用 input():
name = input("你的名字:")
age = int(input("你的年龄:"))
print(f"{name},明年你 {age + 1} 岁。")
print("A", "B", "C", sep=" | ")
print("处理中", end="...")
print("完成")
数字可以用下划线分组提高可读性,例如 1_000_000;注释用 #。不要把多条语句挤在一行用分号分隔——Python 允许,但可读性差。
2.5 代码结构:缩进、注释与续行
前四节讲的是“和旧语言不一样的地方”,从这里开始补齐 Python 的基础语法全貌。
先记住最根本的一条:缩进不是排版,而是语法。MATLAB 用 end、
R 用花括号、VB 用 End If 划分代码块,Python 用冒号加缩进。
| 语言 | 代码块如何标记 |
|---|---|
| MATLAB | if ... end、for ... end |
| R | { ... } |
| Visual Basic | If ... End If、For ... Next |
| Python | 行尾冒号 : + 下一行缩进(推荐 4 个空格) |
- 缩进:同一代码块必须使用相同缩进;不要混用 Tab 和空格,编辑器统一设成 4 个空格最省事。
- 注释:
#到行尾都是注释;"""文档字符串"""写在模块、函数或类开头,用help()可以查看。 - 语句:一条语句一行,行尾不需要分号;
;可以分隔多条语句,但不推荐。 - 续行:长表达式优先在圆括号、方括号、花括号内换行;反斜杠
\也能续行,但容易出错。 - 大小写:Python 区分大小写,
Value、value、VALUE是三个不同的名字。 - 编码:源文件默认 UTF-8,中文可以直接写在字符串和注释里;空行和空格不影响执行。
# 缩进就是语法:同一代码块必须对齐
total = 0
for value in [1, 2, 3]:
total += value # 属于循环体
if total > 3:
print("超过 3") # 属于 if 代码块
# 括号内可以自然换行,不需要反斜杠
result = (
1 + 2
+ 3
+ 4
)
print(result) # 10
2.6 变量、赋值与真假值
Python 的变量是“名字到对象”的绑定,不需要声明类型,重新赋值时类型也可以改变。
这一点和 VB 的 Dim ... As ...、MATLAB 的数值矩阵默认类型都不一样。
- 命名规则:以字母或下划线开头,后面可接字母、数字、下划线;不能使用关键字(如
if、for、class)。 - 命名约定:普通变量和函数用
snake_case,常量用UPPER_CASE,类名用PascalCase。 - 多重赋值:
x, y = 1, 2;交换两个变量写x, y = y, x;链式赋值写a = b = 0。 - 增强赋值:
+=、-=、*=、/=、//=、%=、**=。 - 删除绑定:
del name只删除名字,对象由垃圾回收管理,通常不需要手动释放。 - 比较:
==比较值,is比较是否为同一个对象;判空写if x is None。 - 真值规则:
False、None、数值 0、空字符串、空列表/元组/字典/集合都视为假,其余视为真;bool()可显式转换。
注意 bool([0]) 是 True:列表里有元素 0,但列表本身非空。
判断容器是否为空,直接写 if items: 即可。
2.7 数字类型与运算符全表
- int:任意精度整数,不会溢出;float:IEEE 754 双精度;complex:如
2 + 3j;bool 是 int 的子类(True == 1)。 - 字面量:
0b1010(二进制)、0o17(八进制)、0xFF(十六进制)、1_000_000、1.5e-3。 - 类型转换:
int()向零截断小数,float()解析数字字符串,str()转成文本,bool()按真值规则转换;round()采用“银行家舍入”(round(2.5) == 2),需要商业舍入时用decimal.Decimal。 - 浮点比较:
0.1 + 0.2 != 0.3,判断近似相等用math.isclose(a, b)。 - 优先级:不必背,拿不准就加括号;括号永远最优先。
| 类别 | 运算符 | 说明 |
|---|---|---|
| 算术 | + - * / // % ** | / 浮点除,// 整除,** 幂 |
| 比较 | == != < <= > >= | 可以链式写:0 < x < 10 |
| 逻辑 | and or not | 短路求值,返回的是操作数本身 |
| 位运算 | & | ^ ~ << >> | 整数按位操作,^ 是异或,不是幂 |
| 成员 | in / not in | 判断子串、元素或字典键是否存在 |
| 身份 | is / is not | 是否同一个对象;判空用 is None |
| 条件表达式 | a if cond else b | 行内的 if/else,类似 VB 的 IIf |
2.8 字符串方法、转义与格式说明
2.3 已经讲了索引、切片和基础 f-string。这里补上转义、原始字符串、常用方法和完整的格式说明符。
Python 的 str 是不可变的,所有“修改”都会返回新字符串。
- 转义:
\n换行、\t制表、\\反斜杠、\"引号、\u4e2dUnicode 字符。 - 原始字符串:
r"C:\temp\new"不处理转义,适合 Windows 路径和正则表达式。 - 多行字符串:三引号
"""..."""可以跨行,也常用作文档字符串。 - 拼接与重复:
"py" + "thon"、"ab" * 3;相邻字面量会自动拼接,如"py" "thon"。 - 文本与字节:
"中文".encode("utf-8")得到bytes,用.decode("utf-8")还原;文件、网络和哈希都按字节处理。
| 方法 | 作用 | 示例 |
|---|---|---|
strip() | 去掉两端空白(或指定字符) | " hi ".strip() |
split(sep) | 按分隔符切分成列表 | "a,b".split(",") |
join(iterable) | 用当前字符串连接序列 | "-".join(["a", "b"]) |
replace(old, new) | 替换子串 | "a.py".replace(".py", "") |
find(sub) | 返回下标,找不到返回 −1 | "python".find("th") |
startswith / endswith | 判断前缀或后缀 | "data.csv".endswith(".csv") |
count(sub) | 统计子串出现次数 | "banana".count("a") |
lower / upper | 转小写 / 大写 | "Py".lower() |
zfill(n) | 左侧补零到指定宽度 | "7".zfill(3) |
pi = 3.1415926
print(f"{pi:.2f}") # 3.14 保留 2 位小数
print(f"{1234567:,}") # 1,234,567 千分位
print(f"{42:08.2f}") # 00042.00 总宽 8,补零
print(f"{255:#x}") # 0xff 十六进制
print(f"{0.8734:.1%}") # 87.3% 百分比
print(f"{'py':^7}|") # py | 居中,总宽 7
print(f"{pi=}") # pi=3.1415926 调试写法(3.8+)
常用格式说明符的格式是 {值:填充对齐宽度.精度类型};
对齐用 <、>、^,类型用 f(浮点)、d(整数)、
x(十六进制)、b(二进制)、%(百分比)、e(科学计数法)。
2.9 语句全景:还有哪些语法
下面这张表把 Python 的常用语句一次列全。基础语法部分只要求“知道有这回事”, 具体用法会在后续章节展开,学完后可以回来对照。
| 语句 / 关键字 | 作用 | 详见 |
|---|---|---|
赋值、解包、del | 绑定名字、交换变量、删除绑定 | 2.6 |
if / elif / else | 条件分支 | 第 4 章 |
for / while / break / continue | 循环;循环的 else 在未 break 时执行 | 第 4 章 |
def / return / lambda | 定义函数、返回值、匿名函数 | 第 5 章 |
class / self | 定义类与实例方法 | 第 7 章 |
import / from ... import / as | 导入模块、指定别名 | 第 6 章 |
try / except / else / finally | 异常捕获与清理 | 第 8 章 |
raise / assert | 主动抛出异常、断言检查 | 第 8 章 |
with | 上下文管理器,自动释放文件等资源 | 第 8 章 |
match / case | 结构化模式匹配(Python 3.10+) | 进阶 |
pass / global / nonlocal | 空语句、声明使用全局或外层变量 | 第 5 章 |
| 推导式、生成器表达式 | 从可迭代对象快速构造容器 | 第 4 章 |
装饰器 @、async / await | 包装函数、异步编程 | 进阶 |
最后给一个最小但完整的程序骨架,把导入、常量、函数、主函数和 __main__ 保护串起来。
现在看不懂细节没关系,学完第 6、7 章再回来看就会很自然。
import math
GRAVITY = 9.81
def fall_time(height):
"""自由落体时间:t = sqrt(2h / g)。"""
return math.sqrt(2 * height / GRAVITY)
def main():
for h in (1.0, 5.0, 20.0):
print(f"{h:5.1f} m -> {fall_time(h):.3f} s")
if __name__ == "__main__":
main()
下面哪个值在 if 条件中会被判定为真?
[0] 是“包含一个元素 0 的列表”,列表本身非空,所以为真。
判断容器是否为空,直接写 if items: 即可。
7 // 2 的结果是?
// 是整除(floor division),丢掉小数部分并向下取整,所以结果是 3。真正的除法是 7 / 2,结果为 3.5。
执行 print("3" + 3) 会发生什么?
"3" + str(3),要么用 f-string:f"3{3}"。这正是“强类型”的体现。
Chapter 03 · Containers
容器:list、tuple、dict、set
大多数 Python 程序都在和这四种容器打交道。它们可以互相嵌套,替代 MATLAB 的 cell、struct, R 的 list、data.frame,以及 VB 的 Collection、Dictionary。
3.1 list:有序、可变、什么都能装
list 用方括号创建,可以装不同类型的数据。索引、切片、负索引和字符串一致。
常用操作有 append、extend、insert、remove、pop、sort。
b = a 只是给同一个列表起了第二个名字。b.append(...) 会同时改变 a。需要独立副本时用 a.copy()、list(a) 或切片 a[:]。
其他常用写法:
a = [3, 1, 2]
a.append(4) # 末尾追加一个元素
a.extend([5, 6]) # 末尾追加多个元素
a.insert(0, 0) # 在下标 0 插入
a.remove(1) # 删除第一个值为 1 的元素
last = a.pop() # 弹出并返回最后一个元素
a.sort() # 原地排序
a.reverse() # 原地反转
print(a)
print(2 in a, a.index(2))
3.2 tuple:不可变的“记录”
tuple 用圆括号创建,创建后不能修改。它适合表示固定结构的数据,比如坐标、尺寸、 函数返回的多个值。tuple 可以作为 dict 的键(list 不行)。
point = (3.0, 4.0)
x, y = point # 解包
print(x, y)
# point[0] = 5 # TypeError: tuple 不可变
single = (42,) # 只有一个元素时,逗号不能省
print(type(single)) # <class 'tuple'>
3.3 dict:键值映射
dict 相当于 MATLAB 的 struct、R 的命名 list、VB 的 Dictionary。 它用键而不是位置来查找值,适合存“带名字的字段”。Python 3.7+ 会保留插入顺序。
student["gpa"] 在键不存在时会抛 KeyError;student.get("gpa") 会返回 None。
用 del student["age"] 或 student.pop("age") 删除键。
3.4 set:去重与集合运算
set 是无序、不重复的集合。常用于去重、判断成员、求交集 / 并集 / 差集。
注意空集合必须写成 set(),{} 是空字典。
values = [1, 1, 2, 3, 3, 3]
unique = set(values)
print(unique) # {1, 2, 3}
a = {1, 2, 3, 4}
b = {3, 4, 5}
print(a & b) # 交集 {3, 4}
print(a | b) # 并集 {1, 2, 3, 4, 5}
print(a - b) # 差集 {1, 2}
print(3 in a) # True
3.5 怎么选容器?
| 需求 | 选择 | 例子 |
|---|---|---|
| 有序、可修改的序列 | list | [1, 2, 3] |
| 固定记录、多返回值 | tuple | (x, y) |
| 按键查找 | dict | {"name": "Ada"} |
| 去重、集合运算 | set | {1, 2, 3} |
| 数值数组 / 矩阵 | numpy.ndarray | np.array([1, 2, 3]) |
| 表格数据 | pandas.DataFrame | pd.DataFrame(...) |
| MATLAB / R / VB | Python |
|---|---|
| MATLAB cell array | list |
| MATLAB struct | dict 或 dataclass |
| R named list | dict |
| R data.frame | pandas.DataFrame |
| VB Collection / Dictionary | list / dict |
已知 a = [10, 20, 30, 40, 50],a[1:4] 的结果是?
1,不包含终点 4,所以取下标 1、2、3,即 [20, 30, 40]。
下面代码输出什么?a = [1, 2]b = ab.append(3)print(a)
b = a 复制的是引用,两个名字指向同一个列表。要独立复制,用 b = a.copy() 或 b = list(a)。
Chapter 04 · Control flow
控制流:遍历,而不是数数
Python 的 for 循环更像“对集合里的每个元素做点什么”,而不是 MATLAB 的“从 1 数到 n”。 理解这一点,循环会自然很多。
4.1 if / elif / else
条件不需要括号,但冒号和缩进必须有。elif 是 else if 的缩写。
Python 允许链式比较,例如 0 < x < 100,这在 MATLAB / R / VB 里通常写不出来。
score = 86
if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
else:
grade = "C"
print(grade) # B
status = "pass" if score >= 60 else "fail" # 条件表达式
print(status)
Python 有“真值”概念:0、0.0、""、[]、{}、
None、False 在条件里都视为假,其余大多视为真。所以判断列表是否为空可以直接写
if items:,不必写 if len(items) > 0:。
MATLAB 的 for i = 1:5 包含 5,对应 Python 的 for i in range(1, 6)。range(1, 5) 只到 4。刚开始可以记成“range 的终点要 +1”。
4.2 while、break、continue
不知道要循环多少次时用 while;条件在每轮开始前检查。
break 立即退出整个循环,continue 跳过本轮剩余语句。
n = 0
while n < 5:
n += 1
if n == 3:
continue # 跳过 3
if n == 5:
break # 提前结束
print(n, end=" ") # 1 2 4
print()
4.3 列表推导式:把“循环 + 追加”压成一行
列表推导式是 Python 最有辨识度的语法之一,相当于 MATLAB 的 arrayfun、
R 的 sapply 的常见用法,但更紧凑。格式是
[表达式 for 变量 in 可迭代对象 if 条件]。
推导式适合简单变换和筛选。逻辑一复杂就拆回普通循环——可读性比“少写几行”重要。
| 任务 | MATLAB | R | VB | Python |
|---|---|---|---|---|
| 从 1 到 n | for i = 1:n | for (i in 1:n) | For i = 1 To n | for i in range(1, n + 1) |
| 遍历元素 | for x = a | for (x in a) | For Each x In a | for x in a |
| 带下标 | for i = 1:numel(a) | seq_along(a) | 手动维护计数器 | for i, x in enumerate(a) |
| 映射 | arrayfun(@f, a) | sapply(a, f) | 循环 + 新数组 | [f(x) for x in a] |
在 for x in a: 里删除 a 的元素会跳过元素,结果不可预测。需要过滤时用新列表:a = [x for x in a if keep(x)];需要遍历副本时写 for x in a[:]。
list(range(3)) 的结果是?
range(3) 从 0 开始,到 3 之前结束,所以是 0、1、2。要得到 1 到 3,写 range(1, 4)。
[x * x for x in range(4) if x % 2 == 0] 的结果是?
range(4) 产生 0、1、2、3;条件只留下偶数 0、2;再平方得到 [0, 4]。
Chapter 05 · Functions
函数:输入、输出、可复用
Python 用 def 定义函数,不需要单独的 .m 文件,也没有 End。函数可以返回多个值、 接受默认参数和关键字参数,这些特性会让工程代码更清晰。
5.1 def、return 与文档字符串
函数体靠缩进界定。第一个字符串语句会自动成为文档字符串(docstring),
相当于 MATLAB 函数开头的注释块;用 help(f) 或编辑器提示都能看到。
height_m=1.75 是默认参数:调用时省略就用默认值。
调用时写 bmi(height_m=1.68, weight_kg=55) 叫关键字参数,顺序可以打乱,
在参数很多时尤其有用。
5.2 默认参数与可变对象:一个必须知道的坑
默认参数只在函数定义时求值一次。如果默认值是列表、字典这类可变对象, 它会在多次调用之间共享,导致结果累积。
5.3 *args 与 **kwargs
不确定参数个数时,*args 收集位置参数为 tuple,**kwargs 收集关键字参数为 dict。
工程代码里常见于日志、配置和包装函数;日常业务不必滥用。
def summarize(label, *values, unit=""):
print(label, values, unit)
summarize("scores", 90, 85, 92, unit="分")
# scores (90, 85, 92) 分
def build_config(**options):
return options
print(build_config(debug=True, workers=4))
5.4 作用域与 Lambda
函数内部赋值的变量默认是局部变量,函数外看不到。需要把结果传出去就 return,
尽量少用 global。Lambda 是单表达式匿名函数,常用于 sorted 的 key:
pairs = [("b", 2), ("a", 3), ("c", 1)]
print(sorted(pairs, key=lambda p: p[1])) # 按第二个元素排序
factor = 2
scale = lambda x: x * factor # 能读外部变量
print(scale(5)) # 10
# 等价于
def scale(x):
return x * factor
5.5 类型标注:给工程代码加“说明书”
Python 3.5+ 支持类型标注,但它不会在运行时强制检查,主要给编辑器和同事看, 也可以配合 mypy / pyright 做静态检查。大型工程里非常值得写。
def scale(values: list[float], factor: float = 1.0) -> list[float]:
return [v * factor for v in values]
print(scale([1.0, 2.0], 3))
| 任务 | MATLAB | R | VB | Python |
|---|---|---|---|---|
| 定义函数 | function y = f(x) ... end | f <- function(x) {} | Function F(x As Double) As Double | def f(x): |
| 返回多个值 | [a, b] = f(x) | list(a = ..., b = ...) | ByRef 参数 / 自定义类型 | return a, b |
| 默认参数 | nargin 判断 | function(x, y = 1) | Optional y As Double = 1 | def f(x, y=1): |
| 匿名函数 | @(x) x.^2 | function(x) x^2 | Function(x) x ^ 2 | lambda x: x ** 2 |
一个函数只做一件事;名字用动词开头,如 load_data、clean_signal;参数多时用关键字;需要共享状态时优先 return,而不是改全局变量。
下面代码输出什么?def f(a, b=2): return a * bprint(f(3))
b 有默认值 2,所以调用 f(3) 等价于 f(3, 2),返回 6。默认参数让调用方可以只传必需参数。
下面代码输出什么?def greet(name, greeting="Hello"): return f"{greeting}, {name}"print(greet(greeting="Hi", name="Ada"))
greeting="Hi"、name="Ada" 分别绑定到对应参数,所以输出 Hi, Ada。
Chapter 06 · Modules
模块、包与工程化习惯
单文件脚本能解决一次性的问题,但工程代码需要拆分模块、固定依赖、区分“被导入”和“被运行”。 这一章把 MATLAB 的 path、R 的包和 VB 的引用对应到 Python 的世界。
6.1 import:把别人的代码拿过来用
Python 的标准库非常全:数学、随机数、日期、路径、JSON、CSV、统计都有。 第三方包则通过 pip 安装后再 import。常见写法有三种:
import math
print(math.sqrt(16)) # 4.0
from datetime import date
print(date.today()) # 2026-11-14(取决于本机日期)
import numpy as np
print(np.array([1, 2, 3])) # 约定俗成的别名
from collections import Counter
print(Counter("hello"))
from math import * 会把大量名字倒进当前命名空间,容易覆盖你自己的变量。用 import math 或只导入需要的名字。
下面这段代码把工程里最常用的几个标准库串起来:
6.2 依赖管理:venv + pip
不要直接把包装进系统 Python。每个项目建一个虚拟环境,依赖隔离,换机器也能复现。 MATLAB 的 path / Toolbox、R 的 library 路径、VB 的项目引用,在 Python 里对应的就是 “虚拟环境 + requirements.txt”。
# 1. 在项目目录创建虚拟环境
python -m venv .venv
# 2. 激活(macOS / Linux)
source .venv/bin/activate
# Windows PowerShell
# .venv\Scripts\Activate.ps1
# 3. 安装依赖
pip install numpy pandas matplotlib
# 4. 导出依赖清单
pip freeze > requirements.txt
# 5. 在另一台机器复现
pip install -r requirements.txt
如果你已经在用 Anaconda,可以继续用 conda 管理环境;近几年 uv 也因为速度快而流行。
关键不是工具,而是一个项目一个环境,并记录依赖版本。
6.3 项目结构与 __main__
当脚本被直接运行,__name__ 的值是 "__main__";
当它被别的文件 import,__name__ 是模块名。因此可以用下面这个惯用法,
让模块既可以被复用,又不会在 import 时自动执行测试代码。
def clean(values):
return [v for v in values if v is not None]
def main():
data = [1, 2, None, 4]
print(clean(data))
if __name__ == "__main__":
main()
project/
├── .venv/ # 虚拟环境(不要提交到 git)
├── requirements.txt
├── README.md
├── src/
│ └── analysis.py
└── tests/
└── test_analysis.py
| 场景 | 推荐形态 |
|---|---|
| 探索数据、画图、临时验证 | Jupyter Notebook |
| 可复用的清洗 / 计算逻辑 | .py 模块 + 函数 |
| 定时任务、批处理、自动化 | .py 脚本 + argparse |
| 团队共享、长期维护 | 包结构 + README + 依赖清单 + 测试 |
| 旧语言 | Python 对应 |
|---|---|
MATLAB addpath / Toolbox | pip install + import |
R install.packages() / library() | pip install / import |
| VB 项目引用 / NuGet | pip + 虚拟环境 |
| MATLAB 当前文件夹 | 脚本所在目录、包路径、PYTHONPATH |
① 文件不要和标准库重名,例如 random.py、json.py,否则 import 的可能是你自己的文件。② pip 包名和 import 名不一定相同:pip install scikit-learn 后是 import sklearn,opencv-python 后是 import cv2。
用 pip install scikit-learn 安装后,代码里应该怎么导入?
scikit-learn,导入名是 sklearn。遇到不确定的包,查官方文档的“Installation”或“Quickstart”即可。
if __name__ == "__main__": 的作用是?
__name__ 是 "__main__";被 import 时是模块名。这个判断让模块可以安全地被复用,而不会在导入时执行测试或主流程。
Chapter 07 · Objects
类与对象:够用就好
工程代码里,大部分问题用函数加 dict 就能解决。当一组数据需要绑定自己的行为、 并且要维护状态时,类才真正有价值。这一章只讲最常用的部分。
7.1 class、__init__ 与 self
__init__ 是构造方法,创建对象时自动调用;self 指向当前实例,
相当于 VB 的 Me、MATLAB 的 obj、R6 的 self。
方法第一个参数必须是 self(名字是约定,但别改)。
__repr__ 决定对象在交互环境和 print 里的显示方式,调试时非常有用。
类似地,__len__、__getitem__ 可以让对象支持 len() 和索引。
7.2 dataclass:数据类的捷径
如果类的主要作用是“装数据”,用 @dataclass 可以自动生成
__init__、__repr__ 和相等比较,代码短很多。
from dataclasses import dataclass, field
@dataclass
class Point:
x: float
y: float
tags: list = field(default_factory=list)
p = Point(1.0, 2.0)
p.tags.append("sensor")
print(p) # Point(x=1.0, y=2.0, tags=['sensor'])
dataclass 里不要写 tags: list = [],所有实例会共享同一个列表。用 field(default_factory=list)。
7.3 继承与组合
继承用 class Child(Parent):,子类可以复用或覆盖父类方法。但在工程代码里,
组合往往比继承更简单:一个类持有另一个对象,而不是变成它的子类。
除非确实存在“是一种”的关系,否则优先组合。
class Sensor:
def __init__(self, name):
self.name = name
class TemperatureSensor(Sensor):
def __init__(self, name, unit="C"):
super().__init__(name) # 调用父类构造方法
self.unit = unit
def __repr__(self):
return f"TemperatureSensor({self.name!r}, unit={self.unit!r})"
print(TemperatureSensor("T-01"))
| 旧语言 | Python |
|---|---|
VB Class / Me | class / self |
MATLAB classdef / obj | class / self |
| R6 / S3 / S4 对象 | class + 特殊方法(__repr__ 等) |
| 构造函数 | __init__ |
| ToString / Display | __repr__ / __str__ |
数据处理脚本优先写成小函数;需要把“数据 + 行为”绑定时再用类。一个只有属性没有方法的类,通常用 dataclass 或 dict 更合适。
方法定义里的 self 指向什么?
s.add(1) 时,Python 自动把 s 作为第一个参数传给方法,所以在方法里 self 就是 s。名字可以改,但强烈建议保持 self。
__init__ 方法什么时候执行?
Sensor("T-01") 创建实例时会自动调用 __init__,用来初始化属性。它不负责“分配内存”,那一步由 Python 完成。
Chapter 08 · Files & errors
文件、异常与调试
真实工程离不开读写文件和处理错误。Python 的 with 语句、明确的异常类型和 traceback, 会让“出错”变成可以定位、可以恢复的事情。
8.1 用 pathlib 和 with 读写文件
pathlib.Path 跨平台处理路径,比手拼字符串可靠;with open(...)
会在代码块结束时自动关闭文件,即使中途抛异常也一样。文本文件建议始终显式写
encoding="utf-8"。
常见模式:"r" 读、"w" 覆盖写、"a" 追加、"rb" 读二进制。
处理 CSV 可以用标准库 csv,但数据分析里通常直接用 pandas 的
read_csv / to_csv。
本页的 Python 运行在浏览器的虚拟文件系统中。上面的文件读写可以正常工作,但刷新页面后文件会消失,也不能直接访问你电脑上的 C:\data\file.csv。真实项目请在本地运行 Python。
8.2 try / except / else / finally
Python 用异常表示错误。捕获时尽量写具体类型(如 ValueError、
FileNotFoundError),不要用一个裸 except: 吞掉所有问题。
else 在无异常时执行,finally 无论如何都执行。
def set_speed(value):
if value < 0:
raise ValueError(f"速度不能为负:{value}")
return value
try:
set_speed(-5)
except ValueError as error:
print("捕获到:", error)
# 也可以自定义异常
class SensorError(Exception):
pass
8.3 读 traceback:从最后一行开始
Python 的报错信息看起来很长,但最有用的是最后一行:异常类型和消息; 然后往上看最近的“你的代码”所在行。库内部的调用栈通常可以暂时忽略。
Traceback (most recent call last):
File "example.py", line 4, in <module>
print(10 / n)
~~^~~
ZeroDivisionError: division by zero
- 先用 print / f-string 检查中间值,确认数据形状和类型符合预期。
- assert 适合写“这里必须成立”的检查,失败时立即暴露:
assert len(x) > 0。 - breakpoint() 在本地脚本里进入 pdb,可以逐行执行、查看变量;Notebook 里通常用单元格逐步运行。
- logging 比 print 更适合长期运行的程序,可以分级、写文件、带时间戳。
| 旧语言 | Python |
|---|---|
MATLAB try / catch / end | try / except / finally |
R tryCatch() | try / except |
VB Try / Catch / Finally | try / except / else / finally |
MATLAB error() / R stop() | raise ValueError(...) |
无论 try 块是否抛出异常,finally 块会怎样?
finally 用于清理资源(关闭文件、释放连接),无论是否发生异常都会执行,即使 try 块里已经 return。
读取文本文件时,下面哪种写法最推荐?
with 会在代码块结束时自动关闭文件,即使中途出错。显式指定 encoding="utf-8" 可以避免跨平台编码问题。
Chapter 09 · NumPy
NumPy:把矩阵直觉搬到 Python
NumPy 是 Python 科学计算的底座。它提供同构的 n 维数组、逐元素运算、广播和线性代数, 也是 pandas、Matplotlib、scikit-learn 的共同基础。
9.1 创建数组与查看形状
np.array 从 list 创建数组;np.arange 类似 range 但返回数组;
np.linspace 按点数等分区间;zeros、ones 用于预分配。
shape 是各维度长度,dtype 是元素类型。NumPy 数组要求元素同构,
这也是它比 list 快得多的原因:连续内存 + 向量化运算。
9.2 索引、切片与视图
二维数组用逗号分隔维度:m[行, 列]。切片仍然是左闭右开。
与 list 不同,NumPy 的基本切片返回视图,修改视图会改到原数组;
需要独立副本时用 .copy()。
9.3 聚合、轴与线性代数
axis=0 表示“沿着行方向压扁”,结果是每列一个值;
axis=1 表示“沿着列方向压扁”,结果是每行一个值。
这是从 MATLAB 迁移时最容易混淆的参数之一。
import numpy as np
A = np.array([[3.0, 1.0],
[1.0, 2.0]])
b = np.array([9.0, 8.0])
x = np.linalg.solve(A, b) # 解线性方程组,优于先求逆
print(x) # [2. 3.]
print(np.linalg.norm(x))
print(np.linalg.eigvals(A)) # 特征值
print(A.T) # 转置
做数值计算时尽量向量化,不要在 Python 循环里逐个 append。
需要动态长度时先用 list 收集,最后一次性 np.array(list);
已知长度时用 np.empty 预分配。
| MATLAB | NumPy |
|---|---|
a(1) | a[0] |
a(end) | a[-1] |
a(2:5) | a[1:5] |
size(a) | a.shape |
numel(a) | a.size |
a' | a.T(复数用 a.conj().T) |
a .* b | a * b |
a * b | a @ b |
a .^ 2 | a ** 2 |
sum(a) | a.sum() |
sum(a, 1) | a.sum(axis=1) |
find(a > 0) | np.where(a > 0)[0] |
zeros(3, 4) | np.zeros((3, 4)) |
linspace(0, 1, 5) | np.linspace(0, 1, 5) |
reshape(a, 3, 4) | a.reshape(3, 4) |
[a b] / cat | np.hstack / np.concatenate |
① 0 基索引;② * 是逐元素乘,矩阵乘用 @;③ 一维数组没有“行/列向量”的区分,需要显式 reshape(-1, 1) 或 reshape(1, -1) 来控制广播方向。
np.array([1, 2, 3]) * np.array([4, 5, 6]) 的结果是?
* 是逐元素乘法,所以是 [1×4, 2×5, 3×6] = [4, 10, 18]。点积要用 a @ b,结果为 32。
m = np.zeros((2, 3)),m.shape 是?
np.zeros((2, 3)) 创建 2 行 3 列的数组,shape 是 (2, 3),元素总数是 6(size)。注意 NumPy 的 shape 顺序是“行, 列”,和 MATLAB 的 size 一致。
Chapter 10 · Matplotlib
Matplotlib:把结果画出来
Matplotlib 是 Python 的“基础绘图仪”。学会面向对象的 fig / ax 写法, 你就能控制多子图、坐标轴、图例和导出,而不是停留在 plt.plot 的快捷方式里。
10.1 推荐写法:fig + ax
plt.subplots() 返回一个 Figure(画布)和一个 Axes(坐标轴)。
之后所有绘图操作都作用在 ax 上。相比 plt.plot() 的全局状态写法,
这种写法在多个子图和函数封装里更可靠。
注意这里没有调用 plt.show()。在脚本里 show() 会打开窗口并阻塞;
在 Notebook 里会内联显示;在本页中,运行时环境会自动捕获当前 Figure 并显示成图片。
10.2 常用设置与多子图
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 10, 100)
rng = np.random.default_rng(0)
fig, axes = plt.subplots(1, 2, figsize=(9, 3.2))
axes[0].plot(x, np.sin(x), color="#1f5f8b", linewidth=2)
axes[0].set_title("line")
axes[0].set_xlabel("x")
axes[1].hist(rng.normal(size=500), bins=20, color="#e7b02b")
axes[1].set_title("histogram")
fig.tight_layout()
fig.savefig("result.png", dpi=200, bbox_inches="tight")
| 任务 | 代码 |
|---|---|
| 折线 | ax.plot(x, y, label="y") |
| 散点 | ax.scatter(x, y, s=20, alpha=0.7) |
| 柱状图 | ax.bar(categories, values) |
| 直方图 | ax.hist(values, bins=30) |
| 误差棒 | ax.errorbar(x, y, yerr=err, fmt="o-") |
| 二维图像 | ax.imshow(matrix, cmap="viridis") |
| 坐标范围 | ax.set_xlim(0, 10) / ax.set_ylim(-1, 1) |
| 保存 | fig.savefig("plot.png", dpi=200) |
本页的 Matplotlib 运行在浏览器里,没有中文字体,所以示例标签用英文避免出现方框。本地运行时可以设置 plt.rcParams["font.sans-serif"] = ["PingFang SC", "Microsoft YaHei", "SimHei"] 和 plt.rcParams["axes.unicode_minus"] = False。
plot(x, y) 对应 ax.plot(x, y);hold on 对应在同一个 ax 上继续 plot;subplot(1,2,1) 对应 fig, axes = plt.subplots(1, 2);ggplot2 的分面可以对应 subplots 或 seaborn 的 FacetGrid。
使用面向对象 API 时,下面哪一行创建画布和坐标轴?
plt.subplots() 返回 (fig, ax)。之后用 ax.plot()、ax.set_xlabel() 等方法操作具体坐标轴,避免依赖全局当前图。
Chapter 11 · Pandas
Pandas:像 R 一样处理表格
如果你用过 R 的 data.frame 或 MATLAB 的 table,pandas 的 DataFrame 会很亲切。 它把“筛选、分组、汇总、排序、读写 CSV”变成几行链式调用。
11.1 DataFrame:带列名的二维表
DataFrame 可以看成“多个共享索引的 Series”。创建方式很多:从 dict、list of dicts、 CSV、Excel、数据库查询结果都可以。下面从 dict 构造一个小表,并做最常见的分组汇总。
11.2 查看数据
df.head() # 前 5 行
df.tail(3) # 后 3 行
df.shape # (行数, 列数)
df.columns # 列名
df.dtypes # 每列类型
df.info() # 类型、非空数量、内存
df.describe() # 数值列统计摘要
df["score"].mean()
df["team"].value_counts()
在脚本里这些表达式不会自动打印,需要 print(df.head());
在 Notebook 里最后一行会直接显示成表格。
11.3 选择、筛选与新增列
df["score"] # 取一列,得到 Series
df[["team", "score"]] # 取多列,得到 DataFrame
df.loc[0, "score"] # 按标签取单元格
df.iloc[0, 1] # 按位置取单元格(第 0 行第 1 列)
mask = df["score"] > 85
print(df[mask]) # 布尔筛选
print(df.loc[mask, ["team", "score"]])
print(df.query("score > 85 and hours < 13"))
df["passed"] = df["score"] >= 90 # 新增列
df["per_hour"] = df["score"] / df["hours"]
不要写 df[df["score"] > 85]["passed"] = True,这可能会修改副本并触发警告。用 df.loc[df["score"] > 85, "passed"] = True 一次定位到行列。
11.4 分组、排序与缺失值
# 分组汇总
summary = df.groupby("team").agg({
"score": ["mean", "max"],
"hours": "sum",
})
print(summary)
# 排序与排名
print(df.sort_values(["score", "hours"], ascending=[False, True]))
df["rank"] = df["score"].rank(ascending=False)
# 缺失值
print(df.isna().sum())
df = df.dropna(subset=["score"])
df["hours"] = df["hours"].fillna(df["hours"].mean())
# 读写 CSV
# df = pd.read_csv("data.csv", encoding="utf-8")
# df.to_csv("result.csv", index=False)
在浏览器示例里不能直接读取本地路径的文件;真实项目中用 read_csv 即可。
如果数据在网页里,通常先由用户上传,再用 io.StringIO 包装文本传给 pandas。
| R / MATLAB | pandas |
|---|---|
R data.frame / MATLAB table | DataFrame |
df$score / df[["score"]] | df["score"] / df[["score"]] |
df[df$x > 0, ] | df[df["x"] > 0] |
aggregate / group_by |> summarise | df.groupby(...).agg(...) |
arrange() | df.sort_values() |
mutate() | df["new"] = ... / df.assign(...) |
read.csv() / writetable | pd.read_csv() / df.to_csv() |
is.na() | df.isna() |
factor | astype("category") |
%>% 管道 | 方法链 df.query(...).groupby(...).mean() |
不要试图在 pandas 里复刻每一个 dplyr 动词。先掌握 筛选 → 分组 → 聚合 → 排序 四件事,已经能覆盖大部分工程数据分析。绘图可以继续用 Matplotlib,或考虑 seaborn / plotnine(更接近 ggplot2)。
df.groupby("team")["score"].mean() 得到什么?
groupby("team") 把行按 team 分组,["score"] 选中 score 列,.mean() 对每组求均值,结果是一个以 team 为索引的 Series。
要筛选 score 大于 90 的所有行,正确写法是?
df["score"] > 90 生成布尔 Series,再用它筛选行:df[布尔条件]。注意列名要加引号,且条件本身要作用在列上。
Chapter 12 · Reference & practice
迁移速查表与综合练习
最后把三套旧语言的高频写法压成速查表,准备八个可以直接运行的小案例, 再用五个综合练习检验自己。建议收藏这一页,遇到“这个在 Python 里怎么写”时回来查。
12.1 MATLAB → Python 速查
| 任务 | MATLAB | Python |
|---|---|---|
| 第一个元素 | a(1) | a[0] |
| 最后一个 | a(end) | a[-1] |
| 切片 | a(2:5) | a[1:5] |
| 逐元素乘 | a .* b | a * b(NumPy) |
| 矩阵乘 | a * b | a @ b |
| 幂 | a .^ 2 | a ** 2 |
| 长度 / 尺寸 | length(a) / size(a) | len(a) / a.shape |
| 转置 | a' | a.T |
| 拼接 | [a b] | np.hstack([a, b]) |
| 求和 | sum(a) | a.sum() / np.sum(a) |
| 按维度求和 | sum(a, 2) | a.sum(axis=1) |
| 查找非零 | find(a > 0) | np.where(a > 0)[0] |
| 空值 | NaN / isnan | np.nan / np.isnan |
| 绘图 | plot(x, y) | ax.plot(x, y) |
| 函数 | function y = f(x) ... end | def f(x): return y |
| 字符串格式化 | sprintf("%d", x) | f"{x}" |
| 逻辑运算 | && || ~ | and or not |
| 循环 | for i = 1:n | for i in range(1, n + 1) |
12.2 R → Python 速查
| 任务 | R | Python |
|---|---|---|
| 赋值 | x <- 1 | x = 1 |
| 索引 | x[1] | x[0] |
| 数据框 | data.frame | pandas.DataFrame |
| 列 | df$col | df["col"] |
| 筛选行 | df[df$x > 0, ] | df[df["x"] > 0] |
| 分组汇总 | aggregate / dplyr | groupby(...).agg(...) |
| 排序 | order() / arrange() | sort_values() |
| 新增列 | mutate() | df["new"] = ... |
| 缺失值 | NA / is.na() | None / np.nan / pd.NA |
| 因子 | factor() | astype("category") |
| 安装包 | install.packages() | pip install |
| 绘图 | ggplot2 | Matplotlib / seaborn / plotnine |
| 管道 | %>% / |> | 方法链 . |
| 函数 | function(x) { ... } | def f(x): ... |
12.3 Visual Basic → Python 速查
| 任务 | Visual Basic | Python |
|---|---|---|
| 变量声明 | Dim x As Integer = 1 | x = 1 |
| 条件 | If ... Then ... End If | if ...: + 缩进 |
| 循环 | For i = 1 To 5 | for i in range(1, 6): |
| 遍历集合 | For Each x In items | for x in items: |
| 函数 | Function F(x As Double) As Double | def f(x: float) -> float: |
| 逻辑运算 | And / Or / Not | and / or / not |
| 字符串拼接 | a & b | f"{a}{b}" / a + b |
| 空值 | Nothing | None |
| 布尔值 | True / False | True / False |
| 注释 | ' comment | # comment |
| 语句结尾 | 换行(可加 _ 续行) | 换行(括号内可自然续行) |
| 类 / 当前实例 | Class / Me | class / self |
12.4 十个最容易踩的坑
- 01 · ^ 不是幂Python 的
^是按位异或,幂用**。 - 02 · range 右开
range(1, 5)只到 4;1 到 5 要写range(1, 6)。 - 03 · 0 基索引第一个元素是
a[0],切片终点也不包含。 - 04 · / 与 //
/总是浮点,//才是整除。 - 05 · = 不是复制列表赋值共享引用,用
.copy()。 - 06 · 可变默认参数默认值不要写
[]或{},用None。 - 07 · == 与 is
==比较值,is比较身份;判空用is None。 - 08 · 字符串 + 数字不会隐式转换,用 f-string 或
str()。 - 09 · 中英文标点代码里的逗号、冒号、括号必须是英文半角,中文标点会 SyntaxError。
- 10 · NumPy 的 *逐元素乘用
*,矩阵乘用@,别和 MATLAB 混淆。
12.5 八个可运行小案例
下面八个案例由浅入深,覆盖字符串、容器、循环、函数、NumPy、pandas 和 Matplotlib。 每个案例都能直接点“运行”看结果,末尾的“改一改”建议可以用来练手。 学习新语言最有效的方式,就是把案例改成自己的数据再跑一遍。
案例 1 · 成绩统计与等级
把列表、函数、字典计数和 f-string 串起来:遍历分数、累加总分、用字典统计各等级人数。
对应 MATLAB 里“先写循环再 tabulate”、R 里 table() 的常见流程。
改一改:把 scores 换成你自己的成绩,或把分数线改成 85 / 75 / 60,观察等级分布的变化。
案例 2 · 用筛法找质数
埃拉托斯特尼筛法:先假设所有数都是质数,再从 2 开始把每个质数的倍数划掉。
重点是布尔列表、range 的步长和列表推导式,这三个都是 Python 的高频工具。
改一改:把 limit 改成 200,先猜一猜质数个数,再运行验证。
案例 3 · 二分查找
在已排序的列表里查目标值,每次把搜索范围缩小一半。
函数同时返回下标和比较次数,方便观察 O(log n) 的效果;注意 Python 的 // 才是整除。
改一改:在 data 里插入 40(保持有序),再查找一次;然后把列表长度翻倍,观察比较次数的增长。
案例 4 · 词频 Top N
collections.Counter 是统计频次的利器,相当于 R 的 table()。
配合 most_common(),几行代码就能完成“分词 + 计数 + 排序”。
改一改:换成一段英文句子,用 text.lower().split() 统一大小写后再统计;把 most_common() 改成 most_common(3)。
案例 5 · 蒙特卡洛估算 π
在一个边长为 1 的正方形里随机撒点,落在四分之一圆内的比例约为 π/4。 这是“循环 + 随机数”的经典组合,也展示了为什么数值计算最终要向量化。
改一改:把 n 改成 1_000_000,看误差是否变小;然后把 for 循环换成 NumPy 的 rng.random(n) 与布尔索引,体验向量化的速度。
案例 6 · NumPy 最小二乘拟合
工科最常用的数据处理之一:给一组带噪声的测量值拟合直线。
np.linalg.lstsq 负责求解,@ 是矩阵乘法,R² 用来衡量拟合好坏。
改一改:把噪声的 scale 从 0.8 改成 2.0,观察拟合系数和 R² 如何变化;再试试把直线换成二次多项式 y = a x² + b x + c。
案例 7 · pandas 缺失值与分组
真实数据几乎都有缺失值。这个案例先统计缺失数量,再用均值填充,最后按组汇总。
对应 R 里的 is.na()、mean(na.rm = TRUE) 和 aggregate()。
改一改:把 mean() 换成 median(),比较两种填充方式对分组均值的影响;再试试 dropna() 直接删除缺失行。
案例 8 · Matplotlib 阻尼振荡
用 NumPy 生成时间序列,用 Matplotlib 画曲线和包络线。
这是“函数采样 + 绘图”的最小完整流程,和 MATLAB 的 plot(t, y) 几乎一一对应。
改一改:把衰减系数 0.25 改成 0.1,观察振荡衰减变慢;再把 cos(t) 换成 sin(2 * t),比较频率变化。
12.6 五个综合练习
先自己写,再展开参考答案。每个练习都可以直接在本页的运行框里试(把代码粘进去)。
01温度换算表
用循环打印从 −40°C 到 100°C、每隔 20°C 的摄氏度与华氏度对照表,保留 1 位小数,并对齐列。
for c in range(-40, 101, 20):
f = c * 9 / 5 + 32
print(f"{c:>4}°C = {f:>6.1f}°F")
02不用 NumPy 的统计函数
写一个 describe(values),返回均值、中位数和样本标准差(用标准库 statistics)。
from statistics import mean, median, stdev
def describe(values):
return {
"mean": mean(values),
"median": median(values),
"stdev": stdev(values),
}
print(describe([2, 4, 4, 4, 5, 5, 7, 9]))
03词频 Top 3
统计一句话中每个单词出现的次数,输出出现最多的 3 个。提示:collections.Counter。
from collections import Counter
text = "data science is fun data science is useful"
counts = Counter(text.split())
print(counts.most_common(3))
04NumPy 标准化
生成 100×3 的正态随机矩阵,对每一列做 z-score 标准化,并验证每列均值约为 0、标准差约为 1。
import numpy as np
rng = np.random.default_rng(0)
m = rng.normal(loc=10, scale=2, size=(100, 3))
z = (m - m.mean(axis=0)) / m.std(axis=0)
print(np.round(z.mean(axis=0), 10))
print(np.round(z.std(axis=0), 10))
05Pandas 分组通过率
给每个 team 计算 score >= 90 的比例,并按通过率从高到低排序。
import pandas as pd
df = pd.DataFrame({
"team": ["A", "A", "B", "B", "C"],
"score": [88, 92, 79, 95, 85],
})
df["passed"] = df["score"] >= 90
result = (
df.groupby("team")["passed"]
.mean()
.sort_values(ascending=False)
)
print(result)
12.7 结课自检
- 我能解释 list 和 NumPy ndarray 的区别,并知道什么时候用哪个。
- 我写循环时会自然想到
range的右开区间和 0 基索引。 - 我知道函数默认参数不能直接写可变对象。
- 我能用 NumPy 做向量化运算,而不是写双重循环。
- 我能用 pandas 做筛选、分组、聚合和排序。
- 我知道怎么创建虚拟环境、安装依赖,并记录 requirements.txt。
- 我遇到 traceback 会从最后一行开始读,而不是从头慌。
官方教程 docs.python.org/3/tutorial; NumPy 快速入门 numpy.org; pandas 十分钟 pandas.pydata.org。 遇到问题先读报错最后一行,再查官方文档——这比复制粘贴更快。