企业官网建设流程全解析

简介：《程序员数学》配套源码与程序资源，专为想用 Python 学透线性代数和微积分的开发者设计，覆盖向量、矩阵、特征值、线性空间、极限、导数与积分等核心知识，适合初学者及有编程基础后重温数学的读者。整个压缩包共 104 个文件，包含 74 个 Python 脚本、17 个 Jupyter Notebook、7 张图示及少量辅助数据，按章节与书本一一对应；Notebook 可直接运行交互式示例，py 脚本便于二次修改，7z 格式整体大小约 13.55 MB，轻量易下载。目前已有 1652 人浏览学习，社区认可度较高。与常见资源相比，该版本不仅提供与《程序员数学》章节对应的完整源码，还修正了原书中的若干错误与 bug，读者可对照书本逐章练习，减少踩坑；同时可利用 matplotlib、sympy 等库直观观察向量运算和函数变化，把抽象概念转化为可运行代码，适合系统自修、教学备课或刷题巩固。

1. 为什么用Python啃《程序员数学》：给“看得懂公式、写不出代码”的人准备

如果你已经工作了两三年，回头看线性代数和微积分，大概率只剩一个模糊印象：矩阵乘法会算但不知道算什么，导数会求但不知道在机器学习里干了什么。《程序员数学》这本书的价值，是让每个公式都落在Python代码上；而这套配套源码的价值，是告诉你书里每一段代码到底怎么跑起来、跑不通时卡在哪。最难得的是，这套源码针对原书做了一批bug修正——很多老教材的示例代码在今天的Python版本下根本跑不动，不是算法错，而是API早被淘汰了。它适合两类人：一类是准备转数据分析或算法岗、需要用代码把数学概念焊死在脑子里的开发者；另一类是已经在用numpy、sympy但遇到“书上能跑、我这就报错”的翻车选手。按章节复现一遍，比对着公式发呆效率高得多。

2. 先把环境调到“能跑书里源码”的状态：依赖版本与目录对应关系

2.1 依赖选型：numpy矩阵运算、scipy数值计算、sympy符号推导、matplotlib绘图

拿到这套源码，第一件事不是打开第一章读代码，而是先确认运行环境。书里的代码在编写时用的还是Python 2和早期numpy API，纠错版虽然做了修改，但运行时仍然需要一套稳妥的依赖组合。我一般建议用虚拟环境，避免污染日常开发环境。

常见依赖组合如下：

# requirements.txt numpy>=1.21.0 scipy>=1.7.0 matplotlib>=3.4.0 sympy>=1.9.0 jupyter>=1.0.0

安装命令用pip即可：

python -m venv math_env source math_env/bin/activate # Windows下用 math_env\Scripts\activate pip install -r requirements.txt

这里刻意没有把numpy版本锁死到某个具体数字，因为老代码的主要兼容性问题集中在np.float、np.int这类别名被移除，以及np.matrix被弱化上。如果你电脑里已经装了TensorFlow或PyTorch，这些框架对numpy版本有自己的下限要求，锁死版本反而容易和现有环境冲突。用>=下限配合虚拟环境，是最省后悔药的做法。

2.2 章节目录结构：怎么判断“源码和书本对应”

这套源码是按章组织的，目录命名逻辑和书章节基本一致：

math_learning/ ├── chapter01_intro/ ├── chapter02_linear_equations/ ├── chapter03_vectors/ ├── chapter04_matrix_operations/ ├── chapter05_eigenvalues/ ├── chapter06_derivatives/ ├── chapter07_integrals/ ├── chapter08_gradient_descent/ └── common_utils/ └── plot_helper.py

判断一份源码是否和书本页码对应，不要只看文件夹名，要看文件里的注释和打印输出。纠错版一般在文件开头给出了原书页码或章节编号，例如# 第3章 3.2节 例1。跑的时候按章节顺序来，因为后面的章节会复用前面章节定义的公共函数，common_utils目录就是用来干这件事的。如果文件名带bugfix、corrected这类标记，那就是原书代码修正后的版本，优先看这些文件。

2.3 环境验证：先跑一个最小示例确认没配错

拿到源码后我不急着翻正文，先跑一个最小的线性代数示例，确认numpy和matplotlib都正常：

