🏠 总目录📚 本教程 05 · 内存布局与 stride ← →

NUMPY / 05 · 05 · 内存布局与 stride

转置没搬数据,读取顺序怎么变了?

同一排数可以有不止一种读取说明。shape、stride 与 offset 决定了每一步落到哪里。

你能区分说明书变化与数据搬运,并判断 reshape 为什么有时需要复制。

strides 机制示意本图的步幅按“元素”计,真实 ndarray.strides 按字节计。原数组 (2,3) 与转置 (3,2) 共享同一缓冲区。同一缓冲区:0 1 2 3 4 5x:shape (2,3)012345x.T:shape (3,2)031425步幅 (3,1) → (1,3)
本图的步幅按“元素”计,真实 ndarray.strides 按字节计。原数组 (2,3) 与转置 (3,2) 共享同一缓冲区。
阅读范围、用时与原有实验记录
实验记录怎么读

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

⏱ 50 分钟 | ⭐ 同一段数据可以有多种读法,先找起点,再按步长走。

01 / 完整解释

字节没动,说明书怎么变?

🎯 一句话

ndarray 用一套规则把下标对应到数据缓冲区中的字节。 转置和基础切片可以用不同的起点或步长读取同一块数据。改形状能否沿用原数据,要看新的读取方式。

上一章你已经知道「视图会跟着变、拷贝不会」。这一章回答为什么 —— 以及为什么有些 reshape 白拿,有些要掏钱。

⚠️ 先消歧,不然你会记混。 站内别处出现的「stride」是卷积的滑动步长(Conv2d(stride=2),隔一格取一次)。 这一章说的 stride 是内存步长:沿某个轴走一格,地址要挪多少字节。 两者同名不同物,唯一的共同点是「跨着走」这个字面意思。

🧩 一、说明书里有什么

要找到表里的某一格,先看形状(shape)确定行列范围,再从第一个逻辑元素出发。步长(stride)表示某一轴的下标加 1 时地址变化多少字节。数据类型(dtype)决定每格怎样解读,itemsize 给出每格的字节数。

下面原有的示例以默认整数为 8 字节的环境为例。后面新增的数字练习显式指定 np.int64。

import numpy as np

base = np.arange(12)
a = base.reshape(3, 4)

print(a.shape)      # (3, 4)
print(a.strides)    # (32, 8)   ⭐ 单位是【字节】,不是元素
print(a.itemsize)   # 8         int64 每个占 8 字节
print(a.dtype)      # int64

strides = (32, 8) 读作:

动作 地址挪多少
行号 +1(往下走一行) 32 字节 = 4 个元素 = 一整行
列号 +1(往右走一格) 8 字节 = 1 个元素
同一块连续内存(base)每格 1 个 int64 = 8 Bashape (3, 4) · strides (32, 8)a.Tshape (4, 3) · strides (8, 32)00 B18 B216 B324 B432 B540 B648 B756 B864 B972 B1080 B1188 B行 +1跨 4 格 = +32 B列 +1:跨 1 格 = +8 B行 +1:跨 1 格 = +8 B列 +1跨 4 格 = +32 Ba[2, 1]2×32 + 1×8 = 72 B → 第 9 格转置前后:中间 12 格一字未动,只有两组 strides 互换
看中间那条内存:转置前后它一个字节都没动,动的只是两组箭头的跨度。shape / strides 是说明书,不是另一份数据。

⭐ 相对起点的字节偏移 = 行号 × 行步长 + 列号 × 列步长。 偏移(offset)表示地址相差多少字节。这里的起点是 a[0, 0],行号和列号都是从 0 数的有效非负下标。比如第 2 行第 1 列,先走两行的 2 × 32 = 64 字节,再走一列的 8 字节,共 72 字节。

import numpy as np

base = np.arange(12)
a = base.reshape(3, 4)

