如何在for循环中根据字典替换值？ [Python]答案

【问题标题】：How to replace values based on dictionary within for loop? [python]如何在for循环中根据字典替换值？ [Python]
【发布时间】：2021-11-18 02:25:03
【问题描述】：

我有一个完整的数据输出 csv 我想插入回归模型，当然包含一个因变量列和相关值，以及多个自变量列（参数）和那些相关值。问题是我的自变量值不是“真实”值，它们只是对应于实际值的占位符。我使用 python 和 pandas 作为数据框。

我有这个数据框（参数为“Param”）：

    Color Zone Dependent.var  Param_1  Param_2  Param_3
0    Blue    A            XX        0        1        3
1    Blue    A            XX        2        1        1
2    Blue    A            XX        0        0        1
3    Blue    B            XX        1        0        0
4    Blue    B            XX        2        2        2
5    Blue    B            XX        2        1        1
6    Blue    C            XX        2        0        0
7    Blue    C            XX        2        2        3
8    Blue    C            XX        3        1        1
9     Red    A            XX        3        2        1
10    Red    A            XX        0        1        3
11    Red    A            XX        3        3        2
12    Red    B            XX        2        1        1
13    Red    B            XX        0        1        3
14    Red    B            XX        1        0        0
15    Red    C            XX        0        2        1
16    Red    C            XX        1        1        0
17    Red    C            XX        3        2        3
18  Green    A            XX        2        2        3
19  Green    A            XX        0        1        3
20  Green    A            XX        3        2        2
21  Green    B            XX        2        1        1
22  Green    B            XX        0        2        3
23  Green    B            XX        2        3        2
24  Green    C            XX        0        1        1
25  Green    C            XX        3        1        0
26  Green    C            XX        3        2        3

对不起，这太长了，但我觉得有必要交流数据结构。现在我有 9 个单独的字典（或键，我对术语感到困惑），每个颜色和区域组合有 1 个，其中包含初始占位符值与其“真实”值的“翻译”，它们看起来像这样，其中每个颜色/区域之间的“真实”值不同：

对于蓝色（蓝色/A 为 1，蓝色/B 为 1，蓝色/C 为 1）：

          0   1   2   3
------------------------
Param_1   XX  XX  XX   XX
Param_2   XX  XX  XX   XX
Param_3   XX  XX  XX   XX

对于红色（红色/A 为 1，红色/B 为 1，红色/C 为 1）：

          0   1   2   3
------------------------
Param_1   YY  YY  YY   YY
Param_2   YY  YY  YY   YY 
Param_3   YY  YY  YY   YY

对于绿色（绿色/A 为 1，绿色/B 为 1，绿色/C 为 1）：

          0   1   2   3
------------------------
Param_1   ZZ  ZZ  ZZ  ZZ
Param_2   ZZ  ZZ  ZZ  ZZ 
Param_3   ZZ  ZZ  ZZ  ZZ

我想获取这些“参数值映射”，然后用它们替换初始数据框中的数字。有没有一种简单的方法可以在 python 中做到这一点？我只是对如何解决存在三种不同颜色和 3 个独立区域以及 9 组独立替换值的问题感到非常困惑。我认为这将涉及一个 for 循环来迭代“颜色”和“区域”，但我不确定。

【问题讨论】：

您使用哪个框架来创建数据框？请添加标签。
不清楚“每种颜色之间的实际值”是什么意思。您要映射的值到底是什么？是不是只有XX 代表所有蓝色，YY 代表所有红色，ZZ 代表所有绿色？
@AcaNg- 我正在使用 pandas 作为数据框。
@ddejohn- “真实”值是指我实际打算使用的值，它们位于另一个电子表格中。我需要自己用钥匙把它们写下来。我不想在回归分析中使用 0、1、2、3，我想使用它们所代表的值。

标签： python dataframe dictionary indexing key

【解决方案1】：

由于你没有给出具体的映射，我将使用这个示例映射：

PARAMS = ["Param_1", "Param_2", "Param_3"]

