【问题标题】：How to multiply every column of one Pandas Dataframe with every column of another Dataframe efficiently?如何有效地将一个 Pandas Dataframe 的每一列与另一个 Dataframe 的每一列相乘？
【发布时间】：2017-01-28 22:08:03
【问题描述】：

我正在尝试将两个 pandas 数据帧相乘。具体来说，我想将每一列与另一个 df 的每一列相乘。

数据帧是 one-hot 编码的，所以它们看起来像这样：

col_1, col_2, col_3, ...
 0      1      0 
 1      0      0 
 0      0      1 
 ...

我可以使用 for 循环遍历每一列，但在 python 中计算成本很高，我希望有一种更简单的方法。

其中一个数据框有 500 列，另一个有 100 列。

这是迄今为止我能写的最快的版本：

interact_pd = pd.DataFrame(index=df_1.index)
df1_columns = [column for column in df_1]
for column in df_2:
    col_pd = df_1[df1_columns].multiply(df_2[column], axis="index")
    interact_pd = interact_pd.join(col_pd, lsuffix='_' + column)

我遍历 df_2 中的每一列并将所有 df_1 乘以该列，然后将结果附加到 interact_pd。但是，我宁愿不使用 for 循环来执行此操作，因为这在计算上非常昂贵。有没有更快的方法？

编辑：示例

df_1：

1col_1, 1col_2, 1col_3
 0      1      0 
 1      0      0 
 0      0      1

df_2：

2col_1, 2col_2
 0      1       
 1      0       
 0      0

interact_pd：

1col_1_2col_1, 1col_2_2col_1,1col_3_2col_1, 1col_1_2col_2, 1col_2_2col_2,1col_3_2col_2

  0      0      0        0       1        0  
  1      0      0        0       0        0 
  0      0      0        0       0        0

【问题讨论】：

如果您尝试过，您需要生成可重现的示例，清楚地展示您想要的输出，并解释您之前努力的缺点。
互动是什么意思？
刚刚编辑了这个问题 - 它更有意义吗？
向我们展示 2（短）df 和您期望的相应输出。
如果第二个数据帧的每一列的列数不同，你想如何将第一个数据帧的每一列与第二个数据帧的每一列相乘？您的目标是 50000 列的结果吗？

标签： python pandas numpy dataframe

【解决方案1】：

# use numpy to get a pair of indices that map out every
# combination of columns from df_1 and columns of df_2
pidx = np.indices((df_1.shape[1], df_2.shape[1])).reshape(2, -1)

# use pandas MultiIndex to create a nice MultiIndex for
# the final output
lcol = pd.MultiIndex.from_product([df_1.columns, df_2.columns],
                                  names=[df_1.columns.name, df_2.columns.name])

# df_1.values[:, pidx[0]] slices df_1 values for every combination
# like wise with df_2.values[:, pidx[1]]
# finally, I marry up the product of arrays with the MultiIndex
pd.DataFrame(df_1.values[:, pidx[0]] * df_2.values[:, pidx[1]],
             columns=lcol)

时间

代码

from string import ascii_letters

df_1 = pd.DataFrame(np.random.randint(0, 2, (1000, 26)), columns=list(ascii_letters[:26]))
df_2 = pd.DataFrame(np.random.randint(0, 2, (1000, 52)), columns=list(ascii_letters))

def pir1(df_1, df_2):
    pidx = np.indices((df_1.shape[1], df_2.shape[1])).reshape(2, -1)

    lcol = pd.MultiIndex.from_product([df_1.columns, df_2.columns],
                                      names=[df_1.columns.name, df_2.columns.name])

    return pd.DataFrame(df_1.values[:, pidx[0]] * df_2.values[:, pidx[1]],
                        columns=lcol)

def Test2(DA,DB):
  MA = DA.as_matrix()
  MB = DB.as_matrix()
  MM = np.zeros((len(MA),len(MA[0])*len(MB[0])))
  Col = []
  for i in range(len(MB[0])):
    for j in range(len(MA[0])):
      MM[:,i*len(MA[0])+j] = MA[:,j]*MB[:,i]
      Col.append('1col_'+str(i+1)+'_2col_'+str(j+1))
  return pd.DataFrame(MM,dtype=int,columns=Col)

