Question

我有一个大的一维整数数组，我需要取下切片。那是微不足道的，我只会做a[start:end]。问题是我需要更多这些切片。如果start和end是数组，则a[start:end]不起作用。 For循环可以用于此，但我需要它尽可能快（这是一个瓶颈），所以欢迎本地的numpy解决方案。

为了进一步说明，我有这个：

a = numpy.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], numpy.int16)
start = numpy.array([1, 5, 7], numpy.int16)
end   = numpy.array([2, 10, 9], numpy.int16)

需要以某种方式进入这个：

[[1], [5, 6, 7, 8, 9], [7, 8]]

Answer 1

这可以（几乎？）使用蒙版数组和步长技巧在纯numpy中完成。首先，我们创建我们的面具：

>>> indices = numpy.arange(a.size)
>>> mask = ~((indices >= start[:,None]) & (indices < end[:,None]))

或更简单：

>>> mask = (indices < start[:,None]) | (indices >= end[:,None])

对于那些False到起始值和>=结束值的索引，掩码是<（即未屏蔽的值）。（使用None（又名numpy.newaxis）进行切片会添加一个新维度，从而启用广播。）现在我们的掩码看起来像这样：

>>> mask
array([[ True, False,  True,  True,  True,  True,  True,  True,  True,
         True,  True,  True],
       [ True,  True,  True,  True,  True, False, False, False, False,
        False,  True,  True],
       [ True,  True,  True,  True,  True,  True,  True, False, False,
         True,  True,  True]], dtype=bool)

现在我们必须使用stride_tricks拉伸数组以适合蒙版：

>>> as_strided = numpy.lib.stride_tricks.as_strided
>>> strided = as_strided(a, mask.shape, (0, a.strides[0]))
>>> strided
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],
       [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],
       [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11]], dtype=int16)

这看起来像一个3x12阵列，但每一行都指向同一个内存。现在我们可以将它们组合成一个蒙版数组：

>>> numpy.ma.array(strided, mask=mask)
masked_array(data =
 [[-- 1 -- -- -- -- -- -- -- -- -- --]
 [-- -- -- -- -- 5 6 7 8 9 -- --]
 [-- -- -- -- -- -- -- 7 8 -- -- --]],
             mask =
 [[ True False  True  True  True  True  True  True  True  True  True  True]
 [ True  True  True  True  True False False False False False  True  True]
 [ True  True  True  True  True  True  True False False  True  True  True]],
       fill_value = 999999)

这与你要求的不完全相同，但它应该表现得相似。

Answer 2

没有多余的方法可以做到这一点。请注意，由于它是不规则的，所以它只是一个数组/切片列表。但是我想为所有（二进制）ufuncs添加几乎所有函数都在numpy中（或者它们至少基于它们），有reduceat方法，这可能会帮助你避免实际创建切片列表，因此，如果切片很小，也会加快计算速度：

In [1]: a = np.arange(10)

In [2]: np.add.reduceat(a, [0,4,7]) # add up 0:4, 4:7 and 7:end
Out[2]: array([ 6, 15, 24])

In [3]: np.maximum.reduceat(a, [0,4,7]) # maximum of each of those slices
Out[3]: array([3, 6, 9])

In [4]: w = np.asarray([0,4,7,10]) # 10 for the total length

In [5]: np.add.reduceat(a, w[:-1]).astype(float)/np.diff(w) # equivalent to mean
Out[5]: array([ 1.5,  5. ,  8. ])

编辑：由于你的切片重叠，我会补充说这也没关系：

# I assume that start is sorted for performance reasons.
reductions = np.column_stack((start, end)).ravel()
sums = np.add.reduceat(a, reductions)[::2]

[::2]通常没什么大不了的，因为重叠切片没有真正的额外工作。

此处还有一个问题是片stop==len(a)。必须避免这种情况。如果您只有一个切片，则可以reductions = reductions[:-1]（如果是最后一个切片），但除此之外，您只需要将值附加到a以欺骗reduceat：

 a = np.concatenate((a, [0]))

因为在最后添加一个值并不重要，因为无论如何都要处理切片。

Answer 3

这不是一个“纯粹的”numpy解决方案（尽管@ mgilson的评论指出，很难看出不规则输出如何成为一个numpy数组），但是：

a = numpy.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], numpy.int16)
start = numpy.array([1, 5, 7], numpy.int16)
end   = numpy.array([2, 10, 9], numpy.int16)

map(lambda range: a[range[0]:range[1]],zip(start,end))

得到你：

[array([1], dtype=int16), array([5, 6, 7, 8, 9], dtype=int16),  array([7, 8], dtype=int16)]

根据需要。

Answer 4

类似于timday的解决方案。类似的速度：

a = np.random.randint(0,20,1e6)
start = np.random.randint(0,20,1e4)
end = np.random.randint(0,20,1e4)

def my_fun(arr,start,end):
        return arr[start:end]

%timeit [my_fun(a,i[0],i[1]) for i in zip(start,end)]
%timeit map(lambda range: a[range[0]:range[1]],zip(start,end))

100 loops, best of 3: 7.06 ms per loop 100 loops, best of 3: 6.87 ms per loop

Answer 5

如果你想把它放在一行，那就是：

x=[list(a[s:e]) for (s,e) in zip(start,end)]

用另一个数组切片numpy数组

5 个答案: