Come raggruppare le righe dei frame di dati nell'elenco nel panda groupby?


274

Ho un frame di dati Panda dfcome:

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

Voglio raggruppare per la prima colonna e ottenere la seconda colonna come elenchi in righe :

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

È possibile fare qualcosa del genere usando i panda groupby?

Risposte:


394

Puoi farlo usando groupbyper raggruppare sulla colonna di interesse e poi apply listper ogni gruppo:

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]

7
Questo richiede molto tempo se il set di dati è enorme, diciamo 10 milioni di righe. C'è un modo più veloce per farlo? Il numero di unici in 'a' è comunque intorno a 500k
Abhishek Thakur

6
il groupby è notoriamente lento e la memoria ha fame, quello che potresti fare è ordinare per colonna A, quindi trovare idxmin e idxmax (probabilmente archiviarlo in un dict) e usarlo per tagliare il tuo frame di dati sarebbe più veloce credo
EdChum

1
Quando ho provato questa soluzione con il mio problema (avere più colonne da raggruppare e da raggruppare), non ha funzionato - i panda inviati "La funzione non si riduce". Quindi ho usato la tupleseguente risposta qui: stackoverflow.com/questions/19530568/… . Vedere la seconda risposta in stackoverflow.com/questions/27439023/… per una spiegazione.
Andarin,

Questa soluzione è valida, ma esiste un modo per memorizzare un set di elenchi, il che significa che posso rimuovere i duplicati e quindi memorizzarli?
Sriram Arvind Lakshmanakumar,

1
@PoeteMaudit Siamo spiacenti, non capisco cosa stai facendo e porre domande nei commenti è una cattiva forma in SO. Stai chiedendo come concatenare più colonne in un unico elenco?
EdChum,

47

Se le prestazioni sono importanti, scendi al livello intorpidito:

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

test:

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

8
Come potremmo usarlo se stiamo raggruppando due o più chiavi, ad es. Con .groupby([df.index.month, df.index.day])invece di solo .groupby('a')?
ru111,

25

Un modo pratico per raggiungere questo obiettivo sarebbe:

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

Cerca nella scrittura Aggregazioni personalizzate: https://www.kaggle.com/akshaysehgal/how-to-group-by-aggregate-using-py


5
lambda args: f(args)equivale af
BallpointBen,

6
In realtà, agg(list)è abbastanza. Vedere anche qui .
cs95,

!! Cercavo solo qualche sintassi e mi sono reso conto che il mio notebook era referenziato per la soluzione lol. Grazie per aver collegato questo. Solo per aggiungere, dal momento che 'list' non è una funzione in serie, dovrai usarlo con apply df.groupby('a').apply(list)o usarlo con agg come parte di un dict df.groupby('a').agg({'b':list}). Potresti anche usarlo con lambda (che raccomando) poiché puoi fare molto di più con esso. Esempio: df.groupby('a').agg({'c':'first', 'b': lambda x: x.unique().tolist()})che consente di applicare una funzione serie alla colonna e una funzione unica quindi una lista alla colonna.
Akshay Sehgal

21

Come stavi dicendo, il groupbymetodo di un pd.DataFrameoggetto può fare il lavoro.

Esempio

 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]}

che fornisce e una descrizione indicizzata dei gruppi.

Per ottenere elementi di singoli gruppi, è possibile, ad esempio

 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

21

Per risolvere il problema per diverse colonne di un frame di dati:

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]

Questa risposta è stata ispirata dalla risposta di Anamika Modi . Grazie!


12

Utilizzare una delle seguenti groupbye aggricette.

# 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

Per aggregare più colonne come elenchi, utilizzare uno dei seguenti:

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]

Per elencare in gruppo solo una singola colonna, converti il ​​groupby in un SeriesGroupByoggetto, quindi chiama SeriesGroupBy.agg. Uso,

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

i metodi sopra indicati sono garantiti per preservare l'ordine? il che significa che gli elementi della stessa riga (ma diverse colonne, b e c nel codice sopra) avrà lo stesso indice nelle liste risultante?
Kai,

@Kai oh, bella domanda. Sì e no. GroupBy ordina l'output in base ai valori della chiave della cernia. Tuttavia, l'ordinamento è generalmente stabile, quindi viene mantenuto l'ordinamento relativo per gruppo. Per disabilitare del tutto il comportamento di ordinamento, utilizzare groupby(..., sort=False). Qui, non farebbe alcuna differenza dal momento che sto raggruppando sulla colonna A che è già ordinata.
cs95,

mi dispiace, non capisco la tua risposta. Puoi spiegare in modo più dettagliato. Penso che questo meriti una sua domanda ...
Kai

1
Questa è un'ottima risposta! C'è anche un modo per rendere unici i valori dell'elenco? qualcosa come .agg (pd.Series.tolist.unique) forse?
Federico Gentile,

1
@FedericoGentile puoi usare una lambda. Ecco un modo:df.groupby('a')['b'].agg(lambda x: list(set(x)))
cs95

7

Se stai cercando un elenco univoco mentre raggruppi più colonne, questo potrebbe probabilmente aiutare:

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

2

Usiamo df.groupbycon lista e Seriescostruttore

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

2

È tempo di usare agg invece di apply.

quando

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

Se si desidera impilare più colonne nell'elenco, il risultato è pd.DataFrame

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

Se si desidera una singola colonna nell'elenco, ottenere ps.Series

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

Nota, il risultato pd.DataFrameè circa 10 volte più lento del risultato ps.Seriesquando si aggrega solo una singola colonna, la si usa in maiuscole e minuscole.


0

Qui ho raggruppato gli elementi con "|" come separatore

    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]

0

Il modo più semplice che ho visto non raggiunge quasi la stessa cosa almeno per una colonna che è simile alla risposta di Anamika solo con la sintassi tupla per la funzione aggregata.

df.groupby('a').agg(b=('b','unique'), c=('c','unique'))
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.