如何将数据帧行分组到 pandas groupby 中的列表中答案

【问题标题】：How to group dataframe rows into list in pandas groupby如何将数据帧行分组到 pandas groupby 中的列表中
【发布时间】：2023-01-30 16:21:40
【问题描述】：

我有一个 pandas 数据框df，比如：

a b
A 1
A 2
B 5
B 5
B 4
C 6

我想要按第一列分组并将第二列作为行列表:

A [1,2]
B [5,5,4]
C [6]

是否可以使用 pandas groupby 做这样的事情？

【问题讨论】：

想象一个场景，如果 A 的元素列表的总和超过 10，我想添加另一个 A 记录。如何实现？

标签： python pandas list aggregate pandas-groupby

【解决方案1】：

您可以使用 groupby 对感兴趣的列进行分组，然后使用 apply list 对每个组进行分组：

In [1]: df = pd.DataFrame( {'a':['A','A','B','B','B','C'], 'b':[1,2,5,5,4,6]})
        df

Out[1]: 
   a  b
0  A  1
1  A  2
2  B  5
3  B  5
4  B  4
5  C  6

In [2]: df.groupby('a')['b'].apply(list)
Out[2]: 
a
A       [1, 2]
B    [5, 5, 4]
C          [6]
Name: b, dtype: object

In [3]: df1 = df.groupby('a')['b'].apply(list).reset_index(name='new')
        df1
Out[3]: 
   a        new
0  A     [1, 2]
1  B  [5, 5, 4]
2  C        [6]

【讨论】：

如果数据集很大，比如 1000 万行，这会花费很多时间。有没有更快的方法来做到这一点？然而，“a”中的唯一身份数量约为 500k
groupby 是出了名的慢而且内存不足，你可以做的是按 A 列排序，然后找到 idxmin 和 idxmax（可能将其存储在字典中）并使用它来切片你的数据帧我认为会更快
当我针对我的问题尝试此解决方案时（有多个列用于 groupBy 和分组），它不起作用 - 熊猫发送“功能不减少”。然后我在第二个答案之后使用了tuple：stackoverflow.com/questions/19530568/…。请参阅stackoverflow.com/questions/27439023/… 中的第二个答案以获取解释。
@PoeteMaudit 抱歉，我不明白你在问什么，在 cmets 中提问在 SO 中是错误的形式。您是在问如何将多个列连接成一个列表吗？
有没有办法一次做多列？ df1 = df.groupby('a')['b','c'].apply(list).reset_index(name='new')

【解决方案2】：

一个方便的方法来实现这一点是：

df.groupby('a').agg({'b':lambda x: list(x)})

考虑编写自定义聚合：https://www.kaggle.com/akshaysehgal/how-to-group-by-aggregate-using-py

【讨论】：

lambda args: f(args)等同于f
其实agg(list)就够了。另见here。
！！我只是在谷歌上搜索一些语法，然后意识到解决方案引用了我自己的笔记本，哈哈。感谢您链接此。只是补充一点，因为'list'不是一个系列函数，你必须将它与apply df.groupby('a').apply(list)一起使用，或者将它与agg一起用作dict df.groupby('a').agg({'b':list})的一部分。您也可以将它与 lambda（我推荐）一起使用，因为您可以用它做更多的事情。示例：df.groupby('a').agg({'c':'first', 'b': lambda x: x.unique().tolist()})，它允许您将一个系列函数应用于 col c，并将一个唯一的列表函数应用于 col b。

【解决方案3】：

如果性能很重要，请降低到 numpy 级别：

import numpy as np

df = pd.DataFrame({'a': np.random.randint(0, 60, 600), 'b': [1, 2, 5, 5, 4, 6]*100})

def f(df):
         keys, values = df.sort_values('a').values.T
         ukeys, index = np.unique(keys, True)
         arrays = np.split(values, index[1:])
         df2 = pd.DataFrame({'a':ukeys, 'b':[list(a) for a in arrays]})
         return df2

测试：

In [301]: %timeit f(df)
1000 loops, best of 3: 1.64 ms per loop

