Python：将一个数据帧与另一个数据帧相乘

Question

嗨，我目前有 2 个不同形状的数据框

df11 = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
                   columns=['a', 'b', 'c'])
    a   b   c
0   1   2   3
1   4   5   6
2   7   8   9

df12 = pd.DataFrame(np.array([[7, 8, 9]]),
                   columns=['a', 'b', 'c'])

a   b   c
0   7   8   9

我想将 df11 中的每一行乘以 df12。所以生成的数据框应该显示

df13 = pd.DataFrame(np.array([[7, 16, 27], [28, 40, 54], [49, 64, 81]]),
                   columns=['a', 'b', 'c'])

    a   b   c
0   7   16  27
1   28  40  54
2   49  64  81

Answer 1

我推荐使用 numpy 乘法

df13 = pd.DataFrame(df11.to_numpy()*df12.to_numpy(), columns=df11.columns)

或者你可以像这样使用 pandas mul 运算符，

df11.mul({'a': 7, 'b': 8, 'c': 9})

Answer 2

One-liner

df_3 = df_1 * df_2.iloc[0]

代码

import pandas as pd

data_1 = {'a': [1, 4, 7],
          'b': [2, 5, 8],
          'c': [3, 6, 9]}
data_2 = {'a': [7], 'b': [8], 'c': [9]}
df_1 = pd.DataFrame(data_1)
df_2 = pd.DataFrame(data_2)

df_3 = df_1 * df_2.iloc[0]
print(df_3)

输出

    a   b   c
0   7  16  27
1  28  40  54
2  49  64  81

时间此输入的一些时间。

# Paul_O's numpy approach
25.9 µs ± 440 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

# iloc approach
172 µs ± 962 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

# mozway's approach 
194 µs ± 254 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

# Paul_O's mul approach
308 µs ± 1.38 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

使 data_1 10000 x 3 DataFrame 1 到 10000 之间的随机整数，我们得到非常相似的结果。

# Paul_O's numpy approach
39 µs ± 396 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

# iloc approach
188 µs ± 1.94 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

# mozway's approach
206 µs ± 2.86 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

# Paul_O's mul approach
312 µs ± 1.95 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

当然，这只是一个系统上两组非常具体的输入的两组时序，所以我不建议从中得出硬性结论，但看起来如果你的问题与这个问题非常相似，那么numpy 方法最好。在其他情况下，最佳方式可能会有所不同，例如，如果您的输入形式不同。

Answer 3

您可以使用 squeeze:

df13 = df11*df12.squeeze()

潜在的优势在于，如果 df12 有超过 2 行，它将执行二维乘法。

输出：

    a   b   c
0   7  16  27
1  28  40  54
2  49  64  81

Python：将一个数据帧与另一个数据帧相乘

Python: Multiplying a dataframe with another dataframe

python

indexing

numpy

dataframe

pandas