Pandas sort by group aggregate and column (tri par groupe, agrégat et colonne)

Question

Étant donné la base de données suivante

In [31]: rand = np.random.RandomState(1)
         df = pd.DataFrame({'A': ['foo', 'bar', 'baz'] * 2,
                            'B': rand.randn(6),
                            'C': rand.rand(6) > .5})

In [32]: df
Out[32]:      A         B      C
         0  foo  1.624345  False
         1  bar -0.611756   True
         2  baz -0.528172  False
         3  foo -1.072969   True
         4  bar  0.865408  False
         5  baz -2.301539   True 

J'aimerais les classer par groupes ( A ) par la somme agrégée de B et ensuite par la valeur de C (non agrégé). Il s'agit donc d'obtenir l'ordre des A les groupes avec

In [28]: df.groupby('A').sum().sort('B')
Out[28]:             B  C
         A               
         baz -2.829710  1
         bar  0.253651  1
         foo  0.551377  1

Puis par Vrai/Faux, de sorte qu'il ressemble finalement à ceci :

In [30]: df.ix[[5, 2, 1, 4, 3, 0]]
Out[30]: A         B      C
    5  baz -2.301539   True
    2  baz -0.528172  False
    1  bar -0.611756   True
    4  bar  0.865408  False
    3  foo -1.072969   True
    0  foo  1.624345  False

Comment procéder ?

Answer 1

Groupe A :

In [0]: grp = df.groupby('A')

Au sein de chaque groupe, faites la somme de B et diffusez les valeurs à l'aide de transform. Trier ensuite par B :

In [1]: grp[['B']].transform(sum).sort('B')
Out[1]:
          B
2 -2.829710
5 -2.829710
1  0.253651
4  0.253651
0  0.551377
3  0.551377

Indexer le fichier d'origine en lui passant l'index ci-dessus. Cela permet de réorganiser les valeurs A en fonction de la somme globale des valeurs B :

In [2]: sort1 = df.ix[grp[['B']].transform(sum).sort('B').index]

In [3]: sort1
Out[3]:
     A         B      C
2  baz -0.528172  False
5  baz -2.301539   True
1  bar -0.611756   True
4  bar  0.865408  False
0  foo  1.624345  False
3  foo -1.072969   True

Enfin, triez les valeurs "C" dans les groupes "A" à l'aide de la fonction sort=False pour conserver l'ordre de tri A de l'étape 1 :

In [4]: f = lambda x: x.sort('C', ascending=False)

In [5]: sort2 = sort1.groupby('A', sort=False).apply(f)

In [6]: sort2
Out[6]:
         A         B      C
A
baz 5  baz -2.301539   True
    2  baz -0.528172  False
bar 1  bar -0.611756   True
    4  bar  0.865408  False
foo 3  foo -1.072969   True
    0  foo  1.624345  False

Nettoyez l'index df en utilisant reset_index avec drop=True :

In [7]: sort2.reset_index(0, drop=True)
Out[7]:
     A         B      C
5  baz -2.301539   True
2  baz -0.528172  False
1  bar -0.611756   True
4  bar  0.865408  False
3  foo -1.072969   True
0  foo  1.624345  False

Answer 2

Voici une approche plus concise...

df['a_bsum'] = df.groupby('A')['B'].transform(sum)
df.sort(['a_bsum','C'], ascending=[True, False]).drop('a_bsum', axis=1)

La première ligne ajoute une colonne au cadre de données avec la somme par groupe. La deuxième ligne effectue le tri et supprime la colonne supplémentaire.

Résultat :

    A       B           C
5   baz     -2.301539   True
2   baz     -0.528172   False
1   bar     -0.611756   True
4   bar      0.865408   False
3   foo     -1.072969   True
0   foo      1.624345   False

NOTE : sort est obsolète, utilisez sort_values au lieu de

Answer 3

Une façon de procéder est d'insérer une colonne fictive avec les sommes afin de les trier :

In [10]: sum_B_over_A = df.groupby('A').sum().B

In [11]: sum_B_over_A
Out[11]: 
A
bar    0.253652
baz   -2.829711
foo    0.551376
Name: B

in [12]: df['sum_B_over_A'] = df.A.apply(sum_B_over_A.get_value)

In [13]: df
Out[13]: 
     A         B      C  sum_B_over_A
0  foo  1.624345  False      0.551376
1  bar -0.611756   True      0.253652
2  baz -0.528172  False     -2.829711
3  foo -1.072969   True      0.551376
4  bar  0.865408  False      0.253652
5  baz -2.301539   True     -2.829711

In [14]: df.sort(['sum_B_over_A', 'A', 'B'])
Out[14]: 
     A         B      C   sum_B_over_A
5  baz -2.301539   True      -2.829711
2  baz -0.528172  False      -2.829711
1  bar -0.611756   True       0.253652
4  bar  0.865408  False       0.253652
3  foo -1.072969   True       0.551376
0  foo  1.624345  False       0.551376

et peut-être que vous laisseriez tomber la ligne fictive :

In [15]: df.sort(['sum_B_over_A', 'A', 'B']).drop('sum_B_over_A', axis=1)
Out[15]: 
     A         B      C
5  baz -2.301539   True
2  baz -0.528172  False
1  bar -0.611756   True
4  bar  0.865408  False
3  foo -1.072969   True
0  foo  1.624345  False

Answer 4

La question est difficile à comprendre. Cependant, il faut regrouper par A et additionner par B puis trier les valeurs en ordre décroissant. L'ordre de tri de la colonne A dépend de B. Vous pouvez alors utiliser le filtrage pour créer un nouveau dataframe en filtrant par les valeurs de A pour ordonner le dataframe.

rand = np.random.RandomState(1)
df = pd.DataFrame({'A': ['foo', 'bar', 'baz'] * 2,
                        'B': rand.randn(6),
                        'C': rand.rand(6) > .5})
grouped=df.groupby('A')['B'].sum().sort_values(ascending=False)
print(grouped)
print(grouped.index.get_level_values(0))

Sortie :

A
foo    0.551377
bar    0.253651
baz   -2.829710