假设我们有一个具有大行数（1600000X4）的数据框（df）。此外，我们还有一个列表，例如：
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个元素）。
编辑：避免LOOPS的新方法
下面你会发现一种依赖熊猫和避免循环的方法。
生成一些与你的大小相同的假数据后，我基本上会从你的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)
老ALGO，因为太多的数据太慢了
这个涉及循环的算法通过给出正确的结果，需要很长时间才能获得如此大量的数据：
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)