import numpy as np import matplotlib matplotlib.use("TkAgg") # 无显示环境下退路 import matplotlib.pyplot as plt a = np.array([3.0, 4.0]) b = np.array([1.0, -2.0]) print("dot product:", np.dot(a, b)) # 期望输出 -5.0 plt.plot([0, a[0]], [0, a[1]], label="a") plt.plot([0, b[0]], [0, b[1]], label="b") plt.axis("equal") plt.legend() plt.show()

这段代码的逻辑很简单：先做向量点积，验证numpy基础运算；再用matplotlib画向量箭头，验证绘图环境。值得留意的是第4行matplotlib.use("TkAgg")，很多源码包不会写这一行。如果你在纯服务器或无桌面环境下跑，缺了这句会直接报no display错误。遇到这类问题，先检查是不是后端选错，而不是急着改业务代码。运行后如果弹出窗口且坐标轴比例正常，说明环境已经就绪。

3. 线性代数部分：从“会算”到“算得对”，源码里藏着哪些门道

3.1 矩阵乘法：手写循环和numpy向量化之间的差距

书里讲矩阵乘法是从定义出发的，源码里一般有两种实现：一种是教材式三重循环，另一种是numpy的@运算符。两种都得跑一遍，差别能直观感受到：

import numpy as np A = np.random.randint(0, 10, size=(200, 300)) B = np.random.randint(0, 10, size=(300, 400)) def matmul_loop(A, B): m, k = A.shape k2, n = B.shape assert k == k2, "矩阵维度不匹配" C = np.zeros((m, n)) for i in range(m): for j in range(n): for p in range(k): C[i, j] += A[i, p] * B[p, j] return C # C_loop = matmul_loop(A, B) # 跑一次就够你等 C_np = A @ B print(C_np.shape) print(np.allclose(C_np, matmul_loop(A[:20, :20], B[:20, :20])))

代码逻辑不复杂，三行代码就写完了，但重点在两处：assert k == k2这一步是很多新手漏掉的，矩阵乘法要求A的列数等于B的行数；最后一行np.allclose是浮点比较的推荐做法，不要用==，否则因为底层BLAS算法顺序不同，可能得到微小的尾数差异而误判“实现错了”。这个示例还说明一个常见纠结：要不要自己实现矩阵乘法？我的建议是，为了理解原理跑一次手写版就够了，实际项目里永远用A @ B，除非你在写面试题。

3.2 解线性方程组：高斯消元法的代码细节与数值稳定性

书本对应的源码里通常会出现两版解方程组的代码：一版是手工实现的高斯消元，一版直接调np.linalg.solve。建议把两个都打开对照着读：

import numpy as np A = np.array([[2.0, 1.0, -1.0], [1.0, 3.0, 2.0], [3.0, 2.0, 1.0]]) b = np.array([8.0, 10.0, 6.0]) # 直接用numpy解 x_np = np.linalg.solve(A, b) print("numpy solution:", x_np) # 手写高斯消元的简化版，标明主元 def gauss_elimination(A, b): M = np.hstack([A.astype(float), b.reshape(-1, 1)]) n = M.shape[0] for col in range(n): pivot = M[col:, col].argmax() + col # 部分主元 M[[col, pivot]] = M[[pivot, col]] for row in range(col + 1, n): factor = M[row, col] / M[col, col] M[row, col:] -= factor * M[col, col:] x = np.zeros(n) for i in range(n - 1, -1, -1): x[i] = (M[i, -1] - M[i, i+1:n] @ x[i+1:]) / M[i, i] return x x_manual = gauss_elimination(A, b) print("manual solution:", x_manual)

注意手写版里特意做了部分主元选择：argmax()找当前列绝对值最大的行并与当前行交换。这个动作的数学意义是防止出现极小的主元导致数值爆炸，实际工程里是必须的。教材里的简化源码如果没做这一步，遇到某些病态矩阵就会算出离谱结果。除了理解算法，你手里这份修正版源码的价值正在这里——原书代码可能在消元前少了一步主元判断，导致特定矩阵上翻车，纠错版会把这个补齐。跑完对比x_np和x_manual，如果数值一致，说明消元逻辑没写错。

3.3 特征值与SVD：最容易“跑通但看不懂”的模块

特征值这块是线性代数里最玄学的部分。源码里通常会出现np.linalg.eig和np.linalg.eigh两个函数。它们的区别，搞懂之后能少踩很多坑：

import numpy as np # 对称矩阵：工程中出现频率最高 A_sym = np.array([[2.0, 1.0], [1.0, 3.0]]) # 通用矩阵 A_gen = np.array([[1.0, 2.0], [3.0, 4.0]]) eigvals_sym, eigvecs_sym = np.linalg.eigh(A_sym) eigvals_gen, eigvecs_gen = np.linalg.eig(A_gen) print("eigh eigenvalues:", eigvals_sym) print("eig eigenvalues:", eigvals_gen) # 验证 A v = lambda v v = eigvecs_sym[:, 0] lam = eigvals_sym[0] print("residual:", np.linalg.norm(A_sym @ v - lam * v))

这里的选型逻辑是：eigh专门处理对称（厄米）矩阵，返回的特征值严格按从小到大排序，数值上比eig更稳定；eig用于普通方阵，返回顺序没有固定约定，复数矩阵时还可能返回虚部。很多人在书上看到示例矩阵恰好是对称的，就误以为eig的结果一定按大小排好，下次换个非对称矩阵就出现“特征值顺序和书上不一样”的情况，这不是bug，是特性。验证残差A v - λ v的范数，是判断特征值算没算对最直接的方法。

SVD部分也一样，源码里会用np.linalg.svd，返回的U、S、Vh三个矩阵，注意这里的Vh是V的共轭转置，不是V本身。书里如果写的是“V”，对照代码时千万别搞混，否则重构回来矩阵对不上。

3.4 修正原书bug的核心修改点：np.matrix、np.float与print语法

这套源码标称“做了错误的修改bug”，我翻下来最常出现的是三类修改：

第一类，np.matrix全部换成np.ndarray。早期numpy里的np.matrix有A.I这种便捷写法，但官方后来不推荐使用。原书有些例子会直接用matrix类，修正版把它们改成array，同时把A.I改成np.linalg.inv(A)，把A.H改成A.conj().T。如果你手里的代码版本还带着np.matrix，建议按这个方向自己改，因为numpy新版本对matrix的支持越来越边缘化。

第二类，np.float、np.int改成float、int。这是numpy 1.24之后的大变化，老代码里凡是用np.float做类型转换的地方都会报AttributeError: module 'numpy' has no attribute 'float'。这不是算法问题，纯属时代变了。

第三类，Python 2的print "hello"改成print("hello")，以及xrange改成range。纠错版已经处理完这些，但如果你在原书附带的旧版代码里看到，心里要有数。

4. 微积分部分：导数、积分与梯度下降的完整可跑代码

4.1 用sympy把导数“画出来”：从符号推导到数值可视化

微积分章节的源码结构很清晰：每讲一个概念就有一个对应的绘图脚本。导数这块，符号计算用sympy，数值计算用numpy，两者配合：

import numpy as np import sympy as sp import matplotlib.pyplot as plt x = sp.Symbol("x") f_expr = x**3 - 2*x**2 + 1 f_prime_expr = sp.diff(f_expr, x) print("f'(x) =", f_prime_expr) # 转成数值函数 f = sp.lambdify(x, f_expr, "numpy") f_prime = sp.lambdify(x, f_prime_expr, "numpy") x_vals = np.linspace(-2, 3, 200) y_vals = f(x_vals) slope_vals = f_prime(x_vals) x0 = 1.2 tangent = f_prime(x0) * (x_vals - x0) + f(x0) plt.figure(figsize=(8, 5)) plt.plot(x_vals, y_vals, label="f(x)") plt.plot(x_vals, tangent, "--", label=f"tangent at x={x0}") plt.scatter([x0], [f(x0)], color="red") plt.legend() plt.grid(True) plt.show()

代码里最关键的一行是sp.lambdify(x, f_expr, "numpy")。lambdify把sympy符号表达式编译成Python可调用的函数，传"numpy"参数让它支持numpy数组的逐元素运算。不传这个参数，你只能在单个数值上调用，没法直接喂给np.linspace生成的数组。这是个高频使用点，也是最容易翻车的地方。打印出来的f'(x)结果，如果长这样3*x**2 - 4*x，就说明符号推导正常。

4.2 数值积分：三种方法对照，别拿矩形法算工程问题

积分章节的源码一般会给三种实现：矩形法、梯形法、Simpson法，并和scipy.integrate.quad做对照：

import numpy as np from scipy.integrate import quad def rectangle_rule(f, a, b, n): dx = (b - a) / n x = a + (np.arange(n) + 0.5) * dx return f(x).sum() * dx def trapezoid_rule(f, a, b, n): x = np.linspace(a, b, n + 1) y = f(x) return np.trapezoid(y, x) # 新版numpy直接用trapezoid def simpson_rule(f, a, b, n): if n % 2 == 1: n += 1 dx = (b - a) / n x = np.linspace(a, b, n + 1) y = f(x) return dx / 3 * (y[0] + y[-1] + 4 * y[1:-1:2].sum() + 2 * y[2:-2:2].sum()) f = lambda x: np.sin(x) + 0.5 * x**2 a, b = 0.0, 2.0 truth, _ = quad(f, a, b) print("quad truth :", truth) print("rectangle n=100:", rectangle_rule(f, a, b, 100)) print("trapezoid n=100:", trapezoid_rule(f, a, b, 100)) print("simpson n=100 :", simpson_rule(f, a, b, 100))

这份代码的实践意义在于让你直观看到收敛速度：矩形法在中低精度要求下需要非常多分片，Simpson法在同样分片数下精度高一大截。注意一个细节：np.trapezoid是numpy 2.0引入的新名字，老版本叫np.trapz。如果你用的是旧环境，trapezoid会报AttributeError，改成np.trapz(y, x)即可。这也是这套源码能踩出来的典型版本坑之一。积分例子里如果是原书旧代码，用的多半是np.trapz，对照时要注意。

4.3 梯度下降：让微积分从课本走向机器学习的第一课

梯度下降章节是整本书和机器学习衔接最紧的地方。源码里会出现一个手工实现的最小例子，重点看学习率和迭代次数怎么设：

import numpy as np def gradient_descent(grad_func, start_x, lr=0.1, epochs=100): x = start_x history = [] for i in range(epochs): g = grad_func(x) x = x - lr * g history.append(x) if abs(g) < 1e-6: print(f"converged at epoch {i}") break return x, np.array(history) # 目标函数 f(x) = (x - 3)^2，导数为 2(x - 3) grad = lambda x: 2 * (x - 3) x_star, hist = gradient_descent(grad, start_x=0.0, lr=0.2, epochs=50) print("minimum at:", x_star) print("iterations used:", len(hist))

参数说明：lr=0.2在这个二次函数上是安全的，收敛到3.0附近；如果把学习率调到0.5以上，你会看到震荡甚至发散。梯度下降最“反直觉”的点就在于：不是迭代次数越多越好，而是学习率、初始位置、停止阈值三者配合。源码里如果提供了损失曲线绘制函数，跑一次不同学习率的对比，这个模块就算真正吃透了。微积分在这里的作用很直白——导数告诉你方向，学习率决定步子多大，剩下的交给循环。

4.4 微积分模块的源码修正点：lambdify冲突与scipy版本变化

这部分修正版源码相对原书，主要动了几个地方。一是所有lambdify调用都显式传入"numpy"模块，避免因为符号名称和numpy内置函数重名导致运行时错误；二是把scipy.integrate.quad的返回值从裸元组里解包取第一个值，旧代码经常忽略误差项，新版源码一般会写明第二项是绝对误差估计；三是把sympy的plot接口改成matplotlib绘制，sympy自带的绘图函数效果一般，且不同版本间API变化大，改成matplotlib能少很多兼容问题。

5. 避坑与排查：跑书里源码最常见的五个问题及处理方案

5.1 ImportError：np.float没了、trapz改名了、printsyntax不对

现象：导入脚本时直接报AttributeError: module 'numpy' has no attribute 'float'，或者ModuleNotFoundError: No module named 'scipy.misc'。

原因：原书写作年代的numpy版本很老，代码用了np.float、np.int这类已经被移除的别名；部分版本还引用了scipy.misc里的工具函数，而新版scipy把它们挪走或删除了。

解决：按numpy官方迁移说明，np.float直接改成float，np.int改成int。涉及scipy.misc的，先看是不是imresize、factorial这类函数——factorial挪到了scipy.special，imresize需要替代方案。改完后重新跑一次，如果还有别的AttributeError，按同样思路排查，无非就是“这个函数在新版本里被改名/挪位置/删掉了”三选一。

5.2 中文注释或字符串编码问题：控制台输出乱码

现象：脚本能跑，但print出来的中文全是乱码，或者文件打开直接报SyntaxError: Non-UTF-8 code starting with ...。

原因：旧源码文件保存为GBK或GB2312编码，而Python 3默认按UTF-8读取源码文件。