In [302]: %timeit df.groupby('a')['b'].apply(list)
100 loops, best of 3: 5.26 ms per loop

【讨论】：

如果我们按两个或多个键分组，我们如何使用它，例如用.groupby([df.index.month, df.index.day])而不是.groupby('a')？
@ru111 我在下面添加了一个 answer，您可能想查看它。它还处理多列分组

【解决方案4】：

要为数据框的多列解决此问题：

In [5]: df = pd.DataFrame( {'a':['A','A','B','B','B','C'], 'b':[1,2,5,5,4,6],'c'
   ...: :[3,3,3,4,4,4]})

In [6]: df
Out[6]: 
   a  b  c
0  A  1  3
1  A  2  3
2  B  5  3
3  B  5  4
4  B  4  4
5  C  6  4

In [7]: df.groupby('a').agg(lambda x: list(x))
Out[7]: 
           b          c
a                      
A     [1, 2]     [3, 3]
B  [5, 5, 4]  [3, 4, 4]
C        [6]        [4]

这个答案的灵感来自于Anamika Modi的回答。谢谢！

【讨论】：

【解决方案5】：

使用以下任何groupby 和agg 食谱。

# Setup
df = pd.DataFrame({
  'a': ['A', 'A', 'B', 'B', 'B', 'C'],
  'b': [1, 2, 5, 5, 4, 6],
  'c': ['x', 'y', 'z', 'x', 'y', 'z']
})
df

   a  b  c
0  A  1  x
1  A  2  y
2  B  5  z
3  B  5  x
4  B  4  y
5  C  6  z

要将多个列聚合为列表，请使用以下任一方法：

df.groupby('a').agg(list)
df.groupby('a').agg(pd.Series.tolist)

           b          c
a                      
A     [1, 2]     [x, y]
B  [5, 5, 4]  [z, x, y]
C        [6]        [z]

要仅对单个列进行分组列表，请将 groupby 转换为 SeriesGroupBy 对象，然后调用 SeriesGroupBy.agg。利用，

df.groupby('a').agg({'b': list})  # 4.42 ms 
df.groupby('a')['b'].agg(list)    # 2.76 ms - faster

a
A       [1, 2]
B    [5, 5, 4]
C          [6]
Name: b, dtype: object

【讨论】：

是上面的方法保证维持秩序？意味着来自同一行的元素（但不同的列，b和C在上面的代码中）将在结果列表中具有相同的索引？
@Kai哦，好问题。是和不是。 GroupBy 按石斑鱼键值对输出进行排序。然而，排序通常是稳定的，因此每组的相对顺序得以保留。要完全禁用排序行为，请使用groupby(..., sort=False)。在这里，这没有什么区别，因为我在已经排序的 A 列上进行分组。
这是一个非常好的答案！还有一种方法可以使列表的值唯一吗？可能是 .agg(pd.Series.tolist.unique) 之类的东西？
@FedericoGentile 你可以使用 lambda。这是一种方式：df.groupby('a')['b'].agg(lambda x: list(set(x)))
@Moondra 不确定，也许你想要df.groupby('a').agg(lambda x: x.to_numpy().ravel().tolist())

【解决方案6】：

正如您所说，pd.DataFrame 对象的 groupby 方法可以完成这项工作。

例子

 L = ['A','A','B','B','B','C']
 N = [1,2,5,5,4,6]

 import pandas as pd
 df = pd.DataFrame(zip(L,N),columns = list('LN'))


 groups = df.groupby(df.L)

 groups.groups
      {'A': [0, 1], 'B': [2, 3, 4], 'C': [5]}

它给出了组的索引描述。

要获取单个组的元素，您可以这样做，例如

 groups.get_group('A')

     L  N
  0  A  1
  1  A  2

  groups.get_group('B')

     L  N
  2  B  5
  3  B  5
  4  B  4

【讨论】：

【解决方案7】：

是时候使用 agg 而不是 apply 了。

什么时候

df = pd.DataFrame( {'a':['A','A','B','B','B','C'], 'b':[1,2,5,5,4,6], 'c': [1,2,5,5,4,6]})

