简介：这份资源是《程序员数学：用Python学透线性代数和微积分》的配套设计源码，面向希望夯实数学基础、提升算法与建模能力的开发者，尤其适合正在学习机器学习、数据分析或准备相关岗位面试的程序员。包内共105个文件，以74个Python源文件与17个Jupyter Notebook交互式文档为主，另有7张教学图片、3个off模型文件及txt、pdf等辅助说明，压缩包约37.25MB。Python源码覆盖矩阵运算、向量空间分析、微分与积分等核心算法的动手实现，Notebook则支持在浏览器中直接运行代码并可视化数学概念，帮助读者把抽象理论转化为可调试的实践过程。目前已有458人学习下载。整体目录按章节组织，从基础概念讲解到配套编程任务层层递进，读者可据此系统梳理线性代数与微积分的知识脉络，并借助可复用代码快速迁移到实际项目中。
1. 程序员数学用 Python 重学：这套源码能省掉多少推导时间
很多人学线性代数和微积分时，卡住的地方不是概念本身，而是「公式看懂了，代码写不出来」。矩阵乘法手算会，但用 NumPy 实现时维度对不上；梯度下降的公式背得滚瓜烂熟，真让你写一个能跑的优化循环，又不知道步长怎么调、什么时候停。这套基于 Python 的程序员数学源码，解决的就是这个断层——它把线性代数和微积分里的核心概念，用可运行的 Jupyter Notebook 逐个实现出来，不是伪代码，不是公式截图，是能直接跑、能改参数、能看到中间结果的那种。
适合谁？正在补数学基础的程序员、准备转方向做算法或数据分析的人、以及教书时需要现成演示材料的老师。它不教你 Python 语法，也不教你数学定义，它做的是把两者接起来。你需要的是一台能跑 Python 的机器，和一点「愿意动手改代码」的耐心。
2. 环境搭起来：Jupyter Notebook 跑数学代码的正确姿势
2.1 为什么选 Jupyter 而不是普通 .py 文件
数学代码和业务代码有个本质区别：你需要反复看中间结果。矩阵乘完长什么样、梯度每一步降了多少、数值积分误差随步长怎么变——这些如果每次都 print 到终端，调试效率极低。Jupyter Notebook 的单元格机制天然适合这种「算一步、看一眼、再改」的节奏。
常见做法是装 Anaconda，它自带 Jupyter 和 NumPy、SymPy、Matplotlib 这些数学必备库。但 Anaconda 体积大，如果你已经有 Python 环境，直接 pip 装也行。我一般会建议用虚拟环境隔离，避免和系统里的包打架。
# 创建虚拟环境（Python 3.9 以上都行） python -m venv math_env # 激活：Windows math_env\Scripts\activate # 激活：macOS / Linux source math_env/bin/activate # 装核心依赖 pip install jupyter numpy sympy matplotlib scipy这里几个包的分工要说清楚：NumPy 负责数值计算，矩阵、向量、特征值都靠它；SymPy 负责符号计算，求导、积分、化简表达式用它；Matplotlib 负责可视化，函数图像、梯度下降轨迹都靠它画；SciPy 补充数值积分和优化算法。版本上没有严格限制，但 NumPy 建议 1.24 以上，SymPy 建议 1.12 以上，避免一些老版本 API 变动带来的报错。
装完之后jupyter notebook启动，浏览器会自动打开工作目录。把源码包里的 .ipynb 文件放进去，逐个打开就能跑。
2.2 源码包的结构与阅读顺序
拿到源码包后别急着从头跑到尾。这类数学源码通常按主题分文件，合理的阅读顺序是先线性代数再微积分，因为微积分里的很多操作（比如雅可比矩阵、海森矩阵）本身就依赖线性代数的工具。
打开一个 Notebook 后，先看第一个单元格的 import 部分，确认依赖都装了。然后从上往下逐格执行，遇到报错先看是不是包版本问题。常见的一个坑是：有些 Notebook 用了np.float或np.int，这在 NumPy 1.24 之后已经废弃，会直接报 AttributeError。解决办法是把np.float改成float，np.int改成int，或者用np.float64。
提示：如果 Notebook 里用了
from numpy import *这种写法，注意它可能覆盖 Python 内置的sum、max等函数，导致后续代码行为异常。建议改成import numpy as np的显式导入。
跑通第一个 Notebook 之后，不要只是「运行全部单元格」就完事。每个代码块后面通常有 Markdown 说明，告诉你这段代码在验证什么数学性质。比如矩阵乘法那一节，它会先定义一个矩阵，再手动算一遍结果，然后用 NumPy 验证。你要做的是改掉矩阵的数值，自己先手算一遍，再跑代码对答案。这个「手算—验证」的循环，才是这套源码真正的用法。
3. 线性代数模块：从矩阵运算到特征值分解的代码落地
3.1 矩阵乘法与逆矩阵：维度对齐是第一个坎
线性代数代码里最高频的报错就是维度不匹配。np.dot(A, B)要求 A 的列数等于 B 的行数，但很多人写代码时凭感觉定义矩阵，跑起来才发现对不上。源码里通常会用注释标出每个矩阵的 shape，但你自己改数值时很容易忽略。
import numpy as np # 定义两个矩阵，注意 shape 标注 A = np.array([[1, 2], [3, 4], [5, 6]]) # shape: (3, 2) B = np.array([[7, 8, 9], [10, 11, 12]]) # shape: (2, 3) # 矩阵乘法：A 的列数(2) == B 的行数(2)，结果 shape 为 (3, 3) C = np.dot(A, B) print("A @ B =\n", C) # 逆矩阵：只有方阵才有逆，且行列式不为零 D = np.array([[2.0, 1.0], [1.0, 3.0]]) D_inv = np.linalg.inv(D) print("D 的逆 =\n", D_inv) # 验证：D @ D_inv 应该接近单位矩阵 print("D @ D_inv =\n", np.dot(D, D_inv))这段代码的逻辑很直白：先构造两个形状互补的矩阵做乘法，再对一个方阵求逆并验证。参数上要注意的是，np.linalg.inv对奇异矩阵会抛LinAlgError，实际使用中如果矩阵接近奇异，求出来的逆矩阵数值不稳定，这时候应该用np.linalg.solve解线性方程组，而不是显式求逆。源码里如果有解方程的部分，通常会体现这个区别。
另一个容易翻车的地方是整数矩阵求逆。如果 D 是整数类型的 array，np.linalg.inv会先转成浮点再算，结果没问题，但如果你后续要做精确的符号运算，就得用 SymPy 的Matrix.inv()，它返回的是分数形式，不会丢精度。
3.2 特征值与特征向量：理解np.linalg.eig的返回值
特征值分解是线性代数里最常被调用的工具之一，PCA、谱聚类、马尔可夫链稳态分布都靠它。但np.linalg.eig的返回值顺序是不保证的，而且对非对称矩阵可能返回复数特征值，这两点经常让人困惑。
import numpy as np # 对称矩阵，特征值一定是实数 A = np.array([[4, 1], [1, 3]]) eigenvalues, eigenvectors = np.linalg.eig(A) print("特征值:", eigenvalues) print("特征向量矩阵:\n", eigenvectors) # 验证：A @ v = lambda * v for i in range(len(eigenvalues)): lam = eigenvalues[i] v = eigenvectors[:, i] print(f"lambda={lam:.4f}, A@v={np.dot(A, v)}, lambda*v={lam * v}")这段代码先对一个对称矩阵做特征分解，然后逐个验证定义式。关键参数在于eigenvectors的每一列才是一个特征向量，不是每一行。很多人第一次用的时候会搞混，取eigenvectors[0]以为是第一个特征向量，实际上那是第一行。验证循环里eigenvectors[:, i]才是正确的取法。
对于非对称矩阵，特征值可能是复数，NumPy 会返回 complex 类型。如果你只关心实数部分，可以用np.real()提取，但要注意这可能会丢失信息。源码里如果有涉及非对称矩阵的例子，通常会提醒这一点。
注意：
np.linalg.eig不保证特征值按大小排序。如果你需要按特征值从大到小排列（比如做 PCA），得自己加排序逻辑：idx = np.argsort(eigenvalues)[::-1]，然后用eigenvalues[idx]和eigenvectors[:, idx]重新排列。
3.3 用 SymPy 做符号化矩阵运算：什么时候该用它
NumPy 做数值计算快，但如果你需要精确的分数结果、或者要推导公式，就得换 SymPy。比如求一个含参数的矩阵的行列式，NumPy 只能代入具体数值算，SymPy 可以直接给出表达式。
import sympy as sp # 定义符号 a, b, c, d = sp.symbols('a b c d') # 构造符号矩阵 M = sp.Matrix([[a, b], [c, d]]) # 行列式 det_M = M.det() print("行列式:", det_M) # 逆矩阵（符号形式） inv_M = M.inv() print("逆矩阵:", inv_M) # 特征值（符号形式） eigenvals = M.eigenvals() print("特征值:", eigenvals)SymPy 的Matrix和 NumPy 的array是两套体系，不能混用。符号运算的代价是速度慢，所以只在你需要精确表达式或推导时用。实际项目中常见的做法是：先用 SymPy 推导出公式，再把公式翻译成 NumPy 代码做数值计算。源码里如果有这种「符号推导 + 数值验证」的组合，那是很值得细看的部分。
参数方面，sp.symbols可以一次定义多个符号，M.det()和M.inv()都是直接调用，不需要额外参数。M.eigenvals()返回的是一个字典，键是特征值，值是该特征值的代数重数。如果你需要特征向量，用M.eigenvects()，返回的是(特征值, 重数, [特征向量])的列表。
4. 微积分模块：数值微分、积分与梯度下降的实现细节
4.1 数值微分：前向差分、中心差分与步长选择
微积分代码里，数值微分是最基础也最容易踩坑的部分。原理简单：用差商近似导数。但步长 h 选多大，直接决定精度。前向差分误差是 O(h)，中心差分误差是 O(h²)，但 h 太小又会因为浮点精度丢失导致结果反而变差。
import numpy as np def forward_diff(f, x, h=1e-5): """前向差分近似导数""" return (f(x + h) - f(x)) / h def central_diff(f, x, h=1e-5): """中心差分近似导数，精度更高""" return (f(x + h) - f(x - h)) / (2 * h) # 测试函数 f(x) = sin(x)，导数应为 cos(x) f = np.sin x0 = 1.0 true_val = np.cos(x0) print(f"真实导数值: {true_val:.10f}") print(f"前向差分 (h=1e-5): {forward_diff(f, x0):.10f}") print(f"中心差分 (h=1e-5): {central_diff(f, x0):.10f}") # 不同步长的中心差分对比 for h in [1e-3, 1e-5, 1e-7, 1e-9, 1e-11]: approx = central_diff(f, x0, h) print(f"h={h:.0e}, 误差={abs(approx - true_val):.2e}")这段代码先定义两种差分方法，然后对比不同步长下的误差。你会看到一个反直觉的现象：h 从 1e-5 降到 1e-9 时误差先减小，但继续降到 1e-11 时误差反而增大。原因是浮点数的有效位数有限，h 太小时f(x+h)和f(x-h)的差值被舍入误差淹没。常见做法是 h 取 1e-5 到 1e-7 之间，具体值取决于函数的光滑程度和量级。
源码里如果有数值微分的部分，通常会包含这个步长扫描的实验。别跳过它，自己跑一遍不同 h 值，观察误差曲线，比看公式推导印象深得多。
4.2 数值积分：梯形法则与辛普森法则的代码实现
数值积分的核心思想是用简单形状逼近曲线下的面积。梯形法则用直线段连接相邻点，辛普森法则用抛物线，后者精度更高但要求等距节点。
import numpy as np def trapezoid(f, a, b, n=1000): """梯形法则数值积分""" x = np.linspace(a, b, n + 1) y = f(x) h = (b - a) / n return h * (y[0] / 2 + np.sum(y[1:-1]) + y[-1] / 2) def simpson(f, a, b, n=1000): """辛普森法则数值积分，n 必须为偶数""" if n % 2 != 0: n += 1 x = np.linspace(a, b, n + 1) y = f(x) h = (b - a) / n return h / 3 * (y[0] + 4 * np.sum(y[1:-1:2]) + 2 * np.sum(y[2:-2:2]) + y[-1]) # 测试：积分 sin(x) 从 0 到 pi，精确值为 2 f = np.sin a, b = 0, np.pi true_val = 2.0 print(f"精确值: {true_val}") print(f"梯形法则 (n=1000): {trapezoid(f, a, b):.10f}") print(f"辛普森法则 (n=1000): {simpson(f, a, b):.10f}") # 收敛性对比 for n in [10, 50, 100, 500]: err_trap = abs(trapezoid(f, a, b, n) - true_val) err_simp = abs(simpson(f, a, b, n) - true_val) print(f"n={n:4d}, 梯形误差={err_trap:.2e}, 辛普森误差={err_simp:.2e}")梯形法则的实现里，y[0]/2和y[-1]/2是因为端点只被一个梯形共用，而中间点被两个梯形共用。辛普森法则的系数 4 和 2 交替出现，对应抛物线拟合的权重。参数 n 越大精度越高，但计算量也线性增长。从收敛性对比可以看出，同样 n 下辛普森法则的误差比梯形法则小几个数量级，这就是高阶方法的优势。
提示：辛普森法则要求 n 为偶数，代码里做了自动修正。如果你用 SciPy 的
scipy.integrate.quad，它内部用的是自适应算法，不需要指定 n，对大多数函数都能给出高精度结果。源码里如果两种方法都有，建议对比着看，理解「固定步长」和「自适应」的区别。
4.3 梯度下降：从数学公式到可运行代码
梯度下降是连接微积分和机器学习的桥梁。数学上它就是沿着负梯度方向迭代更新参数，但代码实现时有几个关键决策：步长怎么定、什么时候停、要不要加动量。
import numpy as np def gradient_descent(grad_f, x0, lr=0.1, tol=1e-6, max_iter=1000): """ 梯度下降求解函数极小值 grad_f: 梯度函数，返回梯度向量 x0: 初始点 lr: 学习率 tol: 梯度范数收敛阈值 max_iter: 最大迭代次数 """ x = np.array(x0, dtype=float) history = [x.copy()] for i in range(max_iter): grad = grad_f(x) if np.linalg.norm(grad) < tol: print(f"在第 {i} 步收敛") break x = x - lr * grad history.append(x.copy()) return x, np.array(history) # 测试函数 f(x, y) = x^2 + 2y^2，梯度为 (2x, 4y) def grad_f(x): return np.array([2 * x[0], 4 * x[1]]) x_opt, history = gradient_descent(grad_f, [3.0, 2.0], lr=0.3) print(f"最优解: {x_opt}") print(f"迭代次数: {len(history) - 1}")这段代码实现了一个带收敛判断的梯度下降。参数 lr 是学习率，太大会震荡甚至发散，太小收敛慢。tol 是梯度范数的阈值，当梯度足够接近零时认为到达极值点。max_iter 是保险丝，防止死循环。
你可以自己改 lr 的值观察行为：lr=0.3 时收敛很快，lr=0.6 时可能震荡，lr=1.0 时直接发散。这个实验比看任何理论分析都直观。源码里如果有梯度下降的可视化部分，通常会画出迭代轨迹，配合等高线图看，能清楚理解为什么学习率不能太大。
对于更复杂的函数，可能还需要加动量项或使用自适应学习率。但作为理解梯度下降的起点，这个最简版本足够了。先把最简版本跑通、改参数看效果，再去碰优化器的高级特性。
5. 避坑与排查：跑数学源码时最容易翻车的五个地方
5.1 现象：AttributeError: module 'numpy' has no attribute 'float'
原因：NumPy 1.24 版本移除了np.float、np.int、np.bool等别名，这些别名在旧代码里很常见。源码包如果是在旧版本下写的，直接跑就会报这个错。
解决：全局搜索np.float替换为float，np.int替换为int，np.bool替换为bool。如果代码里用的是np.float64或np.int32这种带位数的，不受影响。另一个办法是降级 NumPy 到 1.23，但不推荐，因为新版本有其他改进。
5.2 现象：矩阵乘法结果形状不对，或者报ValueError: shapes not aligned
原因：np.dot(A, B)要求 A 的最后一维和 B 的倒数第二维相等。很多人定义矩阵时没注意 shape，或者把行向量和列向量搞混了。
解决：在乘法之前先 print 一下A.shape和B.shape，确认维度匹配。如果是要做逐元素乘法，用A * B而不是np.dot。如果是要做批量矩阵乘法，用np.matmul或@运算符，它支持广播。一维数组的np.dot行为比较特殊，会做内积而不是矩阵乘法，建议显式 reshape 成二维再操作。
5.3 现象：梯度下降不收敛，损失越来越大
原因：学习率太大，或者梯度计算有误，或者数据没有归一化导致某些维度梯度量级差异过大。
解决：先把学习率调小一个数量级试试。如果还是发散，用数值微分验证梯度函数是否正确——写一个check_gradient函数，对比解析梯度和数值梯度的差异。如果差异很大，说明梯度公式推错了。另外，如果输入特征的量级差很多（比如一个特征是 0.001 量级，另一个是 1000 量级），先做标准化再跑梯度下降。
5.4 现象：Jupyter Notebook 里画图不显示，只有一行<matplotlib...>
原因：没有调用%matplotlib inline魔术命令，或者 Matplotlib 后端配置有问题。
解决：在 Notebook 第一个单元格加上%matplotlib inline。如果用的是 JupyterLab，可能需要%matplotlib widget才能交互。另外确认matplotlib.pyplot已经 import。如果还是不行，检查是不是在虚拟环境里装了 Matplotlib 但 Jupyter 用的是另一个内核——用!pip list在 Notebook 里确认当前内核的包列表。
5.5 现象：SymPy 符号计算卡死或返回结果极慢
原因：符号表达式太复杂，或者符号变量定义过多，导致化简和求解的计算量爆炸。
解决：尽量在符号运算前代入具体数值，减少符号变量数量。如果必须做符号推导，用sp.simplify之前先试试sp.expand或sp.factor，有时候能大幅简化表达式。对于矩阵符号运算，如果矩阵维度超过 4x4，符号求逆通常会非常慢，这时候应该考虑数值方法。源码里如果有大规模符号运算的例子，注意看它是不是用了sp.lambdify把符号表达式转成数值函数再计算。
6. 进阶技巧：用lambdify把符号推导变成可复用数值函数
符号推导和数值计算各有优势，但很多人只会在两者之间二选一。实际工作中最高效的做法是：用 SymPy 推导出公式，再用lambdify转成 NumPy 可调用的函数，兼顾推导的准确性和计算的效率。
import sympy as sp import numpy as np # 定义符号 x, y = sp.symbols('x y') # 构造一个复杂表达式 expr = sp.sin(x) * sp.exp(-y**2) + sp.cos(x * y) # 对 x 求偏导 df_dx = sp.diff(expr, x) print("偏导数表达式:", df_dx) # 用 lambdify 转成数值函数 f_num = sp.lambdify((x, y), expr, modules='numpy') df_dx_num = sp.lambdify((x, y), df_dx, modules='numpy') # 现在可以像普通 NumPy 函数一样调用 x_vals = np.linspace(0, np.pi, 5) y_vals = np.linspace(-1, 1, 5) X, Y = np.meshgrid(x_vals, y_vals) Z = f_num(X, Y) dZ_dx = df_dx_num(X, Y) print("函数值形状:", Z.shape) print("偏导数值形状:", dZ_dx.shape)这段代码的关键在sp.lambdify的第三个参数modules='numpy'，它告诉 SymPy 把表达式里的数学函数映射到 NumPy 的对应实现，这样生成的函数支持数组输入，可以直接用于批量计算。如果不加这个参数，生成的函数只支持标量输入，传数组会报错。
参数说明：lambdify的第一个参数是符号变量元组，顺序要和后续调用时的参数顺序一致。第二个参数是表达式。第三个参数除了'numpy'，还可以用'math'（标量更快）或'scipy'（支持特殊函数）。对于需要高性能的场景，还可以用sp.lambdify配合numba做 JIT 编译，但那是另一个话题了。
我自己的习惯是：任何需要反复调用的数学函数，只要涉及复杂推导，都先走一遍「SymPy 推导 → lambdify 转数值 → NumPy 批量计算」的流程。这样既避免了手推公式出错，又不会在每次调用时重复符号运算的开销。从那以后我每次写数值优化代码，都强制走一遍这个流程，省下来的调试时间远超写符号推导的那几分钟。希望帮到你。
本文还有配套的精品资源，点击获取
