Question

我正在寻找对来自数据帧的大量数据进行分块的方法。为此，我需要为字典定义一个动态名称。

我想做类似的事情：

dict_{}.format(VARIABLE_NAME) = {}

上面显示的是非法操作。每当我需要创建一个新的词典名称时，该如何去定义？这是在for循环中发生的，因此我需要使用动态dict名称。让我知道我是否还需要提供其他东西。

这是数据框的一个片段

   REFERENCE_CODE                                        TRANSLATION
0      ladder_now                                                NaN
1               0                                              xyzwu
2               1                                              yxzuv
3               2                                            asdfasd
4               3                                             sdfsdh
5               4                                             hghffg
6               5                                            agfdhsj
7               6                                            dfgasgf
8               7                                             jfhkgj
9               8                                           djfgjfhk
10              9                                            dsfasys
11             10                                            kghkfdy
12             98                                          dsfhsuert
13             99                                           wsdfadjs
14  country_satis  Sa pangkagab’san, aoogma po ba kamo o dai naoo...
15              1                                            Naoogma
16              2                                        Dai naoogma
17              8                           Dai aram (HUWAG BASAHIN)
18              9                           Huminabo (HUWAG BASAHIN)
19            NaN                                                NaN

我正在尝试获取大块数据，例如，获取ladder_now和与之相关的所有值，然后找到country_satis并获取这些值，然后将它们放在单独的字典中。这是我的逻辑..只是缺少动态创建的字典：

for index, row in df.iterrows():
    j = 0
    if isinstance(row['REFERENCE_CODE'], str):
        if j == 0:
            # fix dynamically changing dict here
            trend_dict = {}
            trend_dict[row['REFERENCE_CODE']] = row['TRANSLATION']
        else:
            j = 0
            # create new dynamically named dictionary
            next_dict = {}
            next_dict[row['REFERENCE_CODE']] = row['TRANSLATION']
    else:
        trend_dict[row['REFERENCE_CODE']] = row['TRANSLATION']
        j += 1

因此，从本质上讲，我想将dict_ladder_now作为一个字典，包含它下面所有内容的所有键，值对，直到到达country_satis，然后再将dict_country_satis作为另一个字典。

Answer 1

与其尝试快速生成动态数量的变量名，不如选择使用其他更高级别的数据结构来存储对象，例如字典或列表。

import pandas as pd
REFERENCE_CODE = ["ladder_now", 0, 1, 5, 15, "country_satis", 20, 50, 100, "test3", 10, 50, 90]
TRANSLATION = list(range(len(REFERENCE_CODE)))
df = pd.DataFrame({"REFERENCE_CODE": REFERENCE_CODE,
                   "TRANSLATION": TRANSLATION
                   })
print(df)
#Output: Dummy data prepared for reference
   REFERENCE_CODE  TRANSLATION
0      ladder_now            0
1               0            1
2               1            2
3               5            3
4              15            4
5   country_satis            5
6              20            6
7              50            7
8             100            8
9           test3            9
10             10           10
11             50           11
12             90           12

使用列表：使用列表以及原始问题中编写的逻辑

result = [] #container list that grows dynamically
for index, row in df.iterrows():
    j = 0
    if isinstance(row['REFERENCE_CODE'], str):
        if j == 0:
            # fix dynamically changing dict here
            result.append({}) #new dictionary in container
            result[-1][row['REFERENCE_CODE']] = row['TRANSLATION']
        else:
            j = 0
            # create new dynamically named dictionary
            result.append({}) #new dictionary in container
            result[-1][row['REFERENCE_CODE']] = row['TRANSLATION']
    else:
        result[-1][row['REFERENCE_CODE']] = row['TRANSLATION']
        j += 1

请注意，逻辑的编写方式可以简化为以下内容。没有使用j变量，几乎在每个块中都写入了同一行代码。最终结果是这样的：

result = []      
for index, row in df.iterrows():
    if isinstance(row['REFERENCE_CODE'], str):
        result.append({})
    result[-1][row['REFERENCE_CODE']] = row['TRANSLATION']

print(result)
#Output:
[{'ladder_now': 0, 0: 1, 1: 2, 5: 3, 15: 4},
 {'country_satis': 5, 20: 6, 50: 7, 100: 8},
 {'test3': 9, 10: 10, 50: 11, 90: 12}]

使用字典：这里的词典容器可能更好，因为您可以按名称引用子词典。

result_dict = {}
for index, row in df.iterrows():
    if isinstance(row['REFERENCE_CODE'], str):
        key = row['REFERENCE_CODE']
        result_dict[key] = {}
    result_dict[key][row['REFERENCE_CODE']] = row['TRANSLATION']
print(result_dict)
#Output:
{'ladder_now': {'ladder_now': 0, 0: 1, 1: 2, 5: 3, 15: 4},
 'country_satis': {'country_satis': 5, 20: 6, 50: 7, 100: 8},
 'test3': {'test3': 9, 10: 10, 50: 11, 90: 12}}

请注意，您可能需要进一步修改if块的逻辑，尤其是因为我不确定您是否希望字符串键重新出现在子词典中。但是，这应该使您了解如何解决创建动态数量的项目。

如何在Python中创建动态命名词典？

1 个答案: