Question

假设我们有一个数据帧（df），其中的行数很高（1600000X4）。此外，我们还有一个列表列表，例如：

inx = [[1,2],[4,5], [8,9,10], [15,16]]

我们需要为inx中的每个列表计算此数据帧的第一和第三列的平均值以及第二和第四列的中值。例如，对于inx的第一个列表，我们应该对第一行和第二行执行此操作，并将所有这些行替换为包含这些计算输出的新行。最快的方法是什么？

import numpy as np
import pandas as pd

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

   a  b  c  d
0  1  2  3  3
1  4  5  6  1
2  7  8  9  3
3  1  1  1  1

inx（[1,2]）内第一个列表的输出将是这样的：

   a  b  c  d
0  1  2  3  3
1  5.5  6.5  7.5  2
3  1  1  1  1

如您所见，我们不会更改第一行（0），因为它不在主列表中。之后，我们将对[4,5]执行相同的操作。我们不会更改第3行中的任何内容，因为它也不在列表中。 inx是一个很大的列表列表（超过100000个元素）。

Answer 1

编辑：避免方法的新方法

在下面，您会发现一种依赖熊猫并避免循环的方法。

生成一些大小与您相同的伪数据后，我基本上从inx行列表创建索引列表；即您的inx为：

[[2,3], [5,6,7], [10,11], ...]

创建的列表为：

[[1,1], [2,2,2], [3,3],...]

此后，此列表被展平并添加到原始数据框，以标记要操作的各种行组。经过适当的计算后，结果数据框将与不需要计算的原始行合并在一起（在上面的示例中，行：[0、1、4、8、9，...]）。您会在代码中找到更多注释。

在回答的最后，我也保留了以前的记录方法。在我的盒子上，涉及循环的旧算法需要超过18分钟的时间……难以忍受！仅使用熊猫，只需不到一半的时间！！熊猫很棒！

import pandas as pd
import numpy as np
import random

# Prepare some fake data to test
data = np.random.randint(0, 9, size=(160000, 4))
df = pd.DataFrame(data, columns=['a', 'b', 'c', 'd'])

inxl = random.sample(range(1, 160000), 140000)
inxl.sort()

inx=[]
while len(inxl) > 3:
    i = random.randint(2,3)
    l = inxl[0:i]
    inx.append(l)
    inxl = inxl[i:]
inx.append(inxl)



# flatten inx (used below)
flat_inx = [item for sublist in inx for item in sublist]
# for each element (list) in inx create equivalent list (same length)
# of increasing ints. They'll be used to group corresponding rows
gr=[len(sublist) for sublist in inx]
t = list(zip(gr, range(1, len(inx)+1)))

group_list = [a*[b] for (a,b) in t]

# the groups are flatten either
flat_group_list = [item for sublist in group_list for item in sublist]

# create a new dataframe to mark rows to group retaining 
# original index for each row
df_groups = pd.DataFrame({'groups': flat_group_list}, index=flat_inx)
# and join the group dataframe to the original df
df['groups'] = df_groups
# rows not belonging to a group are marked with 0
df['groups']=df['groups'].fillna(0)

# save rows not belonging to a group for later
df_untouched = df[df['groups'] == 0]
df_untouched = df_untouched.drop('groups', axis=1)

# new dataframe containg only rows belonging to a group
df_to_operate = df[df['groups']>0]
df_to_operate = df_to_operate.assign(ind=df_to_operate.index)

# at last, we group the rows according to original inx
df_grouped = df_to_operate.groupby('groups')

# calculate mean and median
# for each group we retain the index of first row of group
df_operated =df_grouped.agg({'a' : 'mean',
                             'b' : 'median',
                             'c' : 'mean',
                             'd' : 'median',
                             'ind': 'first'})

# set correct index on dataframe
df_operated=df_operated.set_index('ind')

# finally, join the previous dataframe with saved
# dataframe of rows which don't need calcullations
df_final = df_operated.combine_first(df_untouched)

旧算法，如此大量的数据太慢

这种涉及循环的算法虽然给出了正确的结果，但要花费如此长时间才能存储大量数据：

import pandas as pd

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

inx = [[1,2]]

for l in inx:
    means=df.iloc[l][['a', 'c']].mean()
    medians=df.iloc[l][['b', 'd']].median()
    df.iloc[l[0]]=pd.DataFrame([means, medians]).fillna(method='bfill').iloc[0]
    df.drop(index=l[1:], inplace=True)

在大型数据框的特定行上应用算术计算

1 个答案: