Skip to main content
 首页 » 编程设计

python之按 "kind"计算值并使用该计数更新 DataFrame 中的值的更快方法

2024年11月24日13tintown

我正在尝试在脚本中实现一个步骤,在该脚本中,我在每一行中查找存储在同一 DataFrame 中的值的“种类”,并更新每行有多少个值的计数每一种”。为了说明这一点,这里有一个玩具示例:

d = {0: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 
 1: [1, 1, 2, 2, 1, 1, 2, 1, 1, 2], 
 2: [1, 1, 2, 2, 1, 1, 1, 1, 2, 2], 
 3: [2, 1, 8, 3, 6, 5, 10, 3, 4, 7], 
 4: [0, 0, 4, 9, 0, 0, 0, 0, 10, 9], 
 5: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
 6: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]} 
 
df = pd.DataFrame(d) 
df.index += 1 

在df中,df[0]包含一个对象的唯一ID,df[1],包含“种类”(这可能就像物体的颜色)。 df[3] 和 df[4] 包含感兴趣的相邻对象(0 是占位符值,任何非零值都是相邻对象的 ID,所以这里我们有 1 个或 2 个相邻对象)。 df[5] 和df[6] 用于存储每种类型的对象数量。这里只有两种类型,它们是 int,因此类型 1 的相邻对象的计数进入 df[5],类型 2 的相邻对象进入 df[6]。

我有工作代码迭代行和相邻的对象列,查找类型,然后递增适当的列。然而,这并不能很好地扩展,而且我的实际数据集有更多的行和对象类型,而且这个操作作为蒙特卡洛类型模拟的一部分被重复调用。我不确定在这里可以做些什么来加快它的速度,我只是尝试了 ID:Type 的字典查找,但实际上速度较慢。这是功能代码:

def countNeighbors(contactMap): #in case of subgraph, still need to know the neighbors type 
    for index, row in contactMap.iterrows(): 
        for col in range(3,4): 
            cellID = row[col] 
            if cellID == 0: 
                pass 
            else: 
                cellType = int(contactMap[contactMap[0] == cellID][1]) 
                contactMap.at[index, 4+cellType] += 1 
    return contactMap 
 
df = countNeighbors(df) 

预期输出:

output = {0: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 1: [1, 1, 2, 2, 1, 1, 2, 1, 1, 2], 2: [1, 1, 2, 2, 1, 1, 1, 1, 2, 2], 3: [2, 1, 8, 3, 6, 5, 10, 3, 4, 7], 4: [0, 0, 4, 9, 0, 0, 0, 0, 10, 9], 5: [1, 1, 1, 0, 1, 1, 0, 0, 0, 0], 6: [0, 0, 0, 1, 0, 0, 1, 1, 1, 1]} 
 
out_df = pd.DataFrame(output) 
out_ df.index += 1 

明确地说,此输出意味着对象 1(第 1 行)属于类型 1,具有 1 个相邻对象,即对象 2。我们在 df 中查找对象 2 并看到它是类型 1,因此增加 col 5。 有没有更快的方法来达到同样的效果?如果需要,我愿意重新设计数据结构,但这种格式很方便。

请您参考如下方法:

选项 1:

type_dict = df.set_index(0)[1].to_dict() 
 
for i in [3,4]: 
    s = df[i].map(type_dict) 
    df.loc[:,[5,6]] += pd.get_dummies(s)[[1,2]].values 

选项 2:

df.loc[:,[5,6]] = (pd.get_dummies(df[[3,4]] 
                     .stack().map(type_dict)) 
                     .sum(level=0) 
                  ) 

输出:

    0   1   2   3   4   5   6 
1   1   1   1   2   0   1   0 
2   2   1   1   1   0   1   0 
3   3   2   2   8   4   1   1 
4   4   2   2   3   9   1   1 
5   5   1   1   6   0   1   0 
6   6   1   1   5   0   1   0 
7   7   2   1   10  0   0   1 
8   8   1   1   3   0   0   1 
9   9   1   2   4   10  0   2 
10  10  2   2   7   9   1   1