print(a[2, 1])                              # 9
off = 2 * a.strides[0] + 1 * a.strides[1]   # 2*32 + 1*8
print(off)                                  # 72  ← 字节偏移
print(off // a.itemsize)                    # 9   ← 第 9 个元素
print(a.ravel()[9])                         # 9   ✅ 对上了

这组二维单元素索引用固定次数的乘加定位。对按行连续的 a,每 8 字节就是一格,所以 72 ÷ 8 = 9,从 0 数的第 9 格就是值 9。下面换一个读取起点,看看原来的偏移公式还怎么用。

倒着读一行,地址怎样走?

还是同一张 3×4 的表。想把每行从右往左读,可以写 v = a[:, ::-1]。第一个 : 保留所有行,第二个 ::-1 从每行最后一列开始,向左逐列取值。第一行仍是四格,起点从值 0 换到了值 3。

把原表的第 0 行倒过来读
视图中的列号原表中的值距原表起点的字节数
0324
1216
218
300

原表每格 8 字节,所以 v[0, 0] 相对 a[0, 0] 的起点偏移是 3 × 8 = 24 字节。视图中行号加 1 仍向后走 32 字节,列号加 1 则向前走 8 字节,所以 v.strides = (32, -8)。

找 v[1, 2]。 从视图起点出发,下移一行、沿倒序列走两格,偏移是 1 × 32 + 2 × (−8) = 16 字节。再加上两个起点相差的 24 字节,得到相对原表起点的 24 + 16 = 40 字节。原表按行排列,40 ÷ 8 = 5 是从 0 数的第 5 格,也就是 a[1, 1] = 5。

import numpy as np

a = np.arange(12, dtype=np.int64).reshape(3, 4)  # (3, 4)
v = a[:, ::-1]                                 # (3, 4)
row, col = 1, 2
offset = row * v.strides[0] + col * v.strides[1]
start = v.ctypes.data - a.ctypes.data

print(v.shape, v.strides)           # (3, 4) (32, -8)
print(v[0].tolist())                # [3, 2, 1, 0]
print(start, offset, start + offset)  # 24 16 40
print(int(v[row, col]), int(a[1, 1]))  # 5 5
print(np.shares_memory(a, v))       # True

代码中 offset 是相对视图起点的距离,start 是两个起点的地址差。.ctypes.data 在这里仅用来取得起点地址的整数值。最后两行分别验证格子取值和数据重叠。步长为负也可以共享数据。NumPy 的步长说明

🧩 二、转置为什么是免费的

既然地址是算出来的,那么把 strides 换个顺序,就等于换了一种读法:

import numpy as np

a = np.arange(12).reshape(3, 4)

print(a.shape,   a.strides)      # (3, 4) (32, 8)
print(a.T.shape, a.T.strides)    # (4, 3) (8, 32)   ⭐ 反过来了
print(np.shares_memory(a, a.T))  # True             ⭐ 同一块内存

转置没有搬动任何一个字节,它只是把说明书里的 shape 和 strides 同时倒了个个儿。 原来「往下走 32 字节」,现在改成「往右走 32 字节」—— 同一块内存,换了个读法。

⭐ 这解释了一个常见困惑:为什么 a.T 对 100 万行的矩阵也是瞬间返回? 因为它根本没干活。干活的是后面真正读数据的那一步。

🚦 三、⚠️ .base 不记录完整的视图链

上一章使用 np.shares_memory(a, b) 检查两数组是否有重叠内存;这一节解释为什么 .base is a 不能替代它。

import numpy as np

base = np.arange(12)
a = base.reshape(3, 4)

print(a.base is base)      # True
print(a.T.base is a)       # ⚠️ False —— 直觉会以为 True
print(a.T.base is base)    # ⭐ True —— 它一路指回真正持有内存的那个

.base 表示该数组借用内存的来源对象,不保证是创建它时的“上一层”,也不保证一定是 ndarray。下面这组普通数组的视图链跳过了中间层;不能把这个例子的对象身份推广为所有数组的恒定规则。

⚠️ 所以上一章那个 c.base is b 的写法,只在 b 自己就是内存持有者时才成立。 一旦 b 本身也是个视图,c.base is b 就会给你 False,但它们确实共享内存。

⚠️⚠️ 而且它还会朝另一个方向骗你 —— .base 不是 None,却根本不共享内存:

import numpy as np

base = np.arange(12)
a = base.reshape(3, 4)

for name, x in [("a.T.reshape(12)", a.T.reshape(12)),
                ("a[1:3, [0,2]]",   a[1:3, [0,2]]),
                ("a[[0,2]]",        a[[0,2]])]:
    print(f"{name:18} .base is None = {x.base is None:<5}  共享内存 = {np.shares_memory(a, x)}")
# a.T.reshape(12)    .base is None = False  共享内存 = False   ⚠️
# a[1:3, [0,2]]      .base is None = False  共享内存 = False   ⚠️
# a[[0,2]]           .base is None = True   共享内存 = False

前两个明明是拷贝,.base 却不是 None —— 因为求值过程中产生了一个中间临时数组, 拷贝结果挂在那个临时数组上,而那个临时数组和 a 无关。

.base 说明当前数组是否借用其他对象的缓冲区;它不直接回答“是否与指定的 a 共享内存”。对两个具体数组使用 np.shares_memory(a, b);复杂 stride 的精确检测可能很昂贵,可设置工作上限,保守判断则用 np.may_share_memory。参见 base 与 shares_memory 文档。

⭐ 稳妥的判据永远是这个:

import numpy as np

base = np.arange(12)
a = base.reshape(3, 4)

print(np.shares_memory(a, a.T))   # True   ⭐ 这个不会被中间层骗到

⚠️ np.shares_memory 默认做的是精确判断,对巨大数组可能偏慢; 赶时间可以用 np.may_share_memory(保守估计,可能误报「共享」但不会漏报)。

02 / 完整解释

新形状能否由 stride 表达?

🧩 四、C 序和 F 序:同一张表,两种铺法

同样一个 2×3 的表,在内存里可以按行铺,也可以按列铺:

import numpy as np

c = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int8)
f = np.asfortranarray(c)

