简介：这是一份面向Python初学者、数据分析入门者及需要系统掌握科学计算基础的学习者的NumPy指南配套代码包，围绕ndarray核心数据结构展开，覆盖创建、操作、变换等关键主题，适用于教学、自学和日常查阅。压缩包共147个文件，其中123个为可直接运行的Python脚本，还有readme说明文档、csv示例数据、mat数据文件及少量辅助文件，整体约65KB，轻量便携，便于随用随取。目前已有389人学习下载，内容适合作为实验课配套材料，也可用于复习NumPy基础。代码示例循序渐进，涵盖数组创建与属性查看、数据类型转换、索引切片、广播机制、常用统计方法、排序及reshape/transpose等核心操作，每个示例均配合清晰输出结果，可帮助读者直观理解NumPy的高效数组运算方式，为后续数据分析、机器学习与图像处理实践夯实基础。
1. 为什么说 NumPy 的代码能跑通和能改对是两回事
照着别人的 NumPy 示例敲一遍能运行，换成自己的数据立刻翻车，这种事我在带新人时见过太多次。很多人以为 NumPy 只是数组容器，装上就能用，实际上它的视图、副本、广播、dtype 这些机制，任何一个理解偏差都会让结果静悄悄出错，而且不报任何异常。这份 python-NumPy 学习指南代码，是一套按知识点拆分的可运行脚本，覆盖数组创建、索引切片、广播机制、线性代数与随机数模块，每一段代码都能直接跑、能改参数看反馈。适合刚学完 Python 语法、准备切入数据处理和科学计算的从业者，也适合需要快速校准 NumPy 边界行为的熟手。
2. 从列表到 ndarray：数组创建、 dtype 与内存布局的一次性理顺
2.1 五种高频创建方式，按实际使用频率排过序
打开这份代码包的第一印象是目录很规整，每个脚本开头都写清了目标、参数注释和预期输出。我一般会先跑01_数组创建.py，它的核心就是把五种最常用的构造方式放在一起对比，而不是逐个孤立地给例子。
import numpy as np a = np.array([1, 2, 3]) # 从已有列表创建，dtype 自动推断 b = np.arange(0, 4, 0.5) # 等间距序列，结束值不包含 c = np.linspace(0, 1, 5) # 等间隔序列，闭区间，默认包含 1.0 d = np.zeros((2, 3), dtype=np.float64) e = np.ones((3, 2)) f = np.full((2, 2), 7) g = np.eye(3)这段代码把np.array、np.arange、np.linspace、np.zeros/ones/full、np.eye一次铺开，适合建立手感。
np.array适合小规模数据和已有 Python 列表的转换，dtype 由数据自动推断，整数列表默认是int64，写入浮点数就会自动转float64。np.arange的三个参数是 start、stop、step，stop 不包含在结果里，写0.5步长时容易得到小额浮点误差，这是很多后续比较失败的起点。np.linspace的参数是 start、stop、num，它包含 stop，num默认为 50。想要首尾都落位就用它，想要 open 区间就把endpoint=False加上。np.full((2,2), 7)填的是一个标量，实际工作里常用来初始化权重矩阵或占位数组。np.eye(3)生成单位阵，代码包之后做线性代数示例时会反复用到。
我第一次用arange(0, 1, 0.1)然后拿去和linspace(0, 1, 10)做array_equal，发现结果是 False，就是因为浮点累积误差，所以后来给打印对比都换成np.allclose。
2.2 dtype、astype 与 reshape：哪些操作生成副本，哪些只换了个读法
创建完数组后，代码包立刻进入 dtype 和内存属性的训练，这是新手最容易忽略的部分。
x = np.array([[1, 2], [3, 4]], dtype=np.int32) y = x.astype(np.float32) # astype 总是生成副本 z = x.reshape((4,)) # reshape 在内存连续时可返回视图 print(x.dtype, x.shape, x.ndim, x.size) print(x.itemsize, x.nbytes, x.strides) print(np.shares_memory(x, y), np.shares_memory(x, z))这里的关键是 d的类型转换与形状变换语义：
astype(np.float32)一定会复制数据，改y不会影响x。如果不想要这个副本，直接写x = x.astype(...)在逻辑上等价，但中间还是会多一次内存分配。reshape((4,))在内存连续时返回视图，np.shares_memory会告诉你能不能安全地只读使用。strides是沿着每个维度前进一个元素时跳过的字节数，它解释了为什么转置后的数组底层数据没有动，只是读取方式变了。
我再补一个实际场景：很多人在读数据后顺手df.values.reshape(-1, 1)去做计算，却不知道原始 DataFrame 的底层数组是被共享的。判断“到底会不会动到原数据”，最靠谱的办法就是np.shares_memory，比猜可靠得多。
2.3 拿到代码包后先做三个属性检查，避免后面全程带病运行
你不需要把每个示例的结果背下来，但拿到任何 NumPy 代码包后，先让每个数组把身份信息吐一遍是值得养成的习惯。代码包在每个脚本末尾常放一段检查代码，我一般会直接跑：
def inspect_array(arr, name): print(f"{name}: shape={arr.shape}, dtype={arr.dtype}, " f"ndim={arr.ndim}, nbytes={arr.nbytes}") return arr inspect_array(b, "arange_result") inspect_array(c, "linspace_result")三个检查项分别有不同的用途：
shape决定广播和矩阵运算的走向，shape 对不上是绝大多数运行时错误的来源。dtype决定后续计算会不会发生隐式类型提升，整数数组做除法得到浮点数组、两个小整数相加溢出，都是 dtype 没看住的表现。nbytes用来估算内存占用，处理几千乘几千的矩阵时心里有数，不会无缘无故把机器跑死。
这套检查我之前只在调试时用，后来发现它真正值钱的地方在于：把所有脚本一口气运行完，先看这些基本信息再谈结果，能把很多“明明照敲却结果不对”的问题挡在门外。
3. 索引、切片与视图/副本：改一处连带另一处的隐藏联动
3.1 普通切片是视图，花式索引是副本，别等数据被改坏才回头查
NumPy 里最贵的认知点就是切片（slice）与索引（index）返回的东西根本不是同一类。普通切片返回的是原数组的视图，花式索引和布尔索引返回的是副本。代码包里专门有一个脚本从打印地址开始验证这件事。
arr = np.arange(12).reshape(3, 4) view_slice = arr[1:3, 1:3] # 普通切片：视图 fancy_idx = arr[[0, 2], [1, 3]] # 花式索引：副本 view_slice[0, 0] = 99 print(arr) # 原数组的第 1 行第 1 列也变成 99 print(np.shares_memory(arr, view_slice)) print(np.shares_memory(arr, fancy_idx))这段输出最能说明问题：
- 第一步把视图里的元素改成 99，原数组同一个位置也变成 99，说明底层是同一块内存。
np.shares_memory一个返回True、一个返回False，是代码包刻意留下的判断证据。- 实际项目里最典型的翻车现场是：从大数组里抽出一个子块，原地把异常值改掉，期望原数组保持不变，结果原数组被连带污染，后面所有统计全部失真。
解决办法不神秘：如果子块后续会被修改，并且不想动原数组，显示调用.copy()；如果确实想改原数组，普通切片反而是合理选择，别多此一举。
3.2 布尔索引做条件筛选，配合 np.where 完成批量替换
数据清理场景里布尔索引是最常用的筛选手段，代码包用一个包含 NaN 的一维数组演示了完整流程。
data = np.array([1, 5, np.nan, 8, -2, 3, 10]) mask = (data >= 0) & (np.abs(data) < 10) clean = data[mask] print(clean) print(np.where(np.isnan(data), 0, data))这里有几个容易踩的细节：
mask必须加括号，(data >= 0) & (np.abs(data) < 10)里每一个比较都先包成布尔数组再做与运算，漏括号会触发运算符优先级陷阱。- 布尔索引返回的是副本，
clean里改动不会影响data。 np.where(condition, x, y)是三目运算符的向量化版本，np.where(np.isnan(data), 0, data)把所有 NaN 替换成 0，保留其余原始值。
实际做数据清洗时，我通常会把布尔索引和np.where组合使用：先用布尔索引定位问题样本，再用np.where做条件替换。比 pandas 的链式操作更直白，也更容易看到中间数据长什么样。
3.3 组合索引时副本与视图的判断方法
当你把普通切片、花式索引、布尔索引混在一个表达式里时，代码包给出的建议是先拆开再做，而不是追求一行写完。
base = np.arange(20).reshape(4, 5) row_mask = np.array([True, False, True, False]) part1 = base[row_mask] # 布尔索引，副本 part2 = part1[:, 1:4] # 普通切片，仍然是 part1 的视图 part3 = part2[[0], :] # 花式索引，又是一个新副本混合索引的判断规则是：碰过布尔索引或花式索引的步骤就已经产生副本，后面再切片只影响这个副本。代码包建议不要一次性写太复杂，把中间结果用变量接住，每隔一步打印一次np.shares_memory，比事后追查高效得多。
判断方法可以总结成一个习惯：遇到“视图还是副本”的疑问，直接运行下面的最小片段：
a = np.zeros((3, 3)) sub = a[1:, 1:] print(np.shares_memory(a, sub)) # True 表示视图，False 表示副本用shares_memory代替肉眼检查，是我在很多次改坏源数据之后总结出来的强制动作。
4. 广播机制与通用函数：向量化运算从会用到不踩雷
4.1 广播的三条规则：先对齐尾部维度，再逐维度扩展
广播可能是 NumPy 里最玄学的部分，因为它既管用，又总是悄悄改变结果的形状。代码包用一个形状对比图把三条规则讲得很清楚，我当时照着跑了一遍才真正记住。
a = np.ones((3, 1)) b = np.ones((1, 4)) c = a + b print(c.shape) # (3, 4)，二维外积结构 x = np.array([1, 2, 3]) # shape (3,) y = np.array([[10], [20]]) # shape (2, 1) z = x + y print(z.shape) # (2, 3)广播的三条规则分别是：
- 规则一：从尾部维度开始对齐，两个 shape 的尾部必须满足相等或其中一个是 1。
- 规则二：缺失的维度按 1 补齐，比如
(3,)与(2,1)配对时，x先变成(1,3)再广播。 - 规则三：维度为 1 的轴会被拉伸到和另一个数组一致，最终结果是两个 shape 各位置取最大值。
前面第二段代码的输出，x + y的结果是(2,3)而非(3,)，这让很多新手意外。实际项目里这种意外经常出现在“给每一行加上同一个向量”的时候，期望得到按行加的(2,3)，结果广播规则给了你这个，却没有提示。代码包留给我的习惯是：广播之前打印一遍两边的 shape，然后再看结果形状，三行检查能省下一整晚查错时间。
4.2 axis 参数与聚合函数：沿哪个轴缩减，keepdims 要不要加
聚合函数的文档看十遍不如在三维数组上跑一遍。代码包里的02_聚合统计.py用一个 3 行 4 列矩阵演示了 axis 的语义。
m = np.arange(12).reshape(3, 4) print(m.sum(axis=0)) # 沿第 0 维（行方向）求和处理，结果是每列的累加 print(m.max(axis=1, keepdims=True)) # 沿第 1 维（列方向）取最大，保留维度 col_sums = m.sum(axis=0) print(col_sums.shape) # (4,) row_max = m.max(axis=1, keepdims=True) print(row_max.shape) # (3, 1)两个参数值得单独说明：
axis=0表示沿着第 0 维移动，把第 0 维消掉。m.sum(axis=0)的结果是一个长度为 4 的数组，因为在列方向累加。keepdims=True保留被缩减的维度，(3,)变成(3,1)，这样后续与m做广播时形状更友好，不会出现(3,)与(3,4)的规则冲突。
代码包里的练习还会演示np.mean、np.std、np.cumsum的 axis 用法，规律是一致的。我自己的习惯是拿一个二维小数组先试 axis=0 和 axis=1 的结果，再套到真实数据上，可以显著降低“结果形状对不上”的报错频次。
4.3 ufunc 的四种调用形态：直接计算、reduce、accumulate、outer
ufunc 是 NumPy 通用函数的简称，add、multiply、power都属于 ufunc。代码包这节给出的四种调用形态是让代码从“能算”走向“会算”的关键。
arr = np.array([1, 2, 3, 4]) print(np.add.reduce(arr)) # 把数组元素逐个相加，等价于 sum print(np.add.accumulate(arr)) # 逐步累加，返回每一步的结果 [1, 3, 6, 10] print(np.multiply.outer(arr, arr)) # 两两相乘，得到外积矩阵 np.add.at(arr, np.array([0, 0, 2]), 10) # 在指定位置反复累加 print(arr)四种形态对应四种实战场景：
reduce适合把任意多维参与，沿着一个轴做累积归约，比手写循环快得多。accumulate常用于记录过程量，比如每日累计销售额。outer生成外积，在做距离矩阵、核矩阵时很方便。at支持在指定索引位置重复累加，比循环里做arr[idx] += val语义更可靠，不会有索引重复时只累加一次的坑。
代码包03_通用函数.py的最后还给了一个小练习：把np.sin(x) * x这种逐元素表达式放到一万个样本上，比较 for 循环和 ufunc 的耗时。实际跑下来差距通常是几十倍起步，这也是我后来坚持让团队新成员用 ufunc 替代逐元素 Python 循环的原因。
5. 避坑与常见问题排查：三个 NumPy 静默出错的高发场景
5.1 视图污染源数据：切片改值，原数组跟着变
现象：从大数组里切出一块子数组，把子数组里的异常值替换掉，准备拿原数组继续计算，结果发现原数组也被改了。
原因：普通切片返回的是视图，底层内存共享，子数组原地赋值等于直接修改原数组。
解决：明确语义，不想改动原数组就调用.copy()，想改原数组就用视图。不要靠猜。判断代码可以这样写：
sub = arr[1:3, 1:3].copy() sub[0, 0] = -1 print(np.shares_memory(arr, sub)) # False，确认安全这个坑我在做模拟项目 Y 的数据清洗时栽过一次，从那以后，凡是切片后还要赋值的场景，我都会强制写一行np.shares_memory检查，再决定是否保留副本。
5.2 广播误判：代码能跑，结果却是外积而不是逐行加
现象：一个(4,1)的列向量和一个(4,)的一维数组相加，本意是按行加，结果得到一个(4,4)的矩阵，代码没有报错，但数据全错。
原因：(4,)会被广播成(1,4)，再与(4,1)配对，最终形状变成(4,4)，形成外积结构。
解决：在相加前先查看两边的 shape，如果确实希望按行广播，给一维数组补一个维度：
a = np.arange(4).reshape(4, 1) b = np.arange(4) print((a + b).shape) # 意外得到 (4, 4) b2 = b.reshape(4, 1) # 或者 b[:, np.newaxis] print((a + b2).shape) # 得到 (4, 1)更稳妥的办法是写一个形状断言，把意图固化成代码：
assert a.shape == (4, 1), f"left shape should be (4,1), got {a.shape}"广播的错误大多不报异常，唯一的防御是让 shape 显眼。
5.3 随机数复现失效：np.random.seed 管不到 default_rng
现象：顺着代码包跑随机数示例时，固定了np.random.seed(42)，再调用np.random.default_rng()生成的数据每次都不一样，复现失败。
原因：np.random.seed设置的是旧式全局随机数状态，而default_rng使用的是新的Generator体系，两者不共享状态。
解决：统一使用default_rng，直接在构造时传种子；或者新旧两套都固定但不要混用。推荐写法是：
rng = np.random.default_rng(42) x = rng.normal(size=(2, 3)) y = rng.normal(size=(2, 3)) print(x) print(y)代码包04_随机数.py里给出的建议是用同一个rng实例完成所有随机采样。这样既保证顺序，又让复现稳定。如果项目里既有遗留代码用np.random.seed、又有新代码用default_rng，我一般会优先迁到default_rng，否则排查复现问题容易变成两套体系互相干扰。
6. 进阶：向量化链路与代码包自查验证
拿到任何 NumPy 学习代码，我只信一种验证方式：把全部脚本从头到尾跑一遍，再主动改参数，看结果是否随参数按预期变化。只有“能复现 + 能变对”的代码才算真正消化了。
跑性能示例时我会用time.perf_counter对比 Python 循环和向量化写法：
import time import numpy as np x = np.linspace(0, 10, 1_000_000) t0 = time.perf_counter() s = np.sum(np.sin(x) * x) t1 = time.perf_counter() print(f"vectorized: {t1 - t0:.6f} s, result={s:.4f}")对比项至少包含一个np.allclose数值断言，确保加速不是以误差为代价：
slow = sum(np.sin(x[i]) * x[i] for i in range(len(x))) fast = np.sum(np.sin(x) * x) print(np.allclose(slow, fast)) # True代码里还有几个值得沿用的验证技巧：先确认环境版本，运行脚本前打印np.__version__；跑完每个示例后用np.testing.assert_allclose对齐预期结果；涉及随机数的脚本固定种子并保存中间数组，方便对比两次运行是否一致。这些动作组合下来，能把“代码能跑”和“结果可信”之间的差距填平。
我自己现在拿到任何 NumPy 代码包，都会先走一遍全量运行、改参数、查形状、看版本这套流程，确认没有视图污染和广播误判后再进入业务逻辑。希望帮到你。
本文还有配套的精品资源，点击获取