PARAM_MAP = {'Red': {'Param_1': {0: 'P1_R0', 1: 'P1_R1', 2: 'P1_R2', 3: 'P1_R3'},
                     'Param_2': {0: 'P2_R0', 1: 'P2_R1', 2: 'P2_R2', 3: 'P2_R3'},
                     'Param_3': {0: 'P3_R0', 1: 'P3_R1', 2: 'P3_R2', 3: 'P3_R3'}},
             'Green': {'Param_1': {0: 'P1_G0', 1: 'P1_G1', 2: 'P1_G2', 3: 'P1_G3'},
                       'Param_2': {0: 'P2_G0', 1: 'P2_G1', 2: 'P2_G2', 3: 'P2_G3'},
                       'Param_3': {0: 'P3_G0', 1: 'P3_G1', 2: 'P3_G2', 3: 'P3_G3'}},
             'Blue': {'Param_1': {0: 'P1_B0', 1: 'P1_B1', 2: 'P1_B2', 3: 'P1_B3'},
                      'Param_2': {0: 'P2_B0', 1: 'P2_B1', 2: 'P2_B2', 3: 'P2_B3'},
                      'Param_3': {0: 'P3_B0', 1: 'P3_B1', 2: 'P3_B2', 3: 'P3_B3'}}}

并使用我们将应用于数据框的这个函数：

def mapping(row):
    color_map = PARAM_MAP[row["Color"]]
    return pd.Series({p: color_map[p][v] for p, v in zip(PARAMS, row[PARAMS])})

现在应用映射并重新分配：

df[PARAMS] = df.apply(mapping, axis=1)

输出：

    Color Zone Dependent.var Param_1 Param_2 Param_3
0    Blue    A            XX   P1_B0   P2_B1   P3_B3
1    Blue    A            XX   P1_B2   P2_B1   P3_B1
2    Blue    A            XX   P1_B0   P2_B0   P3_B1
3    Blue    B            XX   P1_B1   P2_B0   P3_B0
4    Blue    B            XX   P1_B2   P2_B2   P3_B2
5    Blue    B            XX   P1_B2   P2_B1   P3_B1
6    Blue    C            XX   P1_B2   P2_B0   P3_B0
7    Blue    C            XX   P1_B2   P2_B2   P3_B3
8    Blue    C            XX   P1_B3   P2_B1   P3_B1
9     Red    A            XX   P1_R3   P2_R2   P3_R1
10    Red    A            XX   P1_R0   P2_R1   P3_R3
11    Red    A            XX   P1_R3   P2_R3   P3_R2
12    Red    B            XX   P1_R2   P2_R1   P3_R1
13    Red    B            XX   P1_R0   P2_R1   P3_R3
14    Red    B            XX   P1_R1   P2_R0   P3_R0
15    Red    C            XX   P1_R0   P2_R2   P3_R1
16    Red    C            XX   P1_R1   P2_R1   P3_R0
17    Red    C            XX   P1_R3   P2_R2   P3_R3
18  Green    A            XX   P1_G2   P2_G2   P3_G3
19  Green    A            XX   P1_G0   P2_G1   P3_G3
20  Green    A            XX   P1_G3   P2_G2   P3_G2
21  Green    B            XX   P1_G2   P2_G1   P3_G1
22  Green    B            XX   P1_G0   P2_G2   P3_G3
23  Green    B            XX   P1_G2   P2_G3   P3_G2
24  Green    C            XX   P1_G0   P2_G1   P3_G1
25  Green    C            XX   P1_G3   P2_G1   P3_G0
26  Green    C            XX   P1_G3   P2_G2   P3_G3

我想可能有更好的方法，也许是groupby，但我想不通。

【讨论】：

您好，这看起来效果很好，尽管我在刚刚更新的帖子中犯了一个大错误。我的意思是说每个“颜色”和“区域”组合都有一个单独的翻译键，所以总共会有 9 个翻译键。我仍然可以使用您的代码建议来执行此操作吗？还是这会改变一切？