print(np.array_equal(c, f))        # True   内容完全一样
print(c.strides, list(c.tobytes("A")))   # (3, 1) [1, 2, 3, 4, 5, 6]
print(f.strides, list(f.tobytes("A")))   # (1, 2) [1, 4, 2, 5, 3, 6]
strides 内存里的顺序 谁在用
C 序(行优先,NumPy 默认) (3, 1) 1 2 3 4 5 6 C、Python、PyTorch
F 序(列优先) (1, 2) 1 4 2 5 3 6 Fortran、MATLAB、R、BLAS 内部

⚠️ 用 dtype=np.int8 是为了让 tobytes 看得清。换成默认的 int64,每个数占 8 字节、前 7 个都是 0,你会看到一串没有区别的零 —— 这也是我第一次跑这个例子时踩的坑。

⭐ 你平时不需要关心序,除非:把数组交给某个 Fortran 血统的库(SciPy 的部分 LAPACK 封装),或者你发现某个操作莫名其妙慢了一截(见第六节)。


🧩 五、reshape 什么时候白拿,什么时候掏钱

先确认新形状的元素总数和原来相同,再检查指定的下标顺序能否用新的步长在原缓冲区读出。下面讲的是默认允许按需复制的 reshape。

  • 能 → 返回视图,原数据无需搬动。
  • 不能 → 复制数据,再按新形状返回。
import numpy as np

a = np.arange(12).reshape(3, 4)

r1 = a.reshape(4, 3)
print(np.shares_memory(a, r1))        # True   ⭐ 白拿

r2 = a.T.reshape(12)
print(a.T.flags["C_CONTIGUOUS"])      # False  转置之后不连续了
print(np.shares_memory(a, r2))        # False  ⚠️ 悄悄拷了一份

用同一张转置表试两种读取顺序。 默认 order="C" 让最后一轴先变。转置表开头取到 0, 4, 8, 1,在原缓冲区的字节偏移是 0, 32, 64, 8,相邻偏移差依次是 32, 32, −56,无法用一个一维步长表示。改用 order="F" 让第一轴先变,开头取到 0, 1, 2, 3,整张表按原缓冲区顺序每次走 8 字节,能返回一维视图。两次都得到 (12,),数值顺序不同。

以下用 NumPy 2.5 的 copy=False 明确要求不搬数据。若指定的顺序必须复制,reshape 会抛出 ValueError。NumPy 的 reshape 参数说明

import numpy as np

a = np.arange(12, dtype=np.int64).reshape(3, 4)
t = a.T  # (4, 3)
flat_c = np.reshape(t, 12, order="C")
flat_f = np.reshape(t, 12, order="F", copy=False)

