这里有一个方法：

import numpy as np
A = np.array([0, 0, 1, 2, 3, 0, 0, 4, 5, 0, 0, 0, 0, 1, 0, 6, 0, 7, 8,
              9, 0, 0, 0, 8, 10, 0])
N = 2
K = 0
b = np.tile(A,N+1)[:N*(A.size+1)].reshape((N,A.size+1)).T
c = np.where(np.all(b[:A.size-N+1]==[K]*N,axis=1))[0]
c = np.concatenate(([-N],c,[A.size]))
d = np.stack((c[:-1]+N,c[1:]-1)).T
e = d[d[:,0]<=d[:,1]]
print(e)
[[ 2  4]
 [ 7  8]
 [13 19]
 [23 25]]   # last zero included (doesn't form a [0,0])

字符串

• b创建一个2D矩阵，其中每行对应于长度为N的值的滚动子范围。
• c查找与K重复N次模式匹配的行的索引。这给出了[0，0]子范围的起始位置。添加表示数组开始和结束的索引以完成边缘范围。
• d将每个起始位置与下一个起始位置组合以形成索引范围。开始索引增加N以获得第一个非K值，并且接下来的开始减少1以获得组中最后一个项目的索引。
• e消除了由多于N个连续K值的序列引起的“空”范围。

根据下面的注解，可以通过更改前两行来利用as_strided或sliding_window_view（* 我只能测试as_strided*）来获得更好的性能：

b = np.lib.stride_tricks.as_strided(A,   shape=(len(A)-N+1,N),
                                       strides=A.strides*2)
c = np.where(np.all(b==[K]*N,axis=1))[0]

型
中间值：

# b[:A.size-N+1] : rolling subranges of length N
array([[ 0,  0],
       [ 0,  1],
       [ 1,  2],
       [ 2,  3],
       [ 3,  0],
       [ 0,  0],
       [ 0,  4],
       [ 4,  5],
       [ 5,  0],
       [ 0,  0],
       [ 0,  0],
       [ 0,  0],
       [ 0,  1],
       [ 1,  0],
       [ 0,  6],
       [ 6,  0],
       [ 0,  7],
       [ 7,  8],
       [ 8,  9],
       [ 9,  0],
       [ 0,  0],
       [ 0,  0],
       [ 0,  8],
       [ 8, 10],
       [10,  0]])

型
...

# c : starting index of [K]*N patterns (and edges)
array([-2,  0,  5,  9, 10, 11, 20, 21, 25, 26])

型
...

# d : subranges between [K]*N patterns (including empties)
array([[ 0, -1],
       [ 2,  4],
       [ 7,  8],
       [11,  9],
       [12, 10],
       [13, 19],
       [22, 20],
       [23, 25]])

型