Pandas groupby: Comment obtenir une union de chaînes

J'ai un dataframe comme celui-ci:

   A         B       C
0  1  0.749065    This
1  2  0.301084      is
2  3  0.463468       a
3  4  0.643961  random
4  1  0.866521  string
5  2  0.120737       !

Appel

In [10]: print df.groupby("A")["B"].sum()

reviendra

A
1    1.615586
2    0.421821
3    0.463468
4    0.643961

Maintenant, je voudrais faire "la même chose" pour la colonne "C". Étant donné que cette colonne contient des chaînes, sum () ne fonctionne pas (bien que vous puissiez penser que cela concaténerait les chaînes). Ce que j'aimerais vraiment voir, c'est une liste ou un ensemble de chaînes pour chaque groupe, c'est-à-dire

A
1    {This, string}
2    {is, !}
3    {a}
4    {random}

J'ai essayé de trouver des moyens de le faire.

Series.unique () ( http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.unique.html ) ne fonctionne pas, bien que

df.groupby("A")["B"]

est un

pandas.core.groupby.SeriesGroupBy object

donc j'espérais que n'importe quelle méthode de série fonctionnerait. Des idées?

In [4]: df = read_csv(StringIO(data),sep='\s+')

In [5]: df
Out[5]: 
   A         B       C
0  1  0.749065    This
1  2  0.301084      is
2  3  0.463468       a
3  4  0.643961  random
4  1  0.866521  string
5  2  0.120737       !

In [6]: df.dtypes
Out[6]: 
A      int64
B    float64
C     object
dtype: object

Lorsque vous appliquez votre propre fonction, il n'y a pas d'exclusion automatique des colonnes non numériques. Ceci est plus lent, cependant, que l'application de .sum()lagroupby

In [8]: df.groupby('A').apply(lambda x: x.sum())
Out[8]: 
   A         B           C
A                         
1  2  1.615586  Thisstring
2  4  0.421821         is!
3  3  0.463468           a
4  4  0.643961      random

sum par défaut concatène

In [9]: df.groupby('A')['C'].apply(lambda x: x.sum())
Out[9]: 
A
1    Thisstring
2           is!
3             a
4        random
dtype: object

Tu peux faire à peu près ce que tu veux

In [11]: df.groupby('A')['C'].apply(lambda x: "{%s}" % ', '.join(x))
Out[11]: 
A
1    {This, string}
2           {is, !}
3               {a}
4          {random}
dtype: object

Faire cela sur une image entière, un groupe à la fois. La clé est de retourner unSeries

def f(x):
     return Series(dict(A = x['A'].sum(), 
                        B = x['B'].sum(), 
                        C = "{%s}" % ', '.join(x['C'])))

In [14]: df.groupby('A').apply(f)
Out[14]: 
   A         B               C
A                             
1  2  1.615586  {This, string}
2  4  0.421821         {is, !}
3  3  0.463468             {a}
4  4  0.643961        {random}

Vous pouvez utiliser la applyméthode pour appliquer une fonction arbitraire aux données groupées. Donc, si vous voulez un ensemble, postulez set. Si vous voulez une liste, postulez list.

>>> d
   A       B
0  1    This
1  2      is
2  3       a
3  4  random
4  1  string
5  2       !
>>> d.groupby('A')['B'].apply(list)
A
1    [This, string]
2           [is, !]
3               [a]
4          [random]
dtype: object

Si vous voulez autre chose, écrivez simplement une fonction qui fait ce que vous voulez et ensuite applycela.

Vous pourrez peut-être utiliser la fonction aggregate(ou agg) pour concaténer les valeurs. (Code non testé)

df.groupby('A')['B'].agg(lambda col: ''.join(col))

Vous pouvez essayer ceci:

df.groupby('A').agg({'B':'sum','C':'-'.join})

une solution simple serait:

>>> df.groupby(['A','B']).c.unique().reset_index()

Agrégations nommées avec pandas >= 0.25.0

Depuis la version 0.25.0 de pandas, nous avons nommé des agrégations où nous pouvons grouper, agréger et en même temps attribuer de nouveaux noms à nos colonnes. De cette façon, nous n'obtiendrons pas les colonnes MultiIndex, et les noms de colonne ont plus de sens étant donné les données qu'ils contiennent:

agréger et obtenir une liste de chaînes

grp = df.groupby('A').agg(B_sum=('B','sum'),
                          C=('C', list)).reset_index()

print(grp)
   A     B_sum               C
0  1  1.615586  [This, string]
1  2  0.421821         [is, !]
2  3  0.463468             [a]
3  4  0.643961        [random]

agréger et joindre les chaînes

grp = df.groupby('A').agg(B_sum=('B','sum'),
                          C=('C', ', '.join)).reset_index()

print(grp)
   A     B_sum             C
0  1  1.615586  This, string
1  2  0.421821         is, !
2  3  0.463468             a
3  4  0.643961        random

Si vous souhaitez écraser la colonne B dans le dataframe, cela devrait fonctionner:

    df = df.groupby('A',as_index=False).agg(lambda x:'\n'.join(x))

Suite à la bonne réponse de @ Erfan, la plupart du temps, dans une analyse de valeurs agrégées, vous voulez les combinaisons uniques possibles de ces valeurs de caractères existantes:

unique_chars = lambda x: ', '.join(x.unique())
(df
 .groupby(['A'])
 .agg({'C': unique_chars}))