print(flat_c[:4].tolist(), np.shares_memory(t, flat_c))  # [0, 4, 8, 1] False
print(flat_f[:4].tolist(), np.shares_memory(t, flat_f))  # [0, 1, 2, 3] True

try:
    np.reshape(t, 12, order="C", copy=False)
except ValueError:
    print("C 序需要复制")

下面保留旧写法以便识别已有代码。给 .shape 赋值会改变对象本身的形状,NumPy 已弃用这种赋值方式。NumPy 的 shape 属性说明

import numpy as np

a = np.arange(12).reshape(3, 4)

a.shape = (4, 3)        # ✅ 直接赋值 shape:不能零拷贝就抛 AttributeError
print(a.shape)          # (4, 3)

🧩 六、.contiguous() 到底在修什么

有些操作要求输入满足特定的内存布局。NumPy 的 np.ascontiguousarray 返回按 C 序连续的数组,适合接口明确要求这种布局时使用。PyTorch 的 .contiguous() 也用于请求连续布局,本节用 NumPy 演示。

import numpy as np

a = np.arange(12).reshape(3, 4)

try:
    a.T.view(np.int8)
except ValueError as e:
    print("ValueError:", e)
    # To change to a dtype of a different size, the last axis must be contiguous

b = np.ascontiguousarray(a.T)      # ⭐ 拷一份连续的
print(b.view(np.int8).shape)       # (4, 24)   ✅ 通了

这里把元素从 8 字节重新解释成 1 字节,需要最后一轴的元素紧邻排列。在这张转置表里最后一轴步长是 32 字节,条件不满足。a.view() 不传参数时会保持原 dtype 并返回视图。a.view(新 dtype) 则用新的类型解释原字节,元素字节数改变时才有这里的最后一轴要求。NumPy 的 view 说明

连续性、共享和复制怎样分别判断?

flags.c_contiguous 检查一个数组能否按 C 序连续读。np.shares_memory(a, x) 比较两份数组是否有字节重叠。是否复制还要问是哪一步操作,例如同一个 ascontiguousarray 调用在不同输入上就会走不同的路径。

比较倒序切片和两次连续化
操作C 连续与原表重叠这一步复制数据
对原表倒序切片否是否
把倒序视图转成 C 连续是否是
要求原表 C 连续是是否

先预测 packed 的第一行。连续化会把倒序视图的第一行 [3, 2, 1, 0] 依次放入新缓冲区,取值和视图相同,字节落点已经改变。直接把原表交给 ascontiguousarray,无需改布局或类型,本例会返回原对象。

import numpy as np

a = np.arange(12, dtype=np.int64).reshape(3, 4)
v = a[:, ::-1]
packed = np.ascontiguousarray(v)
same = np.ascontiguousarray(a)

for x in (v, packed, same):
    print(x.flags.c_contiguous, np.shares_memory(a, x))
# False True
# True False
# True True

print(np.array_equal(v, packed), same is a)  # True True

循环每次输出一对检查结果,顺序和上表一致。最后的 array_equal 比较取值,same is a 检查返回的是否为同一个对象。若需要独立数据,即使输入已经 C 连续,也应显式调用 .copy()。NumPy 的 ascontiguousarray 示例

📗 PyTorch 里 .contiguous() 的急救写法(什么时候要在 .transpose() 后面补一个) 在 ML 基础 · 附录C 手撕代码速查 里已经给了, 这一章只解释它为什么必须存在。

03 / 完整解释

把布局优势与安全边界分开。

🧩 七、连续性对速度的影响有多大

⚠️ 先说一个我自己踩的坑,因为它太容易得出错误结论:

❌ 这个对比是【无效】的:big.sum(axis=1) 对 big.T.sum(axis=0)。

这两句是同一次内存遍历 —— big.T 只换了说明书,axis 也跟着换了,走的字节顺序一模一样。 我第一版就是这么测的,结果「不连续」反而更快,因为测的根本不是连续性。

⭐ 公平的对比要拿同样的数据、同样的元素个数,只让内存布局不同:

import numpy as np, timeit

n = 4000
full = np.ones((n, n))
strided = full[:, ::2]                     # 隔列取,真正不连续
packed  = np.ascontiguousarray(strided)    # 同样的数据,连续存一份

