熊猫数据框按权重将值拆分为一行

Question

这似乎是一个基本问题，但是一种巧妙的解决方案使我逃脱了。

我有一个pandas数据框，其中所有值都分配为一行。但是，我需要按权重将值划分为多行。此处的示例：

输入数据框：

import pandas as pd

# starting df with weights W.
df_input = pd.DataFrame({
    'W': [0.3, 0.2, 0.5],
    'X1': [100, 0, 0],
    'X2': [150, 0, 0],
    'X3': [200, 0, 0],
    'X4': [300, 0, 0]
})

所需的输出数据帧：

df_output = pd.DataFrame({
    'W': [0.3, 0.2, 0.5],
    'X1': [30, 20, 50],
    'X2': [45, 30, 75],
    'X3': [60, 40, 100],
    'X4': [90, 60, 150]
})

屏幕截图：

Answer 1

纯熊猫解决方案：

// Store values as LocalTime instead of hour/minute pairs
LocalTime time = LocalTime.of​(hour, minute);
LocalTime startTime = LocalTime.of​(startHour, startMinute);
LocalTime endTime = LocalTime.of​(endHour, endMinute);

// Test
if (minuteOfDay.compareTo​(startMinuteOfDay) >= 0 && minuteOfDay.compareTo​(endMinuteOfDay) < 0) {
    // inside
} else {
    // outside
}

或使用Numpy广播：

df_output = df_input.copy()
df_output.loc[:, 'X1':] = df_output.loc[:, 'X1':].apply(lambda col: col[0] * df_output['W'])

Answer 2

优雅是主观的-一种可能的方法是使用pd.clip

 for col in ['X1', 'X2', 'X3', 'X4']:
     df_input[col] = df_input[col].clip(lower=df_input[col].max())
     df_input[col]*=df_input['W']

结果将是上面的。

Answer 3

使用DataFrame.ffill填充列中的值，然后将它们乘以DataFrame.multiply的因子

values = df_input.replace(0, np.NaN).ffill()
df_input.iloc[:, 1:] = values.iloc[:, 1:].mul(df_input['W'], axis=0)

或者我们可以使用numpy，但是首先我们必须将数组重塑为(,1)

values = df_input.replace(0, np.NaN).ffill()
df_input.iloc[:, 1:] = values.iloc[:, 1:] * values['W'].to_numpy()[:, None]

     W    X1    X2     X3     X4
0  0.3  30.0  45.0   60.0   90.0
1  0.2  20.0  30.0   40.0   60.0
2  0.5  50.0  75.0  100.0  150.0

Answer 4

将数据输出到numpy数组，然后计算点积

• 从行和列数据创建两个数组
• 调整数组的形状
• np.dot两个数组

import pandas as pd
import numpy as np

# using your data

# weight
w = df_input.iloc[:, 0].to_numpy().reshape(len(df_input), 1)

array([[0.3],
       [0.2],
       [0.5]])

# values
v = df_input.iloc[0, 1:].to_numpy().reshape(1, len(df_input.columns[1:]))

array([[30., 45., 60., 90.]])

# load dot product into a dataframe
df_out = pd.DataFrame(np.dot(w, v))

# add column names
df_out.columns = df_input.columns[1:]

# insert W if needed
df_out.insert(0, 'W', df_input['W'])

# output
   W    X1    X2     X3     X4
 0.3  30.0  45.0   60.0   90.0
 0.2  20.0  30.0   40.0   60.0
 0.5  50.0  75.0  100.0  150.0

Answer 5

这里是已经提供的出色答案的替代方法：

获取仅x列：

x_columns = df_input.filter(like='X').columns

计算（注释中包含解释）：

df_input.loc[:,x_columns] = (df_input.loc[:,x_columns]
                            #spill the non zero values downwards
                            .replace(0,method='ffill')
                            #multiply by the 'W' column
                            .mul(df_input['W'],axis=0)
                            .astype(int)
                            )


     W  X1  X2  X3  X4
0   0.3 30  45  60  90
1   0.2 20  30  40  60
2   0.5 50  75  100 150

Answer 6

如果我理解正确，那只是一个简单的矩阵乘法。 从（3,1）矩阵开始，再乘以（1,3）。 最终结果将是（3,3）。让我知道这种解决方法是否有任何帮助：

import numpy as np
A = np.array([[3,6,7],[5,-3,0]])
B = np.array([[1,1],[2,1],[3,-1]])
C = A.dot(B)
print (C)

Output:
[[36,-12],
 [-1,  2]