🏠 总目录📚 本教程 06 · 索引的四种形态 ← →

NUMPY / 06 · 06 · 索引的四种形态

重复下标三次,为什么只加了一次?

先读到临时结果,再写回原数组,与逐次执行累加,走的是两条不同的路径。

你能区分读取与赋值,也能解释重复下标何时需要 np.add.at。

indexing 机制示意示意初始 a[0]=0。a[[0,0,0]] += 1 写回 1;np.add.at(a,[0,0,0],1) 在独立重置后得到 3。独立从 a[0]=0 开始a[[0,0,0]] += 1临时值 [1,1,1]写回 a[0] = 1np.add.at:逐次累加0 → 1 → 2 → 3a[0] = 3
示意初始 a[0]=0。a[[0,0,0]] += 1 写回 1;np.add.at(a,[0,0,0],1) 在独立重置后得到 3。
阅读范围、用时与原有实验记录
实验记录怎么读

本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。

⏱ 80 分钟 | ⭐ 方括号里放什么,决定你拿到的是原数组的一扇窗,还是一份复印件 —— 而这件事有一条唯一的判据

01 / 完整解释

取出相同的数,不等于以相同方式返回。

🎯 一句话

先看索引语法:本章普通数值 ndarray 的基础切片返回视图;整数数组索引和布尔高级索引读取返回副本,即使下标恰好等距。 shape、strides 与起点解释基础切片怎样共享数据,不能反过来证明某种索引一定返回视图;如果每根轴都只给一个整数,就得到标量。

上一章用形状(shape)、各轴步长(strides)和起点解释一块数据怎样被读取。本章用同一张二维数组练习四种选法,先预测返回什么,再判断修改会写到哪里。

  • 视图(view)沿用原数组的数据,改动重叠的元素会反映到原数组。
  • 副本(copy)有自己的数据。即使整数下标等距,例如 a[[0,1,2]],高级索引读取仍返回副本。

🧩 一、四种形态,一次看全

本章的行号和列号都从 0 开始。先看同一张表的四种读法。

同一张 3×4 表的四种读法
形态例子读取结果
① 基础切片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)}")

实跑输出:

操作步骤

  1. 基础切片 shape=(2, 2) 共享内存=True
  2. 花式索引 shape=(2, 4) 共享内存=False
  3. 布尔掩码 shape=(6,) 共享内存=False
  4. 整数索引 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]} 字节")

实跑输出:

关键信息

[[ 8 9 10 11]
[ 0 1 2 3]
[ 8 9 10 11]]
shape: (3, 4)
共享内存: False
第 2 行 -> 偏移 64 字节
第 0 行 -> 偏移 0 字节
第 2 行 -> 偏移 64 字节

三行的起始偏移是 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
2891011

花式索引改完,原数组:

按行、列对齐查看数组
行 / 列列 0列 1列 2列 3
00123
14567
2891011

⭐ 同样是「取前两行再改掉」,一个改到了原数组、一个没有。 两段代码长得几乎一样,差别只在方括号里是 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)

实跑输出:

结果对照

b[idx] += 1 -> [0 1 0 1 0] ⚠️ 1 号位只加了一次
np.add.at -> [0 3 0 1 0] ✅ 加了三次
np.bincount -> [0 3 0 1 0] 返回新的计数数组
d[[1,1,1]] = [10,20,30] -> [ 0 30 0 0 0](本次观察)

为什么是 1?这里会先取出临时值、再加 1,最后写回原数组。

  1. tmp = b[idx] → 取出 [0, 0, 0, 0](一份拷贝,就是第三节那件事)
  2. tmp += 1 → 变成 [1, 1, 1, 1]
  3. 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
01.2.2.
13.5.6.
27.7.9.
310.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 个小时位置。

订单数(单)。加粗表示超过 5 单。
门店小时 0小时 1小时 2小时 3
00123
14567
2891011

布尔掩码(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 的四项。前一个和的单位是小时,后一个和的单位是单。

每一行各算两次:数高峰小时,再加高峰订单
门店数小时(小时)加订单(单)
00 + 0 + 0 + 0 = 00 + 0 + 0 + 0 = 0
10 + 0 + 1 + 1 = 20 + 0 + 6 + 7 = 13
21 + 1 + 1 + 1 = 48 + 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
0FalseFalseFalseFalse
1FalseFalseTrueTrue
2TrueTrueTrueTrue

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)

实跑输出:

结果对照

✅ 正确 a[(a > 3) & (a < 8)] = [4 5 6 7]
❌ 用 and -> The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
⚠️ 少括号 a[(a > 3) & a < 8] = [ 0 1 2 3 4 5 6 7 8 9 10 11]
它算出来的掩码:
[[ True True True True]
[ True True True True]
[ True True True True]]
❌ 掩码长度不对 -> boolean index did not match indexed array along axis 0; size of axis is 3 but size of corresponding boolean axis is 2
现场 症状
用 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)

实跑输出:

