Question

我有一个看起来像这样的DataFrame

df = pd.DataFrame({
    "A": ['Y0', 'Y2', 'Y5', 'Y1', 'Y3', 'Y5'],
    "B": ['Y2', 'Y5', 'Y0', 'Y2', 'Y7', 'Y6'],
    "C": ['Y7', 'Y1', 'Y4', 'Y2', 'Y5', 'Y0'],
    "D": ['Y2', 'Y5', 'Y7', 'Y7', 'Y1', 'Y5'],
    "E": ['Y6', 'Y3', 'Y1', 'Y6', 'Y1', 'Y0'],
    "F": ['Y0', 'Y5', 'Y2', 'Y0', 'Y0', 'Y0'],
    "X0": [100, 200, 300, 400, 500, 600],
    "X1": [101, 201, 301, 401, 501, 601],
    "X2": [102, 202, 302, 402, 502, 602],
    "X3": [103, 203, 303, 403, 503, 603],
    "X4": [104, 204, 304, 404, 504, 604],
    "X5": [105, 205, 305, 405, 505, 605],
    "X6": [106, 206, 306, 406, 506, 606],
    "X7": [107, 207, 307, 407, 507, 607]
})

df

    A   B   C   D   E   F   X0  X1  X2  X3  X4  X5  X6  X7
0   Y0  Y2  Y7  Y2  Y6  Y0  100 101 102 103 104 105 106 107
1   Y2  Y5  Y1  Y5  Y3  Y5  200 201 202 203 204 205 206 207
2   Y5  Y0  Y4  Y7  Y1  Y2  300 301 302 303 304 305 306 307
3   Y1  Y2  Y2  Y7  Y6  Y0  400 401 402 403 404 405 406 407
4   Y3  Y7  Y5  Y1  Y1  Y0  500 501 502 503 504 505 506 507
5   Y5  Y6  Y0  Y5  Y0  Y0  600 601 602 603 604 605 606 607

和一个映射

mapping = {
    'Y0': 'X0',
    'Y1': 'X1',
    'Y2': 'X2',
    'Y3': 'X3',
    'Y4': 'X4',
    'Y5': 'X5',
    'Y6': 'X6',
    'Y7': 'X7',
}

实际上，X和Y之间的映射并不简单（但可以将其放入代码中）。

我正在尝试分配新列，A_result至F_result，其值来自X0至X7列，使用A至{ {1}}作为密钥。

例如，F的第二个元素应该是C_result，因为201的第二个元素是C，而Y1的第二个元素有一个值X1。

我现在要做的代码是

这有效，但是速度很慢。在具有几百行的DataFrame上，运行时间不到一秒钟。什么是更快的方法？

Answer 1

现在进行了一些优化，您可以尝试以下操作：

df2 = df.iloc[:,:6].apply(lambda x: [df[mapping.get(elem)][i] for i, elem in enumerate(x)]).rename(columns=lambda c: f'{c}_results')

#    A_results  B_results  C_results  D_results  E_results  F_results
# 0        100        102        107        102        106        100
# 1        202        205        201        205        203        205
# 2        305        300        304        307        301        302
# 3        401        402        402        407        406        400
# 4        503        507        505        501        501        500
# 5        605        606        600        605        600        600

在n=1000上测试速度：

this method = 6.141038116
your method = 96.079351477

值得一提的是，单次运行的性能似乎并没有太大变化。

如何基于列到值的映射将值分配给DataFrame？

1 个答案: