Python numpy的逆求和

A是（（d，e））numpy数组。我计算（（d，e））numpy数组B，其中我计算条目B[I，j]，如下所示

b=0
for k in range(i+1,d):
    for l in range(j+1,e):
        b=b+A[k,l]
B[i,j]=b

---

换句话说，B[i，j]是A[k，l]在所有指数k>i，l>j上的总和；这和通常应用于两个轴的总和有点相反。我想知道是否有一种更优雅、更快的方法（例如使用np.cumsum）？

假设您正在尝试这样做：

A = np.arange(15).reshape((5, -1))

def cumsum2_reverse(arr):
    out = np.empty_like(arr)
    d, e = arr.shape
    for i in xrange(d):
        for j in xrange(e):
            b = 0
            for k in xrange(i + 1, d):
                for l in xrange(j + 1, e):
                    b += arr[k, l]
            out[i, j] = b
    return out

如果你这样做了

In [1]: A_revsum = cumsum2_reverse(A)

In [2]: A_revsum
Out[2]: 
array([[72, 38,  0],
      [63, 33,  0],
      [48, 25,  0],
      [27, 14,  0],
      [ 0,  0,  0]])

您可以对逆序数组使用

np.cumsum

来计算和。例如，首先您可能会尝试类似于@Jaime建议的方法：

In [3]: np.cumsum(np.cumsum(A[::-1, ::-1], 0), 1)[::-1, ::-1]
Out[3]:
array([[105,  75,  40],
       [102,  72,  38],
       [ 90,  63,  33],
       [ 69,  48,  25],
       [ 39,  27,  14]])

这里我们记住，

np.cumsum

以第一列（在本例中为最后一列）中的值开始，因此为了确保那里为零，您可以移动此操作的输出。这可能看起来像：

def cumsum2_reverse_alt(arr):
    out = np.zeros_like(arr)
    out[:-1, :-1] = np.cumsum(np.cumsum(arr[:0:-1, :0:-1], 0), 1)[::-1, ::-1]
    return out

这将给出与上述相同的值

In [4]: (cumsum2_reverse(A) == cumsum2_reverse_alt(A)).all()
Out[4]: True

注意，对于大型阵列，使用

np.cumsum

的方法要快得多。例如：

In [5]: A=np.arange(3000).reshape((50, -1))

In [6]: %timeit cumsum2_reverse(A)
1 loops, best of 3: 453 ms per loop

In [7]: %timeit cumsum2_reverse_alt(A)
10000 loops, best of 3: 24.7 us per loop

---

你能举一个实际数据和预期结果的小例子吗？！您还可以添加“python”标记。类似于

np.cumsum（np.cumsum（A[：-1，：]，axis=0）[：：-1，：：-1]，axis=1）[：，：：：-1]

的东西可能会让您达到99%的效果……谢谢，这很有效！我认为另一种选择是使用np.rot90（A，2），然后对两个轴应用cumsum，尽管我还没有将其与您的解决方案进行基准测试。