结果

【讨论】：

很好，尽管解释一下也无妨！
使用我的示例，该函数的 timeit 产生 910 µs per loop
@Khris 在更大的数据帧上运行它。 OP 建议这适用于更大的数据集。
使用两个较大的 100x100 数据集产生 16 ms per loop，与其他解决方案相比，速度快得惊人。
@Khris 不仅仅是时间。但这也可以优雅地处理列名。

【解决方案2】：

您可以沿index 轴将您的第一个df 与第二个df 的每一列相乘，这是大型数据集的最快方法（见下文）：

df = pd.concat([df_1.mul(col[1], axis="index") for col in df_2.iteritems()], axis=1)
# Change the name of the columns
df.columns = ["_".join([i, j]) for j in df_2.columns for i in df_1.columns]
df
       1col_1_2col_1  1col_2_2col_1  1col_3_2col_1  1col_1_2col_2  \
0                  0              0              0              0   
1                  1              0              0              0   
2                  0              0              0              0   

   1col_2_2col_2  1col_3_2col_2  
0              1              0  
1              0              0  
2              0              0

--> 查看基准以与其他答案进行比较，为您的数据集选择最佳选项。

基准测试

功能：

def Test2(DA,DB):
  MA = DA.as_matrix()
  MB = DB.as_matrix()
  MM = np.zeros((len(MA),len(MA[0])*len(MB[0])))
  Col = []
  for i in range(len(MB[0])):
    for j in range(len(MA[0])):
      MM[:,i*len(MA[0])+j] = MA[:,j]*MB[:,i]
      Col.append('1col_'+str(i+1)+'_2col_'+str(j+1))
  return pd.DataFrame(MM,dtype=int,columns=Col)

def Test3(df_1, df_2):
    df = pd.concat([df_1.mul(i[1], axis="index") for i in df_2.iteritems()], axis=1)
    df.columns = ["_".join([i,j]) for j in df_2.columns for i in df_1.columns]
    return df

def Test4(df_1,df_2):
    pidx = np.indices((df_1.shape[1], df_2.shape[1])).reshape(2, -1)
    lcol = pd.MultiIndex.from_product([df_1.columns, df_2.columns],
                                      names=[df_1.columns.name, df_2.columns.name])
    return pd.DataFrame(df_1.values[:, pidx[0]] * df_2.values[:, pidx[1]],
                 columns=lcol)

def jeanrjc_imp(df_1, df_2):
    df = pd.concat([df_1.mul(‌i[1], axis="index") for i in df_2.iteritems()], axis=1, keys=df_2.columns) 
    return df

代码：

对不起，丑陋的代码，最后的情节很重要：

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

df_1 = pd.DataFrame(np.random.randint(0, 2, (1000, 600)))
df_2 = pd.DataFrame(np.random.randint(0, 2, (1000, 600)))
df_1.columns = ["1col_"+str(i) for i in range(len(df_1.columns))]
df_2.columns = ["2col_"+str(i) for i in range(len(df_2.columns))]
resa = {}
resb = {}
resc = {}
for f, r in zip([Test2, Test3, Test4, jeanrjc_imp], ["T2", "T3", "T4", "T3bis"]):
        resa[r] = []
        resb[r] = []
        resc[r] = []
        for i in [5, 10, 30, 50, 150, 200]:
             a = %timeit -o f(df_1.iloc[:,:i], df_2.iloc[:, :10])
             b = %timeit -o f(df_1.iloc[:,:i], df_2.iloc[:, :50])
             c = %timeit -o f(df_1.iloc[:,:i], df_2.iloc[:, :200])
             resa[r].append(a.best)
             resb[r].append(b.best)
             resc[r].append(c.best)

X = [5, 10, 30, 50, 150, 200]
fig, ax = plt.subplots(1, 3, figsize=[16,5])
for j, (a, r) in enumerate(zip(ax, [resa, resb, resc])):
    for i in r:
        a.plot(X, r[i], label=i)
        a.set_xlabel("df_1 columns #") 
        a.set_title("df_2 columns # = {}".format(["10", "50", "200"][j]))
