Question

我的pandas数据框看起来像

In [97]: df
Out[97]:
      A1  A1_step  A1_step_n  LB7  dF
0  40000      500          2    4   2
1  60000      300          3    6   7

我想使用包含step和step_n关键字的列来＆＃34;步骤＆＃34; （迭代）通过具有指定步长的数据帧的行。因此，在上面的示例数据框中，我想遍历A1列的40000行两次，步长为500次，三次，步长为300次，行为60000次。最后，我喜欢数据框看起来像

In [98]: df2
Out[98]:
      A1    LB7  dF
0  40000      4   2
1  40500      4   2
2  60000      6   7
3  60300      6   7
4  60600      6   7

其中LB7和dF的值是通过＆＃34;步骤＆＃34;不再需要列。

我尝试循环遍历列，试图通过这些列进行迭代并循环遍历这些循环以添加到数据框中，但它很快就变得非常混乱，我希望有人在这里可以引导我走上更好的道路。

Answer 1

您可以遍历行并手动构建数据框，如下所示：

dfs = []
col_step = df.columns.str.extract('(.*\_step$)', expand=False).dropna()[0]
col_step_n = df.columns.str.extract('(.*\_step\_n$)', expand=False).dropna()[0]

for i, row in df.iterrows():
    start = row['A1']
    steps = row[col_step_n]
    size = row[col_step]
    stop = start + size * (steps)
    df_cur = pd.DataFrame({'A1': np.arange(start, stop, size), 'LB7':row['LB7'], 'dF':row['dF']})
    dfs.append(df_cur)

df_final = pd.concat(dfs, ignore_index=True)

输出

print(df_final)
      A1  LB7  dF
0  40000    4   2
1  40500    4   2
2  60000    6   7
3  60300    6   7
4  60600    6   7

Answer 2

v = df.values
reps = np.arange(len(v)).repeat(v[:, 2])
a1 = np.concatenate([np.arange(a, a + b * c, b) for a, b, c in v[:, :3]])[:, None]
v1 = v[:, 3:][reps]
pd.DataFrame(np.hstack([a1, v1]), columns=['A1', 'LB7', 'dF'])


      A1  LB7  dF
0  40000    4   2
1  40500    4   2
2  60000    6   7
3  60300    6   7
4  60600    6   7

Answer 3

我想分享我最终的答案，因为它展示了我所寻求的一般性水平。

import pandas as pd
from itertools import product

dfs = []
step_cols = [col[:-7] for col in df.columns if '_step_n' in col]
const_cols = ([col + '_step' for col in step_cols] + step_cols +
              [col + '_step_n' for col in step_cols])

for i, row in df.iterrows():
    ranges = []
    for col in step_cols:
        start = row[col]
        stop = row[col] + row[col + '_step'] * row[col + '_step_n']
        step = row[col + '_step']
        ranges.append(list(range(start, stop, step)))
    combos = list(product(*ranges))
    dfs.append(pd.DataFrame(
        {**{k: v for k, v in zip(step_cols, zip(*combos))},
         **df.drop(const_cols, axis=1).iloc[i].to_dict()}))

df2 = pd.concat(dfs, ignore_index=True)

如果原始df是

那么

In [226]: df
Out[226]:
      A1  LB7  dF  A1_step_n  A1_step
0  40000    4   2          2      500
1  60000    6   7          3      300

结果df2是

In [227]: df2
Out[227]:
      A1  LB7  dF
0  40000    4   2
1  40500    4   2
2  60000    6   7
3  60300    6   7
4  60600    6   7

这样做的另一个好处是，将“_step”和“_step_n”添加到其他列名称可以让您遍历笛卡尔积。例如。如果原始df是

In [230]: df
Out[230]:
    A1  LB7  dF  A1_step_n  A1_step  dF_step_n  dF_step
0  100    5  15          4       50          2        7
1  200    8  30          3       30          3        4

结果df2将遍历A1和dF

In [231]: df2
Out[231]:
     A1  LB7  dF
0   100    5  15
1   100    5  22
2   150    5  15
3   150    5  22
4   200    5  15
5   200    5  22
6   250    5  15
7   250    5  22
8   200    8  30
9   200    8  34
10  200    8  38
11  230    8  30
12  230    8  34
13  230    8  38
14  260    8  30
15  260    8  34
16  260    8  38

根据关键字逐步完成pandas数据框

3 个答案: