Python np.append不适用于numpy.ndarray类型的字典值

我有一个函数，给定两个numpy数组，将它们转换成一个dictionary，如下所示

def seggregate_based_on_y(X,y):
    dictionary={}
    for index in range(len(y)):
        if y[index] in dictionary.keys():
            np.append(dictionary[y[index]],X[index])
        else:
            dictionary[y[index]]=np.array([X[index]])
    return dictionary

对于以下输入

X=np.array([[1,1],[2,2],[3,3],[4,4],[5,5]])
y=np.array([2,3,2,3,4])
d=seggregate_based_on_y(X,y)
print(d)

---

我希望'd'是

{2:array（[[1,1]，[3,3]]），3:array（[[2,2]，[4,4]]），4:array（[[5,5]]）}

但我得到的'd'是

{2:array（[[1,1]]），3:array（[[2,2]]），4:array（[[5,5]]）}

这是if语句不起作用。应该怎么做？

您可以使用内置功能

zip

：

def seggregate_based_on_y(X,y):
    d = {}
    for k, v in zip(y, X):
        if k in d:
            d[k] = np.append(d[k], v.reshape(1, 2), axis=0)
        else:
            d[k] = v.reshape(1, 2)

    return d


X=np.array([[1,1],[2,2],[3,3],[4,4],[5,5]])
y=np.array([2,3,2,3,4])
print(seggregate_based_on_y(X,y))

输出：

{2: array([[1, 1],
        [3, 3]]), 3: array([[2, 2],
        [4, 4]]), 4: array([[5, 5]])}

---

您可以使用内置功能

zip

：

def seggregate_based_on_y(X,y):
    d = {}
    for k, v in zip(y, X):
        if k in d:
            d[k] = np.append(d[k], v.reshape(1, 2), axis=0)
        else:
            d[k] = v.reshape(1, 2)

    return d


X=np.array([[1,1],[2,2],[3,3],[4,4],[5,5]])
y=np.array([2,3,2,3,4])
print(seggregate_based_on_y(X,y))

输出：

{2: array([[1, 1],
        [3, 3]]), 3: array([[2, 2],
        [4, 4]]), 4: array([[5, 5]])}

试试这个