print(strided.shape, strided.flags["C_CONTIGUOUS"])   # (4000, 2000) False
print(packed.shape,  packed.flags["C_CONTIGUOUS"])    # (4000, 2000) True

t_s = min(timeit.repeat(lambda: strided.sum(), number=3, repeat=5)) / 3
t_p = min(timeit.repeat(lambda: packed.sum(),  number=3, repeat=5)) / 3
print(f"不连续 {t_s*1000:.2f} ms   连续 {t_p*1000:.2f} ms   快 {t_s/t_p:.2f}x")

本机(numpy 2.4.6)实测:不连续 10.46 ms,连续 5.98 ms —— 快 1.75 倍,元素个数完全一样。

⚠️ 你的绝对数值会不同(取决于 CPU 缓存大小),但量级差异是结构性的: CPU 一次从内存搬的是一整条 cache line(通常 64 字节), 隔列取意味着搬进来的一半直接扔掉。

⭐ 什么时候值得先 ascontiguousarray 一下: 一个不连续的数组要被反复扫描很多次时,先花一次拷贝的钱把它压实,通常划算。 只用一次就不必了 —— 拷贝本身也要遍历一遍。

🧩 八、as_strided:直接手写说明书

既然形状只是说明书,那能不能自己编一份?能,而且这是滑动窗口的经典实现:

import numpy as np
from numpy.lib.stride_tricks import as_strided

v = np.arange(8)
w = as_strided(v, shape=(6, 3), strides=(v.strides[0], v.strides[0]))
print(v)
# [0 1 2 3 4 5 6 7]
print(w)
# [[0 1 2]
#  [1 2 3]
#  [2 3 4]
#  [3 4 5]
#  [4 5 6]
#  [5 6 7]]
print(np.shares_memory(v, w))   # True   ⭐ 零拷贝

6×3 = 18 个数字,背后只有 8 个元素。两个 strides 都等于 8 字节,意思是「行号 +1 和列号 +1 都只挪一格」—— 于是每行自然比上一行错开一位。

💀 但这是本章最危险的一个 API:as_strided 不做任何边界检查。 shape 写大一格,它就去读数组后面那块不属于你的内存 —— 不报错,读出垃圾数, 运气不好直接段错误。

⭐ 实际工作中请用 np.lib.stride_tricks.sliding_window_view,它做同样的事但有边界检查:

import numpy as np

v = np.arange(8)
w = np.lib.stride_tricks.sliding_window_view(v, 3)
print(w.shape)                  # (6, 3)
print(np.shares_memory(v, w))   # True

as_strided 值得知道,是因为它把「形状只是说明书」这件事演示到了极致 —— 但别在生产代码里用它。

04 / 完整解释

从内存布局回到函数边界。

🔗 这一章连到哪里

相关的地方 为什么
04 · 视图还是拷贝 那一章区分共享与独立数据,本章解释起点和步长怎样让两种读法重叠。
06 · 索引的四种形态 基础切片用步长读取原数据。整数数组与布尔高级索引的读取按索引规则返回副本,即使所选元素碰巧等距。
11 · 从 NumPy 到 PyTorch PyTorch 的张量是同一套说明书(storage + shape + stride + offset),.contiguous() 是同一件事
ML 基础 · 附录C 手撕代码速查 .contiguous() 的急救写法在那里:什么时候要在 .transpose() 后面补一个
框架底下是 C++ · 03 · cache 与数据布局 本章第七节那个 1.75 倍差在硬件上是怎么来的:cache line、预取、AoS/SoA

✅ 检查点

  1. a = np.arange(12).reshape(3, 4) 的 strides 是多少?单位是什么?
  2. 为什么 a.T 对一个巨大的矩阵也是瞬间返回?
  3. a[2, 1] 的字节偏移怎么算出来?算给我看。
  4. 对上面的 v = a[:, ::-1],v[0, 3] 相对视图起点和原表起点各偏移多少字节?值是多少?
  5. a.T.base is a 是 True 还是 False?为什么?那该用什么判断共享内存?
  6. C 序和 F 序存 [[1,2,3],[4,5,6]],内存里的字节顺序分别是什么?
  7. a.T.reshape(12) 会不会拷贝?怎么让「要拷贝就报错」而不是偷偷拷?
  8. a.T.view(np.int8) 报的错原文是什么?它抱怨的到底是哪件事?
  9. 拿 big.sum(axis=1) 和 big.T.sum(axis=0) 比较连续性的影响,错在哪?
  10. as_strided 为什么危险?该用什么替代?
