python - 加速循环

Question

我有一个可能来自数据透视表的数据框，所以它看起来很困惑。它不仅仅是一个 XY 2 维数据，而是一个 4 或 5。
我想要做的是，如果满足某些条件，则添加一个新列并从第 3 行(第 0、1、2 行是字符串)开始计算同比变化。
并且为了避免计算时的除零错误(如果直接做数学运算会出错)，我必须在循环中添加循环(if else 函数首先输入0)。通过使用 time()功能，我可以看出该程序每次运行都需要将近 10 分钟。
我想知道是否有任何更聪明的方法来编程它。感谢您的善意建议!

for i in range(1, 187):
   k = i * 1000
   if df.iloc[1, i] == df.iloc[1, i - 1] and df.iloc[1, i] != df.iloc[1, i+ 1]:
        df[k] = 0
        a = df.columns.get_loc[k]
        df.iloc[0, a] = df.iloc[0, i]
        df.iloc[1, a] = df.iloc[1, i]
        df.iloc[2, a] = 'YoY%'
        
        for m in range(3, 13259):
            if df.iloc[m, i - 1] == 0:
                 df.iloc[m, a] = 0
            else:
                 df.iloc[m, a] = (df.iloc[m, i] - df.iloc[m, i - 1]) / df.iloc[m, i - 1]
df = df.sort_values(by=[0, 1, 2], axis=1)

排序前的数据框片段如下所示:

0      cash    cash    cash     cash     trade   trade    cash    cash    trade
1      54100   54100   54103    54103    52209   52209    54100   54103   52209
2      02-21   03-21   02-21    03-21    02-21   03-21    YoY%    YoY%    YoY%
3      0       0       1500     1500     -28.1   -2476.8  0       0       87.14 
4      0       500     16500    16500    25      35       0       0       0.4
5      0       0       300      600      3.1     420      0       1       134.5
       ..      ..      ..       ..       ..      ..       ..      ..      ..
13258  1973.7  4484.9  18300    18600    0       750      1.3     0.02    0

Answer 1

如果您以易于复制和使用的格式提供数据样本，那么回答您的问题会更容易。我会尽力帮助:
假设您有以下数据:

records = [
    ['cash','cash','cash','cash','trade','trade'],
    [54100,54100,54103,54103,52209,52209],
    ['02-21','03-21','02-21','03-21','02-21','03-21'],
    [0,0,1500,1500,-28.1,-2476.8],
    [0,500,16500,16500,25,35],
    [0,0,300,600,3.1,420],
    [1973.7,4484.9,18300,18600,0,750],
]
index = [0,1,2,3,4,5,13259]
df = pd.DataFrame.from_records(records, index=index)

它产生以下数据帧:

            0       1      2      3      4       5
0        cash    cash   cash   cash  trade   trade
1       54100   54100  54103  54103  52209   52209
2       02-21   03-21  02-21  03-21  02-21   03-21
3           0       0   1500   1500  -28.1 -2476.8
4           0     500  16500  16500     25      35
5           0       0    300    600    3.1     420
13259  1973.7  4484.9  18300  18600      0     750

似乎数据的前三行实际上是表头。我们可以将它们转换为 muliindex 以充分利用 pandas 的功能:

# Set columns index from first rows
df.columns = [df.iloc[i] for i in range(3)]
# Delete first rows used for column names
df = df.iloc[3:]

这会产生以下数据框(注意前三行现在是数据框的列):

0        cash                       trade
1       54100          54103        52209
2       02-21   03-21  02-21  03-21 02-21   03-21
3           0       0   1500   1500 -28.1 -2476.8
4           0     500  16500  16500    25      35
5           0       0    300    600   3.1     420
13259  1973.7  4484.9  18300  18600     0     750

现在您可以使用 Pandas 沿列进行分组。首先要做的事情是:当我们对它们进行分组时，我们需要一个函数来应用于每对列。假设我们定义了以下函数来计算两个月之间的增量:

def calculate_incr(df):
    ''' Calculates the increment between a dataframe's first two colums.
    Ignores division by zero errors.
    '''
    mask = df.iloc[:,0] != 0  # prevents divide by zero error
    return df.loc[mask].iloc[:,1] / df.loc[mask].iloc[:,0] - 1

我们终于可以对我们的数据进行分组并计算增量。这有点棘手，因为pandas似乎不喜欢在多个列级别上分组，因此我们将首先组合列标签，然后在后面的步骤中再次拆分它们以与原始数据组合:

In []: df.groupby(by=lambda l: '_'.join(map(str, l[:2])), axis=1).agg(calculate_incr)
Out[]:
       cash_54100  cash_54103  trade_52209
3             NaN    0.000000    87.142349
4             NaN    0.000000     0.400000
5             NaN    1.000000   134.483871
13259    1.272331    0.016393          NaN

数字似乎是正确的，但您可能希望将此结果整合到您的原始表中并替换 NaN s 表示除以零错误除以 0，所以让我们再次计算增量，但这次很漂亮，将列拆分为多索引:

grouped = df.groupby(by=lambda l: '_'.join(map(str, l[:2])), axis=1)
increments = {k: calculate_incr(grp) for k, grp in grouped}
increments = pd.DataFrame(increments).fillna(0)
increments.columns = increments.columns.map(lambda c: tuple([*c.split('_'), 'YoY%']))

啊哈!这现在看起来更好:

In []: increments
Out[]:
           cash                 trade
          54100     54103       52209
           YoY%      YoY%        YoY%
3      0.000000  0.000000   87.142349
4      0.000000  0.000000    0.400000
5      0.000000  1.000000  134.483871
13259  1.272331  0.016393    0.000000

现在也可以轻松地将此结果合并到您的原始数据中:

In []: result = pd.concat([df, increments], axis=1)

In []: result
Out[]:
0        cash                       trade              cash                 trade
1       54100          54103        52209             54100     54103       52209
2       02-21   03-21  02-21  03-21 02-21   03-21      YoY%      YoY%        YoY%
3           0       0   1500   1500 -28.1 -2476.8  0.000000  0.000000   87.142349
4           0     500  16500  16500    25      35  0.000000  0.000000    0.400000
5           0       0    300    600   3.1     420  0.000000  1.000000  134.483871
13259  1973.7  4484.9  18300  18600     0     750  1.272331  0.016393    0.000000

最后，如果您想保留您提供的示例中的表格，而没有标题(即多索引列)，只需使用此技巧来重置列:

In []: result = result.columns.to_frame().T.append(result, ignore_index=True).T.reset_index(drop=True).T

In []: result
Out[]:
        0       1      2      3      4       5        6          7        8
0    cash    cash   cash   cash  trade   trade     cash       cash    trade
1   54100   54100  54103  54103  52209   52209    54100      54103    52209
2   02-21   03-21  02-21  03-21  02-21   03-21     YoY%       YoY%     YoY%
3       0       0   1500   1500  -28.1 -2476.8        0          0  87.1423
4       0     500  16500  16500     25      35        0          0      0.4
5       0       0    300    600    3.1     420        0          1  134.484
6  1973.7  4484.9  18300  18600      0     750  1.27233  0.0163934        0