如果要将多列堆叠到 list 中，则结果为 pd.DataFrame

df.groupby('a')[['b', 'c']].agg(list)
# or 
df.groupby('a').agg(list)

如果你想要列表中的单列，结果为ps.Series

df.groupby('a')['b'].agg(list)
#or
df.groupby('a')['b'].apply(list)

请注意，当您仅聚合单列时，pd.DataFrame 的结果比ps.Series 的结果慢约 10 倍，在多列情况下使用它。

【讨论】：

【解决方案8】：

只是一个补充。 pandas.pivot_table更通用也更方便：

"""data"""
df = pd.DataFrame( {'a':['A','A','B','B','B','C'],
                    'b':[1,2,5,5,4,6],
                    'c':[1,2,1,1,1,6]})
print(df)

   a  b  c
0  A  1  1
1  A  2  2
2  B  5  1
3  B  5  1
4  B  4  1
5  C  6  6

"""pivot_table"""
pt = pd.pivot_table(df,
                    values=['b', 'c'],
                    index='a',
                    aggfunc={'b': list,
                             'c': set})
print(pt)
           b       c
a                   
A     [1, 2]  {1, 2}
B  [5, 5, 4]     {1}
C        [6]     {6}

【讨论】：

【解决方案9】：

如果寻找一个独特列表在对多列进行分组时，这可能会有所帮助：

df.groupby('a').agg(lambda x: list(set(x))).reset_index()

【讨论】：

【解决方案10】：

在@B.M answer 的基础上，这是一个更通用的版本，并已更新以配合使用较新的库版本: (numpy 版本1.19.2，熊猫版本1.2.1) 而且这个解决方案还可以处理多指标:

但是，这没有经过严格测试，请谨慎使用。

如果性能很重要，请降低到 numpy 级别：

import pandas as pd
import numpy as np

np.random.seed(0)
df = pd.DataFrame({'a': np.random.randint(0, 10, 90), 'b': [1,2,3]*30, 'c':list('abcefghij')*10, 'd': list('hij')*30})


def f_multi(df,col_names):
    if not isinstance(col_names,list):
        col_names = [col_names]
        
    values = df.sort_values(col_names).values.T

    col_idcs = [df.columns.get_loc(cn) for cn in col_names]
    other_col_names = [name for idx, name in enumerate(df.columns) if idx not in col_idcs]
    other_col_idcs = [df.columns.get_loc(cn) for cn in other_col_names]

    # split df into indexing colums(=keys) and data colums(=vals)
    keys = values[col_idcs,:]
    vals = values[other_col_idcs,:]
    
    # list of tuple of key pairs
    multikeys = list(zip(*keys))
    
    # remember unique key pairs and ther indices
    ukeys, index = np.unique(multikeys, return_index=True, axis=0)
    
    # split data columns according to those indices
    arrays = np.split(vals, index[1:], axis=1)

    # resulting list of subarrays has same number of subarrays as unique key pairs
    # each subarray has the following shape:
    #    rows = number of non-grouped data columns
    #    cols = number of data points grouped into that unique key pair
    
    # prepare multi index
    idx = pd.MultiIndex.from_arrays(ukeys.T, names=col_names) 

    list_agg_vals = dict()
    for tup in zip(*arrays, other_col_names):
        col_vals = tup[:-1] # first entries are the subarrays from above 
        col_name = tup[-1]  # last entry is data-column name
        
        list_agg_vals[col_name] = col_vals

    df2 = pd.DataFrame(data=list_agg_vals, index=idx)
    return df2

测试：

In [227]: %timeit f_multi(df, ['a','d'])

2.54 ms ± 64.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [228]: %timeit df.groupby(['a','d']).agg(list)

4.56 ms ± 61.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

结果：

对于随机种子 0，一个人会得到：

【讨论】：

很好的答案。请分享示例，如果您只需要一列而不是多列

【解决方案11】：

我发现实现相同目的的最简单方法，至少对于一列，类似于Anamika's answer，只是使用聚合函数的元组语法。

df.groupby('a').agg(b=('b','unique'), c=('c','unique'))

【讨论】：

【解决方案12】：

让我们将 df.groupby 与列表和 Series 构造函数一起使用

pd.Series({x : y.b.tolist() for x , y in df.groupby('a')})
Out[664]: 
A       [1, 2]
B    [5, 5, 4]
C          [6]
dtype: object

【讨论】：

【解决方案13】：

在这里，我用“|”对元素进行了分组作为分隔符

    import pandas as pd

    df = pd.read_csv('input.csv')

    df
    Out[1]:
      Area  Keywords
    0  A  1
    1  A  2
    2  B  5
    3  B  5
    4  B  4
    5  C  6

    df.dropna(inplace =  True)
    df['Area']=df['Area'].apply(lambda x:x.lower().strip())
    print df.columns
    df_op = df.groupby('Area').agg({"Keywords":lambda x : "|".join(x)})

    df_op.to_csv('output.csv')
    Out[2]:
    df_op
    Area  Keywords

    A       [1| 2]
    B    [5| 5| 4]
    C          [6]

【讨论】：

【解决方案14】：

答案基于@EdChum 对他的回答的评论。评论是这样的——

groupby is notoriously slow and memory hungry, what you could do is sort by column A, then find the idxmin and idxmax (probably store this in a dict) and use this to slice your dataframe would be faster I think

让我们首先创建一个数据框，第一列有 500k 个类别，总 df 形状为 2000 万，如问题所述。

df = pd.DataFrame(columns=['a', 'b'])
df['a'] = (np.random.randint(low=0, high=500000, size=(20000000,))).astype(str)
df['b'] = list(range(20000000))
print(df.shape)
df.head()

# Sort data by first column 
df.sort_values(by=['a'], ascending=True, inplace=True)
df.reset_index(drop=True, inplace=True)

# Create a temp column
df['temp_idx'] = list(range(df.shape[0]))

# Take all values of b in a separate list
all_values_b = list(df.b.values)
print(len(all_values_b))

# For each category in column a, find min and max indexes
gp_df = df.groupby(['a']).agg({'temp_idx': [np.min, np.max]})
gp_df.reset_index(inplace=True)
gp_df.columns = ['a', 'temp_idx_min', 'temp_idx_max']

# Now create final list_b column, using min and max indexes for each category of a and filtering list of b. 
gp_df['list_b'] = gp_df[['temp_idx_min', 'temp_idx_max']].apply(lambda x: all_values_b[x[0]:x[1]+1], axis=1)

print(gp_df.shape)
gp_df.head()

对于第一列中的 2000 万行和 50 万个类别，上面的代码需要 2 分钟。

【讨论】：

【解决方案15】：

排序消耗O(nlog(n))时间，这是上面建议的解决方案中最耗时的操作

对于一个简单的解决方案（包含单列）pd.Series.to_list 可以工作并且可以被认为更有效，除非考虑其他框架

例如

import pandas as pd
from string import ascii_lowercase
import random

def generate_string(case=4):
    return ''.join([random.choice(ascii_lowercase) for _ in range(case)])

df = pd.DataFrame({'num_val':[random.randint(0,100) for _ in range(20000000)],'string_val':[generate_string() for _ in range(20000000)]})


%timeit df.groupby('string_val').agg({'num_val':pd.Series.to_list})

对于 2000 万条记录，大约需要 17.2 seconds。与apply(list)相比，它需要大约19.2，而lambda函数需要大约20.6s

【讨论】：

【解决方案16】：

只是为了增加以前的答案，就我而言，我想要列表和其他功能，如min和max。这样做的方法是：

df = pd.DataFrame({
    'a':['A','A','B','B','B','C'], 
    'b':[1,2,5,5,4,6]
})

df=df.groupby('a').agg({
    'b':['min', 'max',lambda x: list(x)]
})

#then flattening and renaming if necessary
df.columns = df.columns.to_flat_index()
df.rename(columns={('b', 'min'): 'b_min', ('b', 'max'): 'b_max', ('b', '<lambda_0>'): 'b_list'},inplace=True)

【讨论】：