Python 使用行索引为numpy数组赋值

假设我有两个数组，

a=np.array（[0,0,1,1,1,2]），b=np.array（[1,2,4,2,6,5]）

。

a

中的元素表示应分配

b

的行索引。如果同一行中有多个元素，则应按顺序分配值。 因此，结果是一个2D数组

c

：

c = np.zeros((3, 4))
counts = {k:0 for k in range(3)}
for i in range(a.shape[0]):
    c[a[i], counts[a[i]]]=b[i]
    counts[a[i]]+=1
print(c)

In [265]: c = np.zeros((3,4),int)                                                                      
In [266]: c[mask] = b                                                                                  
In [267]: c                                                                                            
Out[267]: 
array([[1, 2, 0, 0],
       [4, 2, 6, 0],
       [5, 0, 0, 0]])

---

有没有一种方法可以在numpy中使用一些奇特的索引方法，以便在这些数组很大的情况下更快地获得这样的结果（没有for循环）。

我必须运行您的代码才能真正看到它产生了什么。我能在头脑中“奔跑”的东西是有限的

In [230]: c                                                                                            
Out[230]: 
array([[1., 2., 0., 0.],
       [4., 2., 6., 0.],
       [5., 0., 0., 0.]])
In [231]: counts                                                                                       
Out[231]: {0: 2, 1: 3, 2: 1}

省略这些信息可能会推迟可能的答案。”“矢量化”需要从整个数组的角度进行思考，如果我能可视化结果并寻找模式，这是最容易的

这看起来像是一个

填充问题。

根据前面的填充问题，我可以构建一个掩码：

In [263]: mask = np.arange(4)<c[:,None]                                                                
In [264]: mask                                                                                         
Out[264]: 
array([[ True,  True, False, False],
       [ True,  True,  True, False],
       [ True, False, False, False]])

由于
a
已经排序，我们可能会比使用
unique
更快地获得计数。如果
a
对某些行没有任何值，它也会有问题。
我必须运行你的代码才能真正看到它产生了什么。我能在头脑中“奔跑”的东西是有限的

In [230]: c                                                                                            
Out[230]: 
array([[1., 2., 0., 0.],
       [4., 2., 6., 0.],
       [5., 0., 0., 0.]])
In [231]: counts                                                                                       
Out[231]: {0: 2, 1: 3, 2: 1}

省略这些信息可能会推迟可能的答案。”“矢量化”需要从整个数组的角度进行思考，如果我能可视化结果并寻找模式，这是最容易的

这看起来像是一个
填充问题。

根据前面的填充问题，我可以构建一个掩码：

In [263]: mask = np.arange(4)<c[:,None]                                                                
In [264]: mask                                                                                         
Out[264]: 
array([[ True,  True, False, False],
       [ True,  True,  True, False],
       [ True, False, False, False]])

由于
a
已经排序，我们可能会比使用
unique
更快地获得计数。如果
a
没有某些行的任何值，它也会有问题。
谢谢。是的，这是一个填充问题。如果一行没有任何值，一种解决方法是使用
d=np.zeros（3），d[u]=c，mask=np.arange（4）谢谢。是的，这是一个填充问题。如果一行没有任何值，一种解决方法是使用
d=np.zeros（3），d[u]=c，mask=np.arange（4）