ax[0].set_ylabel("time(s)")
plt.legend(loc=0)
plt.tight_layout()

T3b <=> jeanrjc_imp。这比 Test3 快一点。

结论：

根据您的数据集大小，在 Test4 和 Test3(b) 之间选择正确的函数。给定 OP 的数据集，Test3 或 jeanrjc_imp 应该是最快的，也是最短的！

HTH

【讨论】：

我的小例子产生2.33 ms per loop，我现在正在测试大例子。
100x100 数据集的性能与我的代码大致相同。
@Khris 数据集越大，您的解决方案就越慢。
您的解决方案已从迭代列名更改为使用df_2.iteritems()。后者比前者快。并且在某些情况下比我的解决方案更快（比如 500 x 100）。但是，它不对称地更快。如果列不平衡情况相反，它会更慢。
另外，您错过了在pd.concat 中使用keys 更快的机会。 def jeanrjc_imp(df_1, df_2): df = pd.concat([df_1.mul(i[1], axis="index") for i in df_2.iteritems()], axis=1, keys=df_2.columns) return df

【解决方案3】：

你可以使用 numpy。

考虑这个示例代码，我确实修改了变量名，但Test1() 本质上是您的代码。不过，我没有费心在该函数中创建正确的列名：

import pandas as pd
import numpy as np

A = [[1,0,1,1],[0,1,1,0],[0,1,0,1]]
B = [[0,0,1,0],[1,0,1,0],[1,1,0,0],[1,0,0,1],[1,0,0,0]]

DA = pd.DataFrame(A).T
DB = pd.DataFrame(B).T

def Test1(DA,DB):
  E = pd.DataFrame(index=DA.index)
  DAC = [column for column in DA]
  for column in DB:
    C = DA[DAC].multiply(DB[column], axis="index")
    E = E.join(C, lsuffix='_' + str(column))
  return E

def Test2(DA,DB):
  MA = DA.as_matrix()
  MB = DB.as_matrix()
  MM = np.zeros((len(MA),len(MA[0])*len(MB[0])))
  Col = []
  for i in range(len(MB[0])):
    for j in range(len(MA[0])):
      MM[:,i*len(MA[0])+j] = MA[:,j]*MB[:,i]
      Col.append('1col_'+str(i+1)+'_2col_'+str(j+1))
  return pd.DataFrame(MM,dtype=int,columns=Col)

print Test1(DA,DB)
print Test2(DA,DB)

输出：

   0_1  1_1  2_1  0  1  2  0_3  1_3  2_3  0  1  2  0  1  2
0    0    0    0  1  0  0    1    0    0  1  0  0  1  0  0
1    0    0    0  0  0  0    0    1    1  0  0  0  0  0  0
2    1    1    0  1  1  0    0    0    0  0  0  0  0  0  0
3    0    0    0  0  0  0    0    0    0  1  0  1  0  0  0
   1col_1_2col_1  1col_1_2col_2  1col_1_2col_3  1col_2_2col_1  1col_2_2col_2  \
0              0              0              0              1              0   
1              0              0              0              0              0   
2              1              1              0              1              1   
3              0              0              0              0              0   

   1col_2_2col_3  1col_3_2col_1  1col_3_2col_2  1col_3_2col_3  1col_4_2col_1  \
0              0              1              0              0              1   
1              0              0              1              1              0   
2              0              0              0              0              0   
3              0              0              0              0              1   

   1col_4_2col_2  1col_4_2col_3  1col_5_2col_1  1col_5_2col_2  1col_5_2col_3  
0              0              0              1              0              0  
1              0              0              0              0              0  
2              0              0              0              0              0  
3              0              1              0              0              0

你的功能的表现：

%timeit(Test1(DA,DB))
100 loops, best of 3: 11.1 ms per loop

我的功能表现：

%timeit(Test2(DA,DB))
1000 loops, best of 3: 464 µs per loop

它不漂亮，但它很高效。

【讨论】：