Python 索引数组中重复项的Numpy和

给定numpy ndarray

A

和一个相同形状的整数数组

I

，具有最大值

imax

和一个数组

B=np.zeros（imax）

我们可以做

B[I]=A

。但是，如果

I

有重复的条目，则最后一次分配保持不变。我需要这样做，同时对重复的条目求和，比如

For i in range(A.size):
    B[I.ravel()[i]] += A.ravel()[i]

在

numpy

中有什么好方法可以做到这一点吗

例如，我想要这种行为（但是

=

和

+=

都不是这样工作的）

这里我们在第一个条目中看到

1+9=10

In [1]: A = np.array((1,2,5,9)) 
   ...: I = np.array((0,1,2,0),dtype=int) 
   ...: B = np.zeros(3) 
   ...: B[I] += A                                                                                                          
In [2]: B                                                                                                                  
Out[2]: array([9., 2., 5.])

这是一个缓冲解决方案，不同于迭代解决方案：

In [3]: B = np.zeros(3)                                                                                                    
In [4]: for i,a in zip(I,A): 
   ...:     B[i] += a 
   ...:                                                                                                                    
In [5]: B                                                                                                                  
Out[5]: array([10.,  2.,  5.])

使用

ufunc.at

的非缓冲溶液：

In [6]: B = np.zeros(3)                                                                                                    
In [7]: np.add.at(B, I, A)                                                                                                 
In [8]: B                                                                                                                  
Out[8]: array([10.,  2.,  5.])

这是一个缓冲解决方案，不同于迭代解决方案：

In [3]: B = np.zeros(3)                                                                                                    
In [4]: for i,a in zip(I,A): 
   ...:     B[i] += a 
   ...:                                                                                                                    
In [5]: B                                                                                                                  
Out[5]: array([10.,  2.,  5.])

使用

ufunc.at

的非缓冲溶液：

In [6]: B = np.zeros(3)                                                                                                    
In [7]: np.add.at(B, I, A)                                                                                                 
In [8]: B                                                                                                                  
Out[8]: array([10.,  2.,  5.])

---

如果您提供了一个数据示例来说明问题，您的问题会变得更清楚（并且更容易正确回答）。

add.at

提供了一个无缓冲的添加，以便在您有索引时使用duplicates@Grismar我加了一个例子@这就是答案，非常感谢！如果你想让它成为一个答案，我会接受。如果你提供一个数据示例来说明问题，你的问题会变得更清楚（并且更容易正确回答）。

add.at

提供了一个无缓冲的添加，以便在你有索引时使用duplicates@Grismar我加了一个例子@这就是答案，非常感谢！如果你想回答，我会接受的。