解决：在文件第一行加# -*- coding: utf-8 -*-不能解决读取问题——这只是声明文件编码，真正要改的是把文件转成UTF-8编码。用任意编辑器打开，另存为UTF-8格式，或者在Linux下用iconv -f GBK -t UTF-8 old.py > new.py批量转码。这套源码如果已经处理过bug，这类问题应该很少，但如果你从原书配套网站拿的旧版本没处理过，这是最普遍的第一道坎。

5.3 特征值结果“对不上书”：虚部和顺序干扰判断

现象：书上例子的特征值是[3, 1]，你跑出来array([1., 3.])，或者结果里多了个+0.j虚部符号。

原因：特征值的返回顺序不做保证，这是numpy没承诺过的；非对称矩阵在实数域下用eig求解，虚部就是0也会以复数形式返回。

解决：不要用==比较特征值列表，改成np.allclose(np.sort(real_part), expected)。取实部用.real，判断虚部是否可忽略用np.issubdtype(eigvals.dtype, np.complexfloating)或np.abs(eigvals.imag).max() < 1e-8。把这些判断写进代码里，比肉眼对数字靠谱。

5.4 matplotlib不显示图形：窗口闪现就消失或直接报错

现象：plt.plot之后没有窗口弹出，或者窗口弹出后程序结束、窗口立刻关闭；服务器上直接报no display name。

原因：非交互环境下没有图形后端；代码里缺plt.show()；或者用了plt.ion()交互模式但没保留引用。

解决：本地跑，在脚本末尾补一句plt.show()；服务器上无界面，改用matplotlib.use("Agg")并把图保存成PNG文件，plt.savefig("output.png")。判断问题的顺序是：先确认matplotlib.get_backend()返回什么，再决定是切后端还是加show。

5.5 相对路径与公共模块导入失败：章节脚本互相找不到工具函数

现象：单独跑chapter06里的某个脚本，报ModuleNotFoundError: No module named 'common_utils'。

原因：脚本内部用了from common_utils import plot_helper，但当前工作目录在章节文件夹里，Python的模块搜索路径不包含项目根目录。

解决：在脚本顶部加两行：

import sys, os sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))

这段代码把当前文件上一级目录加入模块搜索路径。更稳妥的做法是给common_utils建一个__init__.py，然后统一从项目根目录运行脚本。很多老源码包没有考虑“单独执行某个文件”的场景，只在IDE全量运行时没问题，一上命令行就翻车，这个坑值得记在笔记本上。

6. 进阶：把教材结论改写成pytest测试，让每个公式都变成可检试验证

啃完一遍书和源码之后，最值钱的一步是把书里的定理、习题改写成自动化测试。这样以后再翻这本书时，不用重新跑一遍所有脚本，直接执行pytest就能确认环境里的代码行为和教材结论一致。

import numpy as np import pytest from numpy.linalg import eig, svd, solve def test_eigenvalue_equation(): A = np.array([[2.0, 1.0], [1.0, 3.0]]) vals, vecs = eig(A) for i in range(len(vals)): v = vecs[:, i] lhs = A @ v rhs = vals[i] * v assert np.allclose(lhs, rhs), f"特征向量不满足 Av = λv, index {i}" def test_svd_reconstruction(): A = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]) U, S, Vh = svd(A) Sigma = np.zeros_like(A, dtype=float) Sigma[:len(S), :len(S)] = np.diag(S) A_recon = U @ Sigma @ Vh assert np.allclose(A, A_recon), "SVD重构失败" def test_solve_residual(): A = np.array([[4.0, 2.0], [1.0, 3.0]]) b = np.array([10.0, 8.0]) x = solve(A, b) assert np.allclose(A @ x, b), "线性方程组求解残差过大"

这套测试的价值在于把书上的数学断言变成机器能检查的事实。跑法也简单：

pytest test_math_book.py -v

把书里每个章的重要公式都改造成类似的测试用例，大致从三个角度入手：验证“分解能重构回去”（SVD、特征分解），验证“方程解代回原式成立”（线性方程组、QR分解），验证“导数定义和符号推导结果一致”（数值微分 vs sympy结果）。这些都是通用模式，不需要给每道习题写测试，挑核心定理就行。我做这件事的教训是：一开始只改了书里的bug就以为自己懂了，几个月后回头发现很多结论都忘了为什么成立；后来强制自己每题写完都补一条测试断言，不用花太多时间，但每次环境重装后跑一遍测试，比重新翻书省事太多。希望这个方法也能帮到你。

本文还有配套的精品资源，点击获取