将numpy导入为np
基于y（X，y）的def seggregate_：
字典={}
对于范围（len（y））中的索引：
如果dictionary.keys（）中的y[index]：
z=np.append（字典[y[index]]，X[index]）
字典[y[索引]]=z.重塑（z.size//2,2）
其他：
字典[y[索引]]=np.array（[X[索引]]）
返回字典
X=np.数组（[[1,1]，[2,2]，[3,3]，[4,4]，[5,5]）
y=np.数组（[2,3,2,3,4]）
d=基于y（X，y）的分段
印刷品（d）

输出：

{2: array([[1, 1],[3, 3]]), 3: array([[2, 2],[4, 4]]), 4: array([[5, 5]])}

试试这个

将numpy导入为np
基于y（X，y）的def seggregate_：
字典={}
对于范围（len（y））中的索引：
如果dictionary.keys（）中的y[index]：
z=np.append（字典[y[index]]，X[index]）
字典[y[索引]]=z.重塑（z.size//2,2）
其他：
字典[y[索引]]=np.array（[X[索引]]）
返回字典
X=np.数组（[[1,1]，[2,2]，[3,3]，[4,4]，[5,5]）
y=np.数组（[2,3,2,3,4]）
d=基于y（X，y）的分段
印刷品（d）

输出：

{2: array([[1, 1],[3, 3]]), 3: array([[2, 2],[4, 4]]), 4: array([[5, 5]])}

---

首先，正如评论所说，您必须为字典分配新值。请参阅以下修复程序：

def seggregate_based_on_y(X,y):
    dictionary={}
    for index in range(len(y)):
        if y[index] in dictionary.keys():
            dictionary[y[index]] = np.append(dictionary[y[index]],X[index])
        else:
            dictionary[y[index]]=np.array([X[index]])
    return dictionary

根据给定的数据输出：

{2: array([1, 1, 3, 3]), 3: array([2, 2, 4, 4]), 4: array([[5, 5]])}

这与您预期的结果不同，因为

np.append

将附加到同一个向量。要获得所需的输出，请使用

np.vstack

def seggregate_based_on_y(X,y):
    dictionary={}
    for index in range(len(y)):
        if y[index] in dictionary.keys():
            dictionary[y[index]] = np.vstack((dictionary[y[index]],X[index]))
        else:
            dictionary[y[index]]=np.array([X[index]])
    return dictionary

这里的输出是：

{2: array([[1, 1],
       [3, 3]]), 3: array([[2, 2],
       [4, 4]]), 4: array([[5, 5]])}

---

我希望这会有所帮助。

首先，正如评论所说，您必须为词典分配新值。请参阅以下修复程序：

def seggregate_based_on_y(X,y):
    dictionary={}
    for index in range(len(y)):
        if y[index] in dictionary.keys():
            dictionary[y[index]] = np.append(dictionary[y[index]],X[index])
        else:
            dictionary[y[index]]=np.array([X[index]])
    return dictionary

根据给定的数据输出：

{2: array([1, 1, 3, 3]), 3: array([2, 2, 4, 4]), 4: array([[5, 5]])}

这与您预期的结果不同，因为

np.append

将附加到同一个向量。要获得所需的输出，请使用

np.vstack

def seggregate_based_on_y(X,y):
    dictionary={}
    for index in range(len(y)):
        if y[index] in dictionary.keys():
            dictionary[y[index]] = np.vstack((dictionary[y[index]],X[index]))
        else:
            dictionary[y[index]]=np.array([X[index]])
    return dictionary

这里的输出是：

{2: array([[1, 1],
       [3, 3]]), 3: array([[2, 2],
       [4, 4]]), 4: array([[5, 5]])}

---

我希望这能有所帮助。

defaultdict

这样的收集很容易：

In [268]: from collections import defaultdict                                                          
In [269]: x = [[1,1],[2,2],[3,3],[4,4],[5,5]]                                                          
In [270]: y = [2,3,2,3,4]                                                                              
In [271]: dd = defaultdict(list)                                                                       
In [272]: for i,j in zip(y, x): 
     ...:     dd[i].append(j) 
     ...:                                                                                              
In [273]: dd                                                                                           
Out[273]: defaultdict(list, {2: [[1, 1], [3, 3]], 3: [[2, 2], [4, 4]], 4: [[5, 5]]})

如果结果必须是数组而不是列表，则可以使用以下方法进行转换：

In [274]: d = {k: np.array(dd[k]) for k in dd}                                                         
In [275]: d                                                                                            
Out[275]: 
{2: array([[1, 1],
        [3, 3]]), 3: array([[2, 2],
        [4, 4]]), 4: array([[5, 5]])}

列表附加比

np.append

（或任何

numpy

串联

函数系列）更快。列表追加操作到位

defaultdict

可以直接构建一个数组（但我希望这会更慢）：

[280]中的

dd=defaultdict（lambda:np.zeros（（0,2），int））
在[281]中：对于i，j在zip（y，x）中：
…：dd[i]=np.vstack（（dd[i]，j））
...:                                                                                              
In[282]：dd
出[282]：
defaultdict（，{2:array（[[1,1]，
[3,3]]），3:array（[[2,2]]，
[4,4]]），4:array（[[5,5]]）}）

defaultdict

这类收集很容易：

In [268]: from collections import defaultdict                                                          
In [269]: x = [[1,1],[2,2],[3,3],[4,4],[5,5]]                                                          
In [270]: y = [2,3,2,3,4]                                                                              
In [271]: dd = defaultdict(list)                                                                       
In [272]: for i,j in zip(y, x): 
     ...:     dd[i].append(j) 
     ...:                                                                                              
In [273]: dd                                                                                           
Out[273]: defaultdict(list, {2: [[1, 1], [3, 3]], 3: [[2, 2], [4, 4]], 4: [[5, 5]]})

如果结果必须是数组而不是列表，则可以使用以下方法进行转换：

In [274]: d = {k: np.array(dd[k]) for k in dd}                                                         
In [275]: d                                                                                            
Out[275]: 
{2: array([[1, 1],
        [3, 3]]), 3: array([[2, 2],
        [4, 4]]), 4: array([[5, 5]])}

列表附加比

np.append

（或任何

numpy

串联

函数系列）更快。列表追加操作到位

defaultdict

可以直接构建一个数组（但我希望这会更慢）：

[280]中的

dd=defaultdict（lambda:np.zeros（（0,2），int））
在[281]中：对于i，j在zip（y，x）中：
…：dd[i]=np.vstack（（dd[i]，j））
...:                                                                                              
In[282]：dd
出[282]：
defaultdict（，{2:array（[[1,1]，
[3,3]]），3:array（[[2,2]]，
[4,4]]），4:array（[[5,5]]）}）

请参见

append（）

返回数组的一个副本，但它不在适当的位置。@MarkMeyer感谢您指出，我不知道这一点。但是问题仍然存在，你知道我是否有任何方法可以得到上面的结果吗？参见

append（）

返回数组的副本，但它不在适当的位置。@MarkMeyer谢谢你指出，我不知道。但问题仍然存在，你知道有没有什么方法可以让我达到预期的效果