基础数学与随机数 — NumPy 和蒙特卡洛的第一次实战Copy Anchor Link

这一章是全书从「语言课」转向「干活课」的转折点。 前半教 Python 的算术和 import 的正确姿势; 后半进入科学计算的主航道:NumPy(数值计算的标配库)和随机数。 读完你会写出第一段真正的科学代码——用随机投点估算 π,并理解「种子」为什么让随机数也能复现。

1. 这一章讲什么Copy Anchor Link

作者开场的定位很准:「扎实的数学和逻辑思维,毫无疑问是任何软件的基础——这正是科学家和工程师有潜力成为好软件工程师的原因。」 语法各家语言不同,即使你会 C++,Python 也有几处「别的语言向东、它向西」的细节。¹

本章路线:

  算术运算符(+/−/*、/、//、%、**)  →  import 的四种姿势与坑
      →  NumPy:等间距数组、矩阵、转置、逆、特征值
      →  图像 = 矩阵(翻转、旋转、傅里叶滤波)
      →  随机数:种子、均匀/正态分布、蒙特卡洛估算 π
  图说:这是一条「从计算器到仿真」的坡道,每一节都建立在前一节的对象上。

2. 核心原理一:算术运算符——「别的语言向东,Python 向西」的三处Copy Anchor Link

解决什么问题: 数学运算的符号各家语言大同小异,但有三处细节会坑住从别的语言来的人。

怎么做: 对照表(走一遍具体数):²

为什么有效、边界在哪: 记住一句话就够:/ 永远返回浮点数,哪怕 4 / 2 也是 2.0。 整除和取余在密码学、哈希(把任意数据映成定长指纹的技术,dict 的快速查找就是靠它)里大量出现。

3. 核心原理二:import 的四种姿势——名字从哪来必须一眼可见Copy Anchor Link

解决什么问题: 用 math 模块的 cos 之前,得先回答「cos 是哪个 cos」——你自己的,还是库里的?

怎么做: 书里把四种写法摆开并逐一评级(以 math.cos(0) 为例):³

import math              # ① 每次写 math.cos(0) —— 啰嗦,但出处永远可见 ★推荐
from math import *       # ② cos(0) —— 库里几百个名字全进你的命名空间,撞名没人告诉你 ✗
from math import cos     # ③ cos(0) —— 只引进一个,尚可;但读代码时仍不如 ① 显眼
import math as m         # ④ m.cos(0) —— 基本没必要:库名本身就短

为什么有效: 判据是「读代码的人(第 02 章!)看到 cos(0) 时,能不能不查别处就知道它来自哪」。 两种例外是行业惯例的缩写:import numpy as np、import matplotlib.pyplot as plt—— 惯例缩写可以,自创缩写免谈。³

4. 核心原理三:NumPy——数值计算的主引擎Copy Anchor Link

4.1 为什么需要它Copy Anchor Link

解决什么问题: 纯 Python 做数值计算慢(第 01 章:解释执行);科学计算要处理海量数字。

怎么做: NumPy 是数值计算最重要的库,底层用 C 写的,所以比纯 Python 代码快得多; 多数科学领域都在用。⁴

第一个工具:linspace(linear spacing,线性等分)——在区间里均匀取点:

import numpy as np
np.linspace(1, 3, 5)     # array([1. , 1.5, 2. , 2.5, 3. ]) —— 1 到 3 之间均匀取 5 个点

对比用列表推导式手搓 [i/10 for i in range(10, 35, 5)] 的等价物——作者的裁决:「那样难读得多。」 这是 NumPy 的信条预告:表达「数组层面的运算」,而不是「对元素逐个写循环」。⁵

4.2 矩阵:一门语言级的对象Copy Anchor Link

解决什么问题: 线性代数是科学计算的语言;矩阵是它的字母。

怎么做(主线例子): 定义、变换、相乘、分解,一条链走完:⁶

m = np.matrix([[1, 2], [3, 4]])
m.getT()                    # 转置:[[1, 3], [2, 4]] —— 行列互换
from numpy.linalg import inv
inv(m)                      # 逆矩阵,乘回原矩阵得单位阵
3*m                         # 数乘:[[3, 6], [9, 12]]
m*inv(m)                    # [[1, 0], [8.88e-16, 1]] ← 右下角不是精确 0!

最后那个 8.88e-16 值得停一拍:矩阵求逆的数值过程带舍入(第 03 章的浮点幽灵回来了—— 8.88e-16 是 8.88×10⁻¹⁶,离 0 近到任何工程目的下都该算 0,但不是 0)。 书里顺势演示特征值分解(eigenvalue):每个矩阵有一些特殊方向,矩阵作用在这些方向上只把向量拉长、不改变方向——拉长的倍数就是特征值,那个方向就是特征向量。 用它们可以把矩阵「对角化」——非对角元同样只是「非常接近 0」。⁷

为什么有效: NumPy 把「矩阵」从「列表的列表」升级成一等对象:转置、求逆、特征分解都是一行; 同时它时刻提醒你——浮点没有精确零。

4.3 图像就是矩阵:翻转、旋转与傅里叶滤波Copy Anchor Link

解决什么问题: 一张图片,每个像素是几个数值(颜色分量),按行列排——「这听起来就是矩阵的完美应用场景,不是吗?」⁸

怎么做: 生成一张 200×200 的渐变图:三层循环填每个像素的红绿蓝分量,存成 PNG。 进阶是三种几何操作,各一行:np.flipud(上下翻转)、np.fliplr(左右翻转)、np.rot90(旋转 90°)。⁹

更精彩的收尾是滤波,需要一点背景:傅里叶变换(Fourier transform,把信号拆成不同频率的正弦成分; 书里明说没讲、推荐读者去学的那个)可以把图像变到「频率域」—— 那里能做一件空间域做不到的事:把高频(快速变化的细节)一刀切掉再变回来。

img_fft = np.fft.fft2(img_input)                    # 变到频率域
img_fft_filtered = img_fft * (np.abs(img_fft) > np.abs(img_fft).mean())  # 只留幅度高于均值的成分
img_output = np.real(np.fft.ifft2(img_fft_filtered)) # 变回来

效果:低通(砍掉高频)让图变糊但主体还在;高通(只留高频)只剩边缘和噪点。 作者的洞察是压缩的原理:被砍掉的成分对人眼几乎不可见——JPEG 压缩就靠这一招, MP3 对声音同理;低通加高通能拼回原图(只差舍入误差),证明信息没丢,只是搬了家。¹⁰

边界: 这段是「演示级」而非「生产级」——真实 JPEG 用的是离散余弦变换不是裸傅里叶阈值, 但「变换域里扔掉人感知不到的成分」这个思想是准的。

4.4 图像代码的完整走查:一个像素一个像素造渐变图Copy Anchor Link

书里生成渐变图的代码,值得逐行走——它是「矩阵思维」的第一次完整实战:⁸

import imageio.v2 as imageio
import numpy as np

height, width = 200, 200
image_array = np.zeros((height, width, 3), dtype=np.uint8)
# 造一个 200×200×3 的三维数组,全部清零 → 全黑图
# dtype=np.uint8:每个格子是 0–255 的整数(像素的标准范围)

for i in range(height):
    for j in range(width):
        image_array[i, j] = [i * 255 // height, 0, j * 255 // width]
        # 红色分量随行号 i 线性增加(0→255),蓝色分量随列号 j 增加,绿色恒 0
        # i*255//height 是整数除法:第 0 行红=0,第 199 行红=199*255//200≈254

imageio.imwrite("gradient_image.png", image_array)   # 数组 → PNG 文件

走一遍关键数:第 100 行第 0 列的像素,红 = 100×255//200 = 127,蓝 = 0 → 暗红色; 第 199 行第 199 列:红≈254,蓝≈254 → 亮紫。每个像素是数组的一个格子,改格子就是改图。 这个等价关系(图像 = 数组)一旦建立,后面所有图像操作(翻转、滤波)都只是数组运算。⁸

4.5 三种几何操作,各一行Copy Anchor Link

img_array = imageio.imread("apress_logo.png")     # 读图 → 数组

flipped_vertical   = np.flipud(img_array)          # 上下翻转:flip up-down
flipped_horizontal = np.fliplr(img_array)          # 左右翻转:flip left-right
rotated_90         = np.rot90(img_array)           # 旋转 90 度

三个函数名都自带说明(flip up/down、left/right、rotate 90)——NumPy 的命名里, 这种「见名知义」的函数占大多数,记住方向词(ud/lr/90)就够,不用背。⁹

5. 核心原理四:随机数与蒙特卡洛Copy Anchor Link

5.1 种子:让「随机」可以复现Copy Anchor Link

解决什么问题: 调试时,如果每次运行结果都不同,你无法确认「修好的 bug 是真的好了还是这次随机数碰巧没触发」。

怎么做: 随机数其实是算出来的——公式 xₙ₊₁ = (a·xₙ + b) mod m,从种子 x₀ 出发逐项递推。 同一颗种子,整个序列逐位复现:¹¹

import random
random.seed(0)
random.random()    # 0.8444218515250481
random.random()    # 0.7579544029403025
random.seed(0)
random.random()    # 0.8444218515250481 —— 从头再来,一模一样

为什么有效、边界在哪: 「可复现的随机」听着矛盾,实为调试的命脉(书里的原话:多数情况下, 可复现是好事,排错容易)。红线:这个库的随机不能用于密码学——序列由公式生成, 理论上可以从一个数反推前后所有数;密码学要用 secrets 模块(书里只说「别用于密码学」,补充模块名)。¹¹

随机数算法本身也值得一行解释:公式 xₙ₊₁ = (a·xₙ + b) mod m 是线性同余生成器, a、b、m 是精心挑选的常数,种子是起点 x₀。它的性质一句话:好到骗过日常使用,不够好骗过密码学家—— 相邻数之间没有肉眼可见的模式(统计测试通过),但序列完全由种子决定,知道一个数就能推全部。 日常仿真、洗牌、蒙特卡洛,它足够;要不可预测,换 secrets 或 os.urandom(后两个名字是补充)。¹¹

常用变体:random.choice(列表) 随机挑一个;random.randint(3, 9) 给范围内的随机整数。 想换区间?乘一个数:2*random.random() 把 [0,1) 均匀扩成 [0,2)。

random.gauss(mu=0, sigma=1) 生成高斯分布的随机数——先记住这个名字,马上解释。

「分布」说清每个值出现的频繁程度。高斯分布(也叫正态分布、钟形曲线)的形状是「中间高、两边低」的那一个。

参数 mu 是均值——钟形的中心;sigma 是标准差——钟形摊开有多宽。¹²

5.2 蒙特卡洛估算 π:投点法Copy Anchor Link

解决什么问题: 有些量没有(或很难有)解析公式,但可以靠大量随机试验逼近。

怎么做(主线例子,全章收官): 在边长 2 的正方形里均匀撒点(坐标各取 −1 到 1 的随机数), 数有多少落在内切圆里。圆面积/正方形面积 = π/4,所以:¹³

import random
n = 100000
inside_circle = 0
random.seed(0)
for _ in range(n):
    x = random.uniform(-1, 1)
    y = random.uniform(-1, 1)
    if x**2 + y**2 <= 1:        # 到原点的距离平方 ≤ 1 ⟺ 在圆内
        inside_circle += 1
pi_estimate = (inside_circle / n) * 4
print(pi_estimate)              # 3.129

走一遍:n = 100,000 个点;约 78,550 个落在圆内(这个约数是为演示编的,实际由种子决定); 78,550/100,000 ≈ 0.7855,× 4 ≈ 3.142,逼近真值 3.14159…。 投得越多越准,但精度只按 √n 提高——想多一位有效数字,点数次方倍地涨,这就是蒙特卡洛(Monte Carlo, 以赌城命名的随机模拟方法)「笨拙但万能」的本性。书里给了 n=100,000 跑出 3.129 的实例,误差在预期内。¹³

这个例子的几何部分也值得写透:为什么「圆内比例 × 4」就是 π?

  正方形面积 = 2×2 = 4(边长 2,坐标 ±1)
  内切圆面积 = π×1² = π(半径 1)
  圆/正方形 = π/4

  随机撒点 → 落在圆内的比例 ≈ π/4 → × 4 ≈ π

判断「在圆内」用勾股:x² + y² ≤ 1——到原点的距离不超过半径。代码里那行 if x**2 + y**2 <= 1 就是这句话。蒙特卡洛的通用配方也在这:把一个面积/体积比问题, 换成「撒点计数」问题——高维体积没人会算,但撒点人人会写。¹³

「笨拙但万能」再补一个数感:n=100,000 时标准误差约 √(p(1−p)/n) ≈ 0.0013(这个数是我们按二项分布估的), 所以 3.129 距离真值 0.012 约 9 个标准误——比典型蒙特卡洛误差偏大, 原因是 random.seed(0) 的这一条特定序列恰好不够走运;换种子,误差会围绕 0.0013 波动。 「种子的运气」本身也是蒙特卡洛的一部分——报告误差时记得带上种子的编号。¹³

4.6 傅里叶滤波,三步走完Copy Anchor Link

滤波代码压缩成三步走,每步有明确的输入输出:¹⁰

  ① img_fft = np.fft.fft2(img_input)
     图像(空间域)→ 频率域表示:每个格子的数,代表一种「空间频率」的强弱
     (低频 = 大片平缓区域;高频 = 边缘、噪点、细节)

  ② img_fft_filtered = img_fft * (np.abs(img_fft) > np.abs(img_fft).mean())
     逐个格子判断:这个频率的强度超过全体平均吗?
     超过 → 保留(乘 1);不超过 → 归零(乘 0)——一刀切在平均值上

  ③ img_output = np.real(np.fft.ifft2(img_fft_filtered))
     滤波后的频率域 → 变回图像;np.real 取实部(变换过程会引入可忽略的小虚部)

高通版只改 ② 的比较方向(<= 保留弱的):结果「失去所有有价值的信息,只剩噪声」—— 这个对比本身就是最好的直觉教材:低频承载主体,高频承载细节;砍掉哪边,图就变成哪边的样子。 低通图「变糊但 logo 还在」,高通图「只剩边缘和噪点」。¹⁰

为什么这套做法能压缩?砍掉的高频成分「人眼几乎看不见」,存文件时它们那部分数据就不用存了—— 「看不见」是感知层面的判断,不是信息层面的(像素数没变),所以压缩是感知无损、数学有损的。 JPEG 的具体实现用离散余弦变换(分块处理,更适合硬件),但「变换域里扔人眼不敏感的成分」 这个思想,两个算法完全一致。¹⁰

验证手段书里也给了:低通图 + 高通图逐像素相加,几乎还原原图(差舍入误差)—— 「滤波没有毁掉信息,只是把信息搬了家」的最直接证据。做数值工作,这种「加回去看能不能还原」 的自检值得养成习惯。¹⁰

5.5 math 模块,最小可用清单Copy Anchor Link

import math 之后,书里点到的和日常常用的合一张小表(函数名后附一行用途):

三角函数用弧度这个坑值得现在就记住:cos(90) 不是 0,是 cos(90 弧度)≈−0.448; 要算角度的余弦,先 math.radians(90) 转成弧度。一次转换,终身免坑(书外补充,书里只用了 cos(0)=1 这个安全样例)。³

6. 作者的判断与证据Copy Anchor Link

书里给了证据的: 全部算式可直接运行;π 估算给了真实种子下的具体输出;低通+高通叠加回原图的实验是漂亮的自证。¹⁰¹³

作者的判断(经验与推荐):

• 「傅里叶变换值得学,虽然要花一阵子」——诚恳的推荐;
• 「随机数多数时候要可复现」——实践共识;
• 「NumPy 因为 C 实现所以快」——机制事实,成立;严格说快的第一原因是向量化(整个数组运算一次进 C 循环, 不是「C 版逐元素」而已),书里只给了结论;
• 「随机数多数时候要可复现」——实践共识,完全正确;
• 把 JPEG/MP3 的直觉讲成「砍掉高频成分」——方向正确、细节省略了变换类型(已在 §4.6 边界标注);
• 「傅里叶变换值得学,虽然要花一阵子」——诚恳的推荐,值得认真对待:这是信号处理的通用语。
• 把 JPEG/MP3 的直觉讲成「砍掉高频成分」——方向正确、细节省略了变换类型的差别(已在边界标注)。

6.1 本章的实战组合,串成一条线Copy Anchor Link

  算术(//、%、**) → import(math) → NumPy(数组/矩阵) → 图像(数组=像素)
      → 随机数(种子/分布) → 蒙特卡洛(投点估 π)
  图说:这条线从「计算器」走到「仿真器」,中间每一步都在为下一步准备对象:
       数组是矩阵,矩阵是图像;种子是随机,随机是蒙特卡洛。

走完这条线,你就具备了科学计算的最小完整闭环:写算式 → 组织数据 → 造/读数据 → 算 → 验证。 后面三章(Matplotlib 画图、Pandas 洗数据、数值数学)分别是这条线的三个加粗段。

判断(我们的,不是书里的): 本章教的内容(算术、import、NumPy、随机数)没有一条会过时, 会过时的是「手写一切」的默认姿势——2026 年的实际做法是调库优先: 积分找 scipy.integrate,画图找 Matplotlib(第 16 章),表格找 Pandas(第 17 章)。 但本章的 Mechanism(数组思维、种子语义、整列运算)在库的内部照样成立—— 库是别人的 NumPy,直觉是你自己的。 如果错,会错在: 如果连库的输入形状都因为不懂数组思维而搞错,调库也只是换个地方报错; 所以「先学机制、后用库」的顺序不能省,省掉机制,库的错误信息也读不懂。

7. 边界与局限Copy Anchor Link

• 傅里叶变换本身没讲(作者明说),滤波代码只能当黑箱演示;
• 蒙特卡洛只有投点一例,精度按 √n 收敛(收敛 = 越来越逼近某个值)这个关键性质书中没点破,本章补上;
• NumPy 数组 vs 矩阵类的区别、np.array 才是日常推荐,书里全用 np.matrix(现代 NumPy 推荐 array);
• 没提向量化循环——NumPy 快的第一原因(把循环挪进 C),本书没有展开; 判断标准很简单:看见自己对数组写 for 循环,就停手想三秒能不能写成整列运算(第 17 章的价格公式是样板);
• 图像部分没讲彩色模型(RGB 三通道)和透明通道,翻转旋转之外的编辑(裁剪、缩放)没提;
• 高斯分布只给了生成,没讲它和「钟形」形状的定量关系(68-95-99.7 规则,书外补充:距均值 1、2、3 个标准差的覆盖率);

8. 可带走的Copy Anchor Link

本章主线例子,一行写完: np.linspace(1, 3, 5) 均匀取点 → m.getT()/inv(m) 矩阵运算 → random.seed(0) 固定序列 → 正方形投点 ×4 = π ≈ 3.129。⁵⁶¹¹¹³

1. / 永远得浮点;整除 //、取余 %、幂 **;^ 是按位异或,不是幂。
2. import 用全名 import math;惯例缩写(np、plt)可以,from ... import * 免谈。
3. NumPy 是数值计算主引擎,C 实现、快;linspace 是等间距取点的日常工具。
4. 矩阵是一等对象:转置、逆、特征分解各一行;但浮点没有精确零(8.88e-16 那一步)。
5. 图像 = 矩阵:翻转旋转各一行;JPEG 的直觉是「频率域砍掉人眼看不见的成分」。
6. 随机数是种出来的:同种子同序列,调试依赖它;密码学别用它。
7. 蒙特卡洛:投点估 π = 圆内比例 × 4;笨拙但万能,精度按 √n 涨。
8. 种子 = 可复现的随机:调试的命脉;密码学别用它,找 secrets。
9. 图像 = 数组:改格子就是改图;翻转旋转各一行(ful/lr/rot90)。
10. 给数组写 for 循环前停三秒——整列运算几乎总是更快、更短、更少错。

8A. 从书到项目:NumPy 的第一步Copy Anchor Link

书教到「矩阵运算各一行」,落地时第一步往往是:把手头的表格数据搬进 NumPy。最小路径:

  列表的列表 → np.array(列表) → 数组
  从此:加减乘除、转置、统计,全是整列运算

(这两行是书外补充,衔接第 17 章:Pandas 读进来的表,底层 .values 就是 NumPy 数组。)

9. 原文地图Copy Anchor Link