阅读范围、用时与原有实验记录
实验记录怎么读
本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。
⏱ 80 分钟 | ⭐ 方括号里放什么,决定你拿到的是原数组的一扇窗,还是一份复印件 —— 而这件事有一条唯一的判据
01 / 完整解释
取出相同的数,不等于以相同方式返回。
🎯 一句话
先看索引语法:本章普通数值 ndarray 的基础切片返回视图;整数数组索引和布尔高级索引读取返回副本,即使下标恰好等距。 shape、strides 与起点解释基础切片怎样共享数据,不能反过来证明某种索引一定返回视图;如果每根轴都只给一个整数,就得到标量。
上一章用形状(shape)、各轴步长(strides)和起点解释一块数据怎样被读取。本章用同一张二维数组练习四种选法,先预测返回什么,再判断修改会写到哪里。
- 视图(view)沿用原数组的数据,改动重叠的元素会反映到原数组。
- 副本(copy)有自己的数据。即使整数下标等距,例如
a[[0,1,2]],高级索引读取仍返回副本。
🧩 一、四种形态,一次看全
本章的行号和列号都从 0 开始。先看同一张表的四种读法。
| 形态 | 例子 | 读取结果 |
|---|---|---|
| ① 基础切片 | a[1:3, ::2] | 视图,和原表共享数据 |
| ② 整数索引 | a[2, 1] | 标量,取第 2 行第 1 列的值 9 |
| ③ 整数数组索引 | a[[0, 2]] | 副本,按名单取两行 |
| ④ 布尔索引 | a[a > 5] | 副本,把命中的格子收集为一维数组 |
索引(indexing)是通过方括号指定要取的位置。给每根轴一个整数时,只留下一个值,这个值叫标量(scalar)。例如,查单个门店在某个小时的记录,可以直接取一格。只给行号则还会保留该行的所有列。
- 整数数组索引也叫花式索引(fancy indexing),按给定的整数名单取值。
- 布尔掩码(Boolean mask)用
True和False标记保留与跳过的位置。
这两类取值都属于高级索引(advanced indexing)。
先运行四种写法。这里显式指定 np.int64,每个整数占 8 字节。后面计算步长时也使用这个大小。
import numpy as np
a = np.arange(12, dtype=np.int64).reshape(3, 4)
s = a[1:3, ::2] # ① 基础切片
i = a[2, 1] # ② 整数索引
f = a[[0, 2]] # ③ 花式索引(整数数组)
m = a[a > 5] # ④ 布尔掩码
for name, r in [("① 基础切片", s), ("③ 花式索引", f), ("④ 布尔掩码", m)]:
print(f"{name} shape={str(r.shape):8s} 共享内存={np.shares_memory(a, r)}")
print(f"② 整数索引 {i} {type(i).__name__} ndim={np.ndim(i)}")
实跑输出:
操作步骤
- 基础切片 shape=(2, 2) 共享内存=True
- 花式索引 shape=(2, 4) 共享内存=False
- 布尔掩码 shape=(6,) 共享内存=False
- 整数索引 9 int64 ndim=0
np.shares_memory(a, r) 检查两个数组是否有重叠的数据。这里的结果和表格一致。.base is a 可能跳过中间视图,不能代替重叠检查。见第 05 章第三节。
空切片 a[:0] 仍由基础切片得到,但它没有元素可与原数组重叠,因此 np.shares_memory(a, a[:0]) 为 False。
📐 二、① 基础切片:它天生就是一份说明书
基础切片(basic slicing)用 start:stop:step 沿某根轴挑位置。终点 stop 不取。省略起点和终点时,NumPy 按步长方向从一端读到另一端。省略步长则每次走一格。
1:3从行 1 开始,取行 1、2。::2从列 0 开始,每次跨两列,取列 0、2。
原表每格 8 字节,沿行轴走一格跨过 4 个元素。对照输出,看切片怎样改变起点和步长。
import numpy as np
a = np.arange(12, dtype=np.int64).reshape(3, 4)
s = a[1:3, ::2]
print("a", a.shape, a.strides)
print("s", s.shape, s.strides)
print(s)
print("共享内存:", np.shares_memory(a, s))
print("s 的第一个元素是 a 的第几个:", s[0, 0])
实跑输出:
要点
a (3, 4) (32, 8)
s (2, 2) (32, 16)
[[ 4 6]
[ 8 10]]
共享内存: True
s 的第一个元素是 a 的第几个: 4
一行一行对照:
| 说明书那一栏 | 怎么来的 |
|---|---|
| 起点 挪到第 4 个元素 | 行切片从 1 开始 → 1 × 32 = 32 字节 |
shape (2, 2) |
行取 2 个(1、2),列步长 2 取 2 个(0、2) |
strides (32, 16) |
行步长没变还是 32;列步长 8 × 2 = 16(隔一个取) |
⭐ 切片的每一维都是「等差数列」 —— 起点、公差、个数。 而 strides 能表达的恰好就是等差数列。两边严丝合缝,所以一个字节都不用搬。
负步长会沿轴反向走。... 是省略号(ellipsis),补足未写的全切片。对下面的二维表,a[..., 2] 等于 a[:, 2]。
import numpy as np
a = np.arange(100, dtype=np.int64).reshape(10, 10)
examples = [
("a[5:100:7, ::-1]", a[5:100:7, ::-1]),
("a[::-1]", a[::-1]),
("a[2]", a[2]),
("a[:, 3]", a[:, 3]),
("a[..., 2]", a[..., 2]),
]
for name, result in examples:
print(f"{name:18s} shape={str(result.shape):10s} "
f"strides={str(result.strides):11s} 视图={np.shares_memory(a, result)}")
实跑输出:
对照
a[5:100:7, ::-1] shape=(1, 10) strides=(560, -8) 视图=True
a[::-1] shape=(10, 10) strides=(-80, 8) 视图=True
a[2] shape=(10,) strides=(8,) 视图=True
a[:, 3] shape=(10,) strides=(80,) 视图=True
a[..., 2] shape=(10,) strides=(80,) 视图=True
⚠️ 注意 a[2] 和 a[:, 3] 也在这张表里。 形态 ② 说的是「每根轴都给整数」才得到标量;
只给一部分轴整数,剩下的轴还在,那还是基础索引 —— 依然是视图。
a[:, 3] 的 strides 是 (80,):沿这一列往下走一格要跳 80 字节,它选中的元素在内存里根本不挨着,
但因为间隔是等差的,一份说明书就够了。
🎭 三、③ 花式索引:它写不出这份说明书
如果要按名单取第 2、0、2 行,固定步长的切片表达不了这个走法。写 a[[2,0,2]] 就能逐项指定行号,也能重复取同一行。
import numpy as np
a = np.arange(12, dtype=np.int64).reshape(3, 4)
f = a[[2, 0, 2]]
print(f)
print("shape:", f.shape)
print("共享内存:", np.shares_memory(a, f))
for r in (2, 0, 2):
print(f"第 {r} 行 -> 偏移 {r * a.strides[0]} 字节")
实跑输出:
关键信息
三行的起始偏移是 64、0、64 字节。相邻两次移动分别是 −64 和 +64 字节,无法用同一个行步长表示。
这解释了本例为何无法用固定步长读取。返回类型要按语法判断,即使把名单换成等距的 [0,1,2],整数数组索引读取也会生成副本。接着试试在视图与副本里改同一批位置。
import numpy as np
# 切片是视图:改它就是改原数组
a = np.arange(12).reshape(3, 4)
v = a[0:2]
v[:] = -1
print("切片改完,原数组:")
print(a)
# 花式索引是拷贝:改它,原数组毫无反应
b = np.arange(12).reshape(3, 4)
f = b[[0, 1]]
f[:] = -1
print("花式索引改完,原数组:")
print(b)
实跑输出:
切片改完,原数组:
| 行 / 列 | 列 0 | 列 1 | 列 2 | 列 3 |
|---|---|---|---|---|
| 0 | -1 | -1 | -1 | -1 |
| 1 | -1 | -1 | -1 | -1 |
| 2 | 8 | 9 | 10 | 11 |
花式索引改完,原数组:
| 行 / 列 | 列 0 | 列 1 | 列 2 | 列 3 |
|---|---|---|---|---|
| 0 | 0 | 1 | 2 | 3 |
| 1 | 4 | 5 | 6 | 7 |
| 2 | 8 | 9 | 10 | 11 |
⭐ 同样是「取前两行再改掉」,一个改到了原数组、一个没有。 两段代码长得几乎一样,差别只在方括号里是
0:2还是[0, 1]。
🚦 四、⚠️ 「花式索引是拷贝」这句话,只对【读】成立
上面那段容易让人得出一个错误的推论:「既然是拷贝,那我就没法用花式索引改原数组了」。 不对:
import numpy as np
a = np.arange(12).reshape(3, 4)
a[[0, 2]] = -1 # 直接赋值:写得进去
print(a)
b = np.arange(12).reshape(3, 4)
b[b > 7] = 0 # 布尔掩码同理
print(b)
实跑输出:
[[-1 -1 -1 -1]
[ 4 5 6 7]
[-1 -1 -1 -1]]
[[0 1 2 3]
[4 5 6 7]
[0 0 0 0]]
⭐ 原因是 Python 把这两句编译成了完全不同的调用:
| 你写的 | Python 调的 | NumPy 干什么 |
|---|---|---|
x = a[[0, 2]] |
a.__getitem__([0, 2]) |
挑出来,抄一份给你 |
a[[0, 2]] = -1 |
a.__setitem__([0, 2], -1) |
按下标直接往原数组里写,压根没有中间数组 |
现在只想把第一个大于 5 的格子改成 999。a[a > 5][0] 先取一份副本,给这份副本的第一个元素赋值,原表的 a[1,2] 仍然是 6。
用 np.nonzero(第七节还会用到)可以把二维掩码变成两组配对的坐标。两组的第 0 项分别给出第一个命中格的行号和列号。先检查有无命中,再在原表上按这个坐标写入。没有命中时,坐标数组为空,跳过写入。
import numpy as np
a = np.arange(12).reshape(3, 4)
all_matches = a.copy()
a[a > 5][0] = 999
print("写副本之后:", a[1, 2])
rows, cols = np.nonzero(a > 5)
if rows.size:
a[rows[0], cols[0]] = 999
print("只改首个:", a.tolist())
all_matches[all_matches > 5] = 999
print("改全部:", all_matches.tolist())
b = np.arange(12).reshape(3, 4)
b[0][1] = 777
print("写共享行之后:", b[0, 1])
写副本之后,原表的 a[1,2] 仍是 6。下面比较两种不同的原表写入目标。
| 目标 | 修改后的数组(按行) |
|---|---|
| 仅首个命中格 | [0,1,2,3][4,5,999,7][8,9,10,11] |
| 全部命中格 | [0,1,2,3][4,5,999,999][999,999,999,999] |
写共享行之后,b[0,1] 为 777。
先问最后的赋值目标是谁,再检查中间对象是否共享原数据。b[0] 是共享行,所以链式写入仍能到达原表。把坐标直接交给原数组,可以明确写入目标。
下一节继续用这条判据,看看同一个位置被指定多次时会写入什么。
02 / 完整解释
下标本身也有形状和重复。
💀 五、重复下标:+= 只加了一次
这是本章最贵的一个坑,因为它结果偏小、不报错、而且只在有重复下标时才出现:
import numpy as np
idx = np.array([1, 1, 1, 3])
b = np.zeros(5, dtype=int)
b[idx] += 1
print("b[idx] += 1 ->", b, " ⚠️ 1 号位只加了一次")
c = np.zeros(5, dtype=int)
np.add.at(c, idx, 1)
print("np.add.at ->", c, " ✅ 加了三次")
print("np.bincount ->", np.bincount(idx, minlength=5), " 返回新的计数数组")
# 观察:给同一个位置写入不同的值
d = np.zeros(5, dtype=int)
d[[1, 1, 1]] = [10, 20, 30]
print("d[[1,1,1]] = [10,20,30] ->", d)
实跑输出:
结果对照
为什么是 1?这里会先取出临时值、再加 1,最后写回原数组。
tmp = b[idx]→ 取出[0, 0, 0, 0](一份拷贝,就是第三节那件事)tmp += 1→ 变成[1, 1, 1, 1]b[idx] = tmp→ 按下标写回去
第 3 步里,写到 1 号位的三个临时值都是 1。无论先处理哪一个,写完都是 1。若写回的值不同,情况就变了:d[[1,1,1]] = [10,20,30] 在本次运行后观察到 d[1] == 30。NumPy 的高级索引赋值通常不保证迭代顺序,因此不能靠右边的排列预测重复位置最终留下哪个值。
np.add.at(c, idx, 1)对每次出现都直接累加。1 号位依次变为 1、2、3。np.bincount(idx, minlength=5)接收一维非负整数下标,返回新的计数数组。从零开始计数时,两者在这里得到相同数字。分组计数和求和见第 07 章的套路 ②。
统计直方图、词频或累加稀疏梯度时,同一个下标可能出现多次。用上面的 += 写法计数,会漏掉同一位置的重复命中。
可以在这里暂停。 读时先看索引语法,写时先看赋值目标。重复下标需要逐次累加时,用
np.add.at。回来从第六节继续。接下来会给行和列各一份名单,先判断它们会配成哪些坐标。
🧮 六、两个整数数组是「配对」,不是「交叉」
假设想从行 0、2 和列 1、3 取值。先判断任务是每行只取指定的一格,还是让每个选中行都取这两列。
| 行号 | 列 1 | 列 3 |
|---|---|---|
| 行 0 | 配对也选这格,值 1 | 交叉才选,值 3 |
| 行 2 | 交叉才选,值 9 | 配对也选这格,值 11 |
配对(pairwise indexing)把同一位置的行号和列号放在一起。两份长度为 2 的名单产生两对坐标 (0,1)、(2,3)。
交叉组合(Cartesian product)让每个行号与每个列号都配一次。rows[:, None] 给行号加一根长度为 1 的轴。按第 03 章的广播规则,(2,1) 和 (2,) 组成 (2,2) 的坐标网格。
import numpy as np
a = np.arange(12).reshape(3, 4)
rows = np.array([0, 2])
cols = np.array([1, 3])
paired = a[rows, cols]
cross = a[rows[:, None], cols]
print("配对:", paired.tolist(), paired.shape)
print("交叉:", cross.tolist(), cross.shape)
print("np.ix_:", a[np.ix_(rows, cols)].tolist())
two_channels = np.arange(24).reshape(3, 4, 2)
kept = two_channels[rows, cols]
print("配对并保留尾轴:", kept.tolist(), kept.shape)
核对输出。 配对是 [1, 11],形状 (2,)。交叉是 [[1, 3], [9, 11]],形状 (2,2)。np.ix_(rows, cols) 生成用于交叉组合的索引,取值相同。
广播决定索引部分的形状。 二维例子索引了全部轴,所以这个形状也是整个结果的形状。三维表 (3,4,2) 的两对坐标各保留两个通道,得到 [[2,3],[22,23]] 和形状 (2,2)。第八节会说明保留轴的顺序。
- 把每行的行号和该行的正确类别配成一对。运行下面的例子,检查每行是否只改了那一个位置。
import numpy as np
# 每行取出「属于本行标签」的那一个分数
scores = np.array([[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0],
[7.0, 8.0, 9.0],
[10., 11., 12.]])
y = np.array([2, 0, 1, 2]) # 每行的正确类别
n = len(y)
print("每行的正确类分数:", scores[np.arange(n), y])
scores[np.arange(n), y] -= 1.0 # 就地改回去
print(scores)
实跑输出:
每行的正确类分数: [ 3. 4. 8. 12.]
| 行 / 列 | 列 0 | 列 1 | 列 2 |
|---|---|---|---|
| 0 | 1. | 2. | 2. |
| 1 | 3. | 5. | 6. |
| 2 | 7. | 7. | 9. |
| 3 | 10. | 11. | 11. |
np.arange(n) 和 y 都是 (n,),配对之后正好是 (0,y₀), (1,y₁), … —— 每行一个。
这就是 ML 基础 附录 C 第 1 题(Softmax + 交叉熵)里
grad[np.arange(n), y] -= 1.0 那行的机制。⚠️ 那里是顺手写的、没有一个字解释过它为什么这么写。
scores[np.arange(n), y] -= 1.0 读出分数、减 1,再写回 scores 上的原坐标。行号互不相同,所以即使 y 里有相同类别,完整的行列坐标也不会重复。
🔍 七、④ 布尔掩码:整行、单格和逐行汇总
三家门店各记了四个小时的订单数。交日报时,只需要门店 0 和 2 的完整记录。查高峰时,要从三家店挑出订单数超过 5 的小时。如果还要知道每家店有几个高峰小时、这些小时共接了多少单,汇总时就得保留门店归属。
下表的演示数据就是前面用过的 a = np.arange(12).reshape(3, 4)。行对应门店,列对应小时,格子里的单位是单。下标从 0 开始。按 第 02 章的 shape 和 axis 规则,轴 0 有 3 个门店位置,轴 1 有 4 个小时位置。
| 门店 | 小时 0 | 小时 1 | 小时 2 | 小时 3 |
|---|---|---|---|---|
| 0 | 0 | 1 | 2 | 3 |
| 1 | 4 | 5 | 6 | 7 |
| 2 | 8 | 9 | 10 | 11 |
布尔掩码(Boolean mask)是一张由 True(保留)和 False(跳过)组成的选择表。先问每个布尔值要决定的是一整行,还是一格。
取整行时,每家门店一个开关
日报选门店 0 和 2。按门店顺序写下 [True, False, True],得到形状为 (3,) 的 rowmask。在 a[rowmask] 中,它对齐第一根轴(轴 0)。门店 0 留下 [0, 1, 2, 3],门店 1 跳过,门店 2 留下 [8, 9, 10, 11]。
选中了 2 行,每行的 4 列都保留,所以结果形状是 (2, 4)。两个 True 决定的是行数,整个结果有 8 个元素。
取单格时,每个小时一个开关
m = a > 5 把每格和 5 比较,得到与 a 同为 (3, 4) 的掩码。门店 0 四格都跳过。门店 1 的 4 和 5 跳过,6 和 7 留下。门店 2 的 8、9、10、11 全留下。
a[m] 按行从上到下、每行从左到右收集命中的值(C 序),得到 [6, 7, 8, 9, 10, 11]。这 6 个值在同一根轴上,形状是 (6,)。这里的逗号表示只有一个轴。这个结果里已经没有门店轴。
每店计数和求和时,先留住行列
两种汇总都沿每行的 4 个小时计算。门店下标 $i$ 从 0 到 2,小时下标 $j$ 从 0 到 3。$a_{ij}$ 是该格的订单数。
数高峰小时,用 $b_{ij}$ 表示掩码,True 记为 1,False 记为 0。加订单数,用同形状的表 $v$,命中的 $v_{ij}$ 填 $a_{ij}$,其余填 0。
门店 $i$ 的高峰小时数是 $C_i=\sum_{j=0}^{3} b_{ij}$,高峰小时的订单总数是 $S_i=\sum_{j=0}^{3} v_{ij}$。求和符号 $\sum$ 让 $i$ 固定,依次加上小时 0、1、2、3 的四项。前一个和的单位是小时,后一个和的单位是单。
| 门店 | 数小时(小时) | 加订单(单) |
|---|---|---|
| 0 | 0 + 0 + 0 + 0 = 0 | 0 + 0 + 0 + 0 = 0 |
| 1 | 0 + 0 + 1 + 1 = 2 | 0 + 0 + 6 + 7 = 13 |
| 2 | 1 + 1 + 1 + 1 = 4 | 8 + 9 + 10 + 11 = 38 |
m.sum(axis=1) 加的是每行的布尔值。np.where(m, a, 0) 逐格按掩码选原值或 0,对应上面的表 $v$,接着 .sum(axis=1) 加的是每行保留的订单数。两次都消去小时轴,每家门店各留一个数,所以结果都是 (3,)。门店 0 没有命中,两个结果里的第一项仍是 0。
例如,门店 1 有 2 小时高峰,但共接 13 单。把订单值填成 1 再求和,会只数出小时数。
运行一次,对照刚才算出的形状和数值
import numpy as np
a = np.arange(12).reshape(3, 4)
m = a > 5
print("掩码本身:", m.dtype, m.shape)
print(m)
print("a[m] =", a[m], " shape", a[m].shape)
print("共享内存:", np.shares_memory(a, a[m]))
print("等价写法 a[np.nonzero(m)] =", a[np.nonzero(m)])
print("nonzero 给的是下标:", np.nonzero(m))
rowmask = np.array([True, False, True])
print("按行选:", a[rowmask].shape)
print("按行选的值:", a[rowmask].tolist())
print("每店高峰小时数:", m.sum(axis=1).tolist())
print("每店高峰订单数:", np.where(m, a, 0).sum(axis=1).tolist())
实跑输出:
掩码本身: bool (3, 4)
| 行 / 列 | 列 0 | 列 1 | 列 2 | 列 3 |
|---|---|---|---|---|
| 0 | False | False | False | False |
| 1 | False | False | True | True |
| 2 | True | True | True | True |
a[m] = [ 6 7 8 9 10 11] shape (6,)
共享内存: False
等价写法 a[np.nonzero(m)] = [ 6 7 8 9 10 11]
nonzero 给的是下标: (array([1, 1, 2, 2, 2, 2]), array([2, 3, 0, 1, 2, 3]))
按行选: (2, 4)
按行选的值: [[0, 1, 2, 3], [8, 9, 10, 11]]
每店高峰小时数: [0, 2, 4]
每店高峰订单数: [0, 13, 38]
布尔索引读取返回副本,可用 np.shares_memory 验证。np.nonzero(m) 给出两组下标,一组行号、一组列号。按上一节的规则逐位配对,前两个坐标是 (1, 2) 和 (1, 3),所以 a[np.nonzero(m)] 和本例的 a[m] 取到相同的值。
查错时,先看掩码的形状和类型
a[rowmask] 用前面定义的 rowmask 对齐轴 0,给 3 个门店各一个布尔值。a[m] 用前面定义的 m = a > 5 对齐两个轴,给 3 × 4 个位置各一个布尔值。[True, False] 只回答了两家店,和轴 0 的长度 3 对不上,所以会抛出 IndexError。布尔索引不会把缺的布尔值按第 03 章的运算广播规则补齐。
检查 dtype 也很重要。a[[0, 1, 0]] 里是整数,会依次读第 0、1、0 行。需要做开关时,应传布尔值。
再用原表检查三个常见错误:
import numpy as np
a = np.arange(12).reshape(3, 4)
print("✅ 正确 a[(a > 3) & (a < 8)] =", a[(a > 3) & (a < 8)])
try:
a[a > 3 and a < 8]
except ValueError as e:
print("❌ 用 and ->", e)
bad = (a > 3) & a < 8 # ⚠️ 少一对括号,不报错
print("⚠️ 少括号 a[(a > 3) & a < 8] =", a[bad])
print(" 它算出来的掩码:")
print(bad)
try:
a[np.array([True, False])]
except IndexError as e:
print("❌ 掩码长度不对 ->", e)
实跑输出:
结果对照
| 现场 | 症状 |
|---|---|
用 and / or / not |
当场报错:The truth value of an array with more than one element is ambiguous |
| 少一对括号 | ⚠️⚠️ 不报错,静默给出全错的答案 |
| 掩码长度对不上 | 报错,而且报得很清楚(size of axis is 3 but ... is 2) |
少括号时,& 比 < 先算。((a > 3) & a) < 8 中的第一步是按位与(bitwise AND),先对整数的二进制位计算,随后才拿结果比 8。本例因此错误地返回全部 12 个元素。
每个比较都加括号,例如 (a > 3) & (a < 8)。这样 & 才会组合两份布尔结果。
自检:把高峰门槛改成超过 7 单
继续用原表。先预测逐格筛选的结果与形状,再算每店的高峰小时数和订单总数。然后试着用 a[a[:, :1] > 7] 取格子,解释报错发生在哪根轴。
查看答案
只剩门店 2 的 8、9、10、11。逐格筛选得到 [8, 9, 10, 11],形状为 (4,)。按门店计数是 [0, 0, 4],订单总数是 [0, 0, 38],两次汇总都还给每家店留了一个位置。
a[:, :1] 保留所有行和第一列,因此比较得到 (3, 1) 的二维掩码。轴 1 上的 1 对不上原表的 4,直接用它索引会抛出 IndexError。如果目的是按第一列的条件保留整行,用 a[a[:, 0] > 7]:整数索引 0 取出第一列并去掉列轴,生成的 (3,) 掩码选出门店 2 的整行,形状是 (1, 4)。
回顾时先说清结果里每个位置代表什么。整行筛选保留每个入选门店的全部小时,逐格筛选收集命中的值,沿轴 1 汇总给每家店留一个数。接下来会看混合索引时结果轴放在哪里。到 第 07 章,也会先辨认循环在沿哪根轴或按哪些组累积,再选择数组写法。
03 / 完整解释
看结果轴,也看搬运量。
🧷 八、混着用:花式索引被切片隔开时,结果轴会跑到最前面
把原表看成 (3,4,5),三根轴依次有 3、4、5 个位置。先圈出用整数数组选的轴,再找仍由 : 保留的轴。
| 写法 | 索引部分放在哪 | 结果形状 |
|---|---|---|
a[:, [0,2], :] | 只有一处,放在两根保留轴之间 | (3,2,5) |
a[[0,1], [0,2], :] | 两处相邻,合成一根配对轴 | (2,5) |
a[[0,1], :, [0,2]] | 被全切片隔开,配对轴移到最前 | (2,4) |
相邻的索引组放在原位置。被 :、... 或 None 隔开时,索引部分放在最前。普通整数和整数数组混用时,整数的位置也参与判断这一组索引是否相邻。
import numpy as np
a = np.arange(60).reshape(3, 4, 5)
print("① 花式索引挨着切片,位置不变:", a[:, [0, 2], :].shape)
print("② 花式索引被切片隔开: ", a[[0, 1], :, [0, 2]].shape)
print("③ 两个花式索引挨在一起: ", a[[0, 1], [0, 2], :].shape)
paired = a[[0, 1], :, [0, 2]]
paired_explicit = np.stack((a[0, :, 0], a[1, :, 2]))
cross = a[[0, 1]][:, :, [0, 2]]
cross_broadcast = a[np.array([0, 1])[:, None], :, [0, 2]]
print("逐对取值:", paired.shape, paired.tolist())
print("逐对取值的显式写法:", np.array_equal(paired, paired_explicit))
print("交叉组合(保留原轴顺序):", cross.shape)
print("交叉组合(组合轴在前):", cross_broadcast.shape)
实跑输出:
操作步骤
- 花式索引挨着切片,位置不变: (3, 2, 5)
- 花式索引被切片隔开: (2, 4)
- 两个花式索引挨在一起: (2, 5)
- 逐对取值: (2, 4) [[0, 5, 10, 15], [22, 27, 32, 37]]
- 逐对取值的显式写法: True
- 交叉组合(保留原轴顺序): (2, 4, 2)
- 交叉组合(组合轴在前): (2, 2, 4)
看表格最后一行。轴 0 的 [0, 1] 和轴 2 的 [0, 2] 逐位配成 (0, 0)、(1, 2) 两对。两个索引数组被切片隔开,NumPy 把长度为 2 的配对轴放在结果最前面。中间的 : 为每对坐标保留轴 1 的 4 个位置,所以形状是 (2, 4)。
先确定需要哪几对坐标,再选写法。
- 逐对取值,两个组合。
np.stack((a[0, :, 0], a[1, :, 2]))把两条长度为 4 的数组叠成两行,形状也是(2, 4),值与原写法相同。 - 交叉组合,保留原来的轴顺序。
a[[0, 1]][:, :, [0, 2]]分两次选择,先取轴 0 的两项,再取轴 2 的两项。每个轴 0 下标都和每个轴 2 下标组合,共有(0, 0)、(0, 2)、(1, 0)、(1, 2)四对,形状是(2, 4, 2)。 - 交叉组合,把组合轴放在前面。
a[np.array([0, 1])[:, None], :, [0, 2]]把两个索引数组的形状(2, 1)与(2,)广播成(2, 2),取同样四对坐标。两个索引数组被切片隔开,因此两根组合轴都排在长度 4 的轴之前,形状是(2, 2, 4)。
⚖️ 九、视图、拷贝与预计算的成本
现在让切片和整数索引取同一批偶数行。三项分别计时:创建视图、复制切片、用已算好的下标取值。结果相同后再比较时间。
timeit.repeat 每组连续跑 20 次。取 7 组中最短的一组,再除以 20,估计每次操作较少受系统干扰的耗时。这里测的是该输入下的表现。
import numpy as np, timeit
n = 2000
a = np.ones((n, n), dtype=np.float64)
idx = np.arange(0, n, 2)
print("选出的值一样:", np.array_equal(a[::2], a[idx]))
print(f"结果大小 {a[idx].nbytes / 2**20:.2f} MiB")
t_view = min(timeit.repeat(lambda: a[::2], number=20, repeat=7)) / 20
t_copy = min(timeit.repeat(lambda: a[::2].copy(), number=20, repeat=7)) / 20
t_index = min(timeit.repeat(lambda: a[idx], number=20, repeat=7)) / 20
print(f"切片视图: {t_view*1e6:.2f} μs")
print(f"复制切片: {t_copy*1e6:.2f} μs")
print(f"整数索引: {t_index*1e6:.2f} μs")
原实验记录(NumPy 2.4.6,同一台机器测量三次):
对照
选出的东西一模一样: True
结果大小约 15.26 MiB
切片(视图) 0.14 us
切片 + .copy() 5595.84 us
花式索引 5850.59 us
| 写法 | 三次实测 | 在干什么 |
|---|---|---|
a[::2] |
0.13 – 0.14 微秒 | 填一份新说明书,和数组多大完全无关 |
a[::2].copy() |
5.6 – 6.6 毫秒 | 真的搬 15.26 MiB |
a[idx] |
5.9 – 6.9 毫秒 | 同样搬 15.26 MiB |
- 视图只建立读取描述。复制切片和整数索引都生成
1000 × 2000 × 8字节的数据,约 15.26 MiB。 - 整数索引还要按下标取值。本例按顺序选整行。下标顺序、内存布局和选取规模都会影响耗时。
再看一维数组的稀疏掩码。种子 0 固定本例生成的数据,阈值 0.001 让命中约占千分之一。三项分别计时,区分复用现成下标和现场生成下标。
import numpy as np, timeit
rng = np.random.default_rng(0)
x = rng.random(5_000_000)
mask = x < 0.001
idx = np.flatnonzero(mask)
print("命中", idx.size, "个 /", x.size)
print("结果一样:", np.array_equal(x[mask], x[idx]))
cases = [
("布尔掩码", lambda: x[mask]),
("复用现成下标", lambda: x[idx]),
("现场求下标再取值", lambda: x[np.flatnonzero(mask)]),
]
for name, select in cases:
seconds = min(timeit.repeat(select, number=20, repeat=5)) / 20
print(f"{name}: {seconds*1e6:.1f} μs")
本例命中 5031 个元素,取值结果一致。读计时结果时,先确认每一项从哪一步开始。
- 布尔掩码。 从检查整张掩码开始。
- 复用现成下标。 只计按
idx取值,适合掩码不变而且要多次取值的场景。 - 现场求下标再取值。 包括遍历掩码并创建下标。只取一次时,用这一项和第一项比。
如果掩码也是现算的,三项都要加上生成掩码的成本。
一维的 x[idx] 使用摊平下标。二维表逐格取值时,保存 coords = np.nonzero(m),再用 a[coords]。直接把摊平下标交给 a[...] 会把它当成行号。第 07 章的套路 ⑥还会用 np.flatnonzero 找相邻变化。
可以在这里暂停。 先分清索引部分的形状和保留的轴。比较速度时,记得确认计时从哪一步开始。
回来从下一节的速记表继续,再用检查题预测结果。
📋 十、一页速记
| 想干的事 | 写法 | 视图还是拷贝 |
|---|---|---|
| 取连续/等距的一块 | a[1:3, ::2] |
视图 |
| 取一整行 / 一整列 | a[2] / a[:, 3] |
视图 |
| 倒序 | a[::-1] |
视图(strides 变负) |
| 取一个标量 | a[2, 1] |
0 维标量 |
| 按任意顺序挑几行 | a[[2, 0, 2]] |
拷贝 |
| 按条件挑元素 | a[a > 5] |
拷贝 |
| 每行各取一个 ⭐ | a[np.arange(n), y] |
拷贝(配对,不是交叉) |
| 交叉取(行 × 列的小方阵) | a[np.ix_(rows, cols)] |
拷贝 |
| 把切片变成独立的一份 | a[1:3].copy() |
拷贝(明码标价) |
| 重复下标累加或计数 | np.add.at(b, idx, 1) 或 np.bincount(idx) |
前者就地更新 b。后者返回新的计数数组。 |
| 掩码 → 整数下标 | np.nonzero(mask)(每根轴一个数组)/ np.flatnonzero(mask)(摊平后的下标) |
— |
| 判断两个数组共不共享内存 | np.shares_memory(a, b) |
— |
⭐ 两条判据,记住这两条就够了:
- 视图、拷贝还是标量 → 先看索引语法:普通数值 ndarray 的基础切片返回视图,整数数组和布尔高级索引读取返回副本,即使下标恰好等距;只用整数索引取尽所有轴时返回标量。shape、strides 与起点解释视图怎样共享数据,不能反过来充当“能描述就必定给视图”的充分判据。
- 赋值写到哪里 → 看赋值目标及中间结果是否共享原数据:基础索引得到视图时,链式赋值可能写回;高级索引先读出临时副本后,再改那份副本不会写回。优先直接在原数组上合并选择做一次索引赋值,可避免误写临时副本;不能只靠方括号数量判断。
04 / 完整解释
留下能回查的索引判据。
🔗 这一章连到哪里
| 相关的地方 | 为什么 |
|---|---|
| 05 · 内存布局与 stride | 用起点与步长解释为什么基础切片能共享数据。 |
| 04 · 视图还是拷贝 | 那一章告诉你「改了会不会串」这件事有多要命,本章告诉你哪种语法会串 |
| 03 · 广播的三条规则 | 第六节用广播规则组合行列下标,并用 rows[:, None] 增加长度为 1 的轴。 |
| 07 · 把循环改写成数组运算 | 套路 ② 用 np.bincount 返回分组结果。套路 ⑥ 用 np.flatnonzero 找一维序列里的变化位置。 |
| 02 · shape 和 axis 到底怎么数 | a[:, None] 用的是索引语法,本章第六节拿它做「配对 vs 交叉」的开关 |
| ML 基础 附录 C · 手撕代码速查 | 第 1 题用 grad[np.arange(n), y] -= 1.0,将行号与每行的正确类别配对。 |
✅ 检查点
- 用一句话说清「什么时候给视图、什么时候给拷贝」的判据。
a = np.arange(12, dtype=np.int64).reshape(3,4)。a[1:3, ::2]的形状和步长是多少?第二个 16 怎样算出?a[[2, 0, 2]]为什么没法是视图?拿那三行的字节偏移说明。a[:, 3]选出的元素在内存里并不挨着,它还是视图吗?为什么?f = a[[0, 1]]; f[:] = -1之后a变了吗?a[[0, 1]] = -1呢?两者差在哪?a[a > 5][0] = 999会改到原表吗?怎样只改原表的第一个命中格?写入b[0][1]为什么能到达原表?- 💀
b = np.zeros(5, int); b[[1,1,1]] += 1之后b[1]是几?为什么?该怎么写才对? - 二维表的配对和交叉各得到什么形状?如果原表是
(3,4,2),按同样的行列名单配对,第三根轴会怎样? - 按什么规则判断布尔索引读取会返回副本?掩码里的
True数在本章的整行和逐格示例中分别决定什么?a[(a > 3) & a < 8]少了一对括号又会怎样? - 第八节的三维数组里,
a[[0,1], :, [0,2]]和a[[0,1]][:, :, [0,2]]各取哪几对坐标?结果各是什么形状?如果要反复使用同一个掩码,第九节的一维x和第七节的二维表a分别怎样保存下标?
👀 答案
- 先按索引语法判断:普通数值 ndarray 的基础切片返回视图,整数数组和布尔高级索引读取返回副本,只用整数索引取尽所有轴时返回标量。shape、strides 与起点解释视图怎样共享原数据,不能反过来推出“能描述就一定给视图”;
a[[0,1,2]]即使等距也仍是副本。 - shape
(2, 2),strides(32, 16)。行步长照抄原来的 32(一整行 4 个 int64);列步长是8 × 2 = 16,因为::2隔一个取。起点还挪了1 × 32 = 32字节,所以第一个元素是4。 - 三行的偏移为 64、0、64 字节,先减 64,再加 64,无法用一个固定行步长表示。索引语法决定读取结果是副本。
- 是视图。 原表每行 4 个元素,沿列向下走一格要跨
4 * a.itemsize字节。元素占 8 字节时就是 32 字节。前文的 80 字节来自每行有 10 个元素的表。 f[:] = -1之后a没变(f是拷贝);a[[0, 1]] = -1之后a变了。差别是 Python 编译成了不同的调用:前者__getitem__先抄一份再改那份拷贝,后者__setitem__直接按下标往原数组写、压根没有中间数组。a[a > 5][0] = 999只修改临时副本。用rows, cols = np.nonzero(a > 5)找坐标,有命中时用a[rows[0], cols[0]] = 999只改一格。b[0]是共享行,所以写入这行能到达原表。b[1]是 1。高级索引先读出三个 0,各自加 1,再将三个相同的 1 写回同一位置。若要在原数组上累计,从新的零数组b开始运行np.add.at(b, [1, 1, 1], 1)。若要单独生成一张计数表,用np.bincount([1, 1, 1], minlength=5),结果是[0, 3, 0, 0, 0]。- 二维表的配对形状是
(2,),交叉形状是(2,2)。广播得到索引部分的形状。三维表保留长度为 2 的尾轴,所以两对坐标的结果是(2,2),每对带两个值。 - 布尔高级索引读取产生副本。整行例子的两个
True决定行数,4 列保留。逐格例子的六个True决定一维长度。少括号会先做按位与,例子中 12 个值都被选中。使用and会抛出ValueError。 - 一次索引逐对取
(0, 0)和(1, 2),每对保留中间轴的 4 个位置,形状是(2, 4)。两步索引还取(0, 2)和(1, 0),四对坐标按原轴顺序排列,形状是(2, 4, 2)。一维x可以预先算idx = np.flatnonzero(mask)后用x[idx]。二维逐格选择预先算coords = np.nonzero(m)后用a[coords],等价于a[np.nonzero(m)]。
本节回顾
走神救援。按任务回到下面三处。
- 读完还要修改。 先用语法分清视图和副本,再问最后的赋值目标是哪一个数组。直接写原坐标,或通过可写的共享视图,都能改到原数据。
- 同一个下标反复出现。 从 0 开始,
b[[1,1,1]] += 1写回 1。要逐次累加,用np.add.at。从零生成频次表可以用np.bincount。 - 有多份下标。 先列出配对或交叉坐标,再标出保留的轴。二维布尔掩码逐格筛选时,坐标会合在一根轴上。
本章用索引确定取值位置。下一章会从一个循环的目标出发,判断该做累计、分组还是滑动窗口。