👀 答案
  1. (32, 8),单位是字节。行 +1 挪 32 字节(4 个 int64 = 一整行),列 +1 挪 8 字节(1 个 int64)。
  2. 因为它一个字节都没搬,只是把 shape 和 strides 同时倒过来 —— (3,4)/(32,8) 变成 (4,3)/(8,32)。干活的是后面真正读数据的那一步。
  3. 2 * 32 + 1 * 8 = 72 字节,72 // 8 = 9,从 0 数的第 9 格,a.ravel()[9] == 9。
  4. 相对视图起点是 0 × 32 + 3 × (−8) = −24 字节。视图起点原本在原表起点之后 24 字节,所以相对原表偏移是 24 − 24 = 0 字节,值为 a[0, 0] = 0。
  5. False。.base 不是「上一层」,在本例中跳过中间视图、指向原始数组 —— a.T.base is base 才是 True(base 是原始的 arange(12))。判断共享内存要用 np.shares_memory(a, a.T),它不会被中间层骗到。
  6. C 序 [1, 2, 3, 4, 5, 6](按行铺),F 序 [1, 4, 2, 5, 3, 6](按列铺)。strides 分别是 (3,1) 和 (1,2)。⚠️ 要用 dtype=np.int8 才看得出来,int64 前 7 个字节全是 0。
  7. 本例默认按 C 序读转置表,原数据的读取位置无法用单个步长表示,所以会复制。按 F 序读可以返回视图,但结果顺序不同。对需要复制的 C 序写法指定 copy=False,就会得到 ValueError。
  8. To change to a dtype of a different size, the last axis must be contiguous。改变每个元素的字节数时,view 要求最后一轴的元素相邻,本例的转置表在这根轴上有间隔。
  9. 错在那两句是同一次内存遍历:big.T 只换了说明书、axis 也跟着换了,走过的字节顺序一模一样,测的根本不是连续性。公平做法是同样的数据、同样的元素个数,只让布局不同(full[:, ::2] vs np.ascontiguousarray(...)),实测 10.46 ms vs 5.98 ms,快 1.75 倍。
  10. 因为它不做任何边界检查 —— shape 写大一格就会去读不属于你的内存,不报错、读出垃圾数,运气不好直接段错误。生产代码用 np.lib.stride_tricks.sliding_window_view,同样零拷贝但有边界检查。

本节回顾

⚡ 走神救援

⭐ 找格子时,先选对起点,再加上每个下标乘对应步长。 倒序切片会把逻辑起点换到原来的末端,相应步长变成负数。

np.arange(12).reshape(3, 4) 的 strides 是 (32, 8),单位是字节:行号 +1 挪 32 字节(一整行),列号 +1 挪 8 字节(一个元素)。任意下标一次乘加就出地址 —— a[2,1] = 2*32 + 1*8 = 72 字节 = 第 9 个元素。这就是索引 O(1) 的全部秘密。转置因此是免费的:a.T 只把 shape 和 strides 同时倒过来,一个字节都没搬。

⚠️ 判断共不共享内存永远用 np.shares_memory,别用 .base —— 它两个方向都骗人:a.T.base is a 是 False(本例跳过了中间视图);而 a.T.reshape(12) 明明是拷贝,.base 却不是 None(挂在中间临时数组上)。

二维表的 C 序先变列号,F 序先变行号。先确定读取顺序,再判断 reshape 能否沿用原缓冲区。想让必须复制的重塑报错,可用 np.reshape(..., copy=False)。连续性看 flags,两份数组的字节重叠看 np.shares_memory。

连续性的真实代价实测 1.75 倍(4000×2000,不连续 10.46 ms vs 连续 5.98 ms)—— CPU 一次搬一整条 cache line,隔列取等于搬进来一半就扔。as_strided 能手写说明书做出零拷贝滑动窗口,但它不做边界检查,生产代码用 sliding_window_view。

下一节 👉 06-索引的四种形态.md

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

如果一种索引根本无法用固定 stride 表达,NumPy 会怎样把元素交给你?