操作步骤

  1. 花式索引挨着切片,位置不变: (3, 2, 5)
  2. 花式索引被切片隔开: (2, 4)
  3. 两个花式索引挨在一起: (2, 5)
  4. 逐对取值: (2, 4) [[0, 5, 10, 15], [22, 27, 32, 37]]
  5. 逐对取值的显式写法: True
  6. 交叉组合(保留原轴顺序): (2, 4, 2)
  7. 交叉组合(组合轴在前): (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) —

⭐ 两条判据,记住这两条就够了:

  1. 视图、拷贝还是标量 → 先看索引语法:普通数值 ndarray 的基础切片返回视图,整数数组和布尔高级索引读取返回副本,即使下标恰好等距;只用整数索引取尽所有轴时返回标量。shape、strides 与起点解释视图怎样共享数据,不能反过来充当“能描述就必定给视图”的充分判据。
  2. 赋值写到哪里 → 看赋值目标及中间结果是否共享原数据:基础索引得到视图时,链式赋值可能写回;高级索引先读出临时副本后,再改那份副本不会写回。优先直接在原数组上合并选择做一次索引赋值,可避免误写临时副本;不能只靠方括号数量判断。

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,将行号与每行的正确类别配对。

✅ 检查点

  1. 用一句话说清「什么时候给视图、什么时候给拷贝」的判据。
  2. a = np.arange(12, dtype=np.int64).reshape(3,4)。a[1:3, ::2] 的形状和步长是多少?第二个 16 怎样算出?
  3. a[[2, 0, 2]] 为什么没法是视图?拿那三行的字节偏移说明。
  4. a[:, 3] 选出的元素在内存里并不挨着,它还是视图吗?为什么?
  5. f = a[[0, 1]]; f[:] = -1 之后 a 变了吗?a[[0, 1]] = -1 呢?两者差在哪?
  6. a[a > 5][0] = 999 会改到原表吗?怎样只改原表的第一个命中格?写入 b[0][1] 为什么能到达原表?
  7. 💀 b = np.zeros(5, int); b[[1,1,1]] += 1 之后 b[1] 是几?为什么?该怎么写才对?
  8. 二维表的配对和交叉各得到什么形状?如果原表是 (3,4,2),按同样的行列名单配对,第三根轴会怎样?
  9. 按什么规则判断布尔索引读取会返回副本?掩码里的 True 数在本章的整行和逐格示例中分别决定什么?a[(a > 3) & a < 8] 少了一对括号又会怎样?
  10. 第八节的三维数组里,a[[0,1], :, [0,2]] 和 a[[0,1]][:, :, [0,2]] 各取哪几对坐标?结果各是什么形状?如果要反复使用同一个掩码,第九节的一维 x 和第七节的二维表 a 分别怎样保存下标?
👀 答案
  1. 先按索引语法判断:普通数值 ndarray 的基础切片返回视图,整数数组和布尔高级索引读取返回副本,只用整数索引取尽所有轴时返回标量。shape、strides 与起点解释视图怎样共享原数据,不能反过来推出“能描述就一定给视图”;a[[0,1,2]] 即使等距也仍是副本。
  2. shape (2, 2),strides (32, 16)。行步长照抄原来的 32(一整行 4 个 int64);列步长是 8 × 2 = 16,因为 ::2 隔一个取。起点还挪了 1 × 32 = 32 字节,所以第一个元素是 4。
  3. 三行的偏移为 64、0、64 字节,先减 64,再加 64,无法用一个固定行步长表示。索引语法决定读取结果是副本。
  4. 是视图。 原表每行 4 个元素,沿列向下走一格要跨 4 * a.itemsize 字节。元素占 8 字节时就是 32 字节。前文的 80 字节来自每行有 10 个元素的表。
  5. f[:] = -1 之后 a 没变(f 是拷贝);a[[0, 1]] = -1 之后 a 变了。差别是 Python 编译成了不同的调用:前者 __getitem__ 先抄一份再改那份拷贝,后者 __setitem__ 直接按下标往原数组写、压根没有中间数组。
  6. a[a > 5][0] = 999 只修改临时副本。用 rows, cols = np.nonzero(a > 5) 找坐标,有命中时用 a[rows[0], cols[0]] = 999 只改一格。b[0] 是共享行,所以写入这行能到达原表。
  7. 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]。
  8. 二维表的配对形状是 (2,),交叉形状是 (2,2)。广播得到索引部分的形状。三维表保留长度为 2 的尾轴,所以两对坐标的结果是 (2,2),每对带两个值。
  9. 布尔高级索引读取产生副本。整行例子的两个 True 决定行数,4 列保留。逐格例子的六个 True 决定一维长度。少括号会先做按位与,例子中 12 个值都被选中。使用 and 会抛出 ValueError。
  10. 一次索引逐对取 (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。
  • 有多份下标。 先列出配对或交叉坐标,再标出保留的轴。二维布尔掩码逐格筛选时,坐标会合在一根轴上。

本章用索引确定取值位置。下一章会从一个循环的目标出发,判断该做累计、分组还是滑动窗口。

下一章 · 把循环改写成数组运算

打卡记录保存在你的浏览器里,首页能看到总进度

索引关系看清以后,再问:这段循环真正维护的,是累计、分组还是一段窗口?