Quelle est la différence entre les pandas agg et appliquer la fonction?

Je ne peux pas comprendre la différence entre les Pandas .aggregate et .apply fonctions.
Prendre le suivant comme exemple: je charge un jeu de données, faire un groupby, de définir une fonction simple,
et de l'utilisateur .agg ou .apply.

Comme vous pouvez le voir, l'impression de la déclaration dans mes résultats de la fonction dans la même sortie
après l'utilisation de .agg et .apply. Le résultat, sur l'autre main est différente. Pourquoi est-ce?

import pandas
import pandas as pd
iris = pd.read_csv('iris.csv')
by_species = iris.groupby('Species')
def f(x):
    ...:     print type(x)
    ...:     print x.head(3)
    ...:     return 1

À l'aide de apply:

by_species.apply(f)
#<class 'pandas.core.frame.DataFrame'>
#   Sepal.Length  Sepal.Width  Petal.Length  Petal.Width Species
#0           5.1          3.5           1.4          0.2  setosa
#1           4.9          3.0           1.4          0.2  setosa
#2           4.7          3.2           1.3          0.2  setosa
#<class 'pandas.core.frame.DataFrame'>
#   Sepal.Length  Sepal.Width  Petal.Length  Petal.Width Species
#0           5.1          3.5           1.4          0.2  setosa
#1           4.9          3.0           1.4          0.2  setosa
#2           4.7          3.2           1.3          0.2  setosa
#<class 'pandas.core.frame.DataFrame'>
#    Sepal.Length  Sepal.Width  Petal.Length  Petal.Width     Species
#50           7.0          3.2           4.7          1.4  versicolor
#51           6.4          3.2           4.5          1.5  versicolor
#52           6.9          3.1           4.9          1.5  versicolor
#<class 'pandas.core.frame.DataFrame'>
#     Sepal.Length  Sepal.Width  Petal.Length  Petal.Width    Species
#100           6.3          3.3           6.0          2.5  virginica
#101           5.8          2.7           5.1          1.9  virginica
#102           7.1          3.0           5.9          2.1  virginica
#Out[33]: 
#Species
#setosa        1
#versicolor    1
#virginica     1
#dtype: int64

À l'aide de agg

by_species.agg(f)
#<class 'pandas.core.frame.DataFrame'>
#   Sepal.Length  Sepal.Width  Petal.Length  Petal.Width Species
#0           5.1          3.5           1.4          0.2  setosa
#1           4.9          3.0           1.4          0.2  setosa
#2           4.7          3.2           1.3          0.2  setosa
#<class 'pandas.core.frame.DataFrame'>
#    Sepal.Length  Sepal.Width  Petal.Length  Petal.Width     Species
#50           7.0          3.2           4.7          1.4  versicolor
#51           6.4          3.2           4.5          1.5  versicolor
#52           6.9          3.1           4.9          1.5  versicolor
#<class 'pandas.core.frame.DataFrame'>
#     Sepal.Length  Sepal.Width  Petal.Length  Petal.Width    Species
#100           6.3          3.3           6.0          2.5  virginica
#101           5.8          2.7           5.1          1.9  virginica
#102           7.1          3.0           5.9          2.1  virginica
#Out[34]: 
#           Sepal.Length  Sepal.Width  Petal.Length  Petal.Width
#Species                                                         
#setosa                 1            1             1            1
#versicolor             1            1             1            1
#virginica              1            1             1            1

source d'informationauteur David D

  1. 19

    apply applique la fonction de chaque groupe (votre Species). Votre fonction retourne 1, si vous vous retrouvez avec 1 valeur pour chacun des 3 groupes.

    agg agrégats chaque colonne (long métrage) pour chaque groupe, si vous vous retrouvez avec une valeur par colonne par groupe.

    Lire la groupe docs, ils sont très utiles. Il y a aussi un tas de tutoriels flottant autour de l'internet.

  2. 8

    ( Remarque: Ces comparaisons sont pertinents pour DataframeGroupby objets )

    Certains plausible avantages de l'utilisation .apa() par rapport à .appliquer(), pour DataFrame Grouper des objets serait:

    1) .apa() donne la flexibilité de de l'application de plusieurs fonctions à la foisou de passer d'une liste de fonction pour chaque colonne.

    2) Aussi, à l'application de différentes fonctions à la fois des différentes colonnes de dataframe.

    Cela signifie que vous avez beaucoup de contrôle sur chaque colonne de chaque exploitation.

    Voici le lien pour plus de détails: http://pandas.pydata.org/pandas-docs/version/0.13.1/groupby.html

    Cependant, appliquer la fonction pourrait être limitée à appliquer une fonction à chacune des colonnes du dataframe à la fois. Donc, vous pourriez avoir à appeler à l'application de fonction à plusieurs reprises de faire appel à différentes opérations à la même colonne.

    Ici, sont quelques exemple de comparaison .appliquer() vs .apa() pour DataframeGroupBy objets :

    Permet, d'abord, de voir les opérations à l'aide .appliquer( ):

    In [261]: df = pd.DataFrame({"name":["Foo", "Baar", "Foo", "Baar"], "score_1":[5,10,15,10], "score_2" :[10,15,10,25], "score_3" : [10,20,30,40]})

In [262]: df
Out[262]: 
   name  score_1  score_2  score_3
0   Foo        5       10       10
1  Baar       10       15       20
2   Foo       15       10       30
3  Baar       10       25       40

In [263]: df.groupby(["name", "score_1"])["score_2"].apply(lambda x : x.sum())
Out[263]: 
name  score_1
Baar  10         40
Foo   5          10
      15         10
Name: score_2, dtype: int64

In [264]: df.groupby(["name", "score_1"])["score_2"].apply(lambda x : x.min())
Out[264]: 
name  score_1
Baar  10         15
Foo   5          10
      15         10
Name: score_2, dtype: int64

In [265]: df.groupby(["name", "score_1"])["score_2"].apply(lambda x : x.mean())
Out[265]: 
name  score_1
Baar  10         20.0
Foo   5          10.0
      15         10.0
Name: score_2, dtype: float64

    Maintenant, regardez la mêmes opérations à l'aide .apa( ) sans effort:

    In [274]: df = pd.DataFrame({"name":["Foo", "Baar", "Foo", "Baar"], "score_1":[5,10,15,10], "score_2" :[10,15,10,25], "score_3" : [10,20,30,40]})

In [275]: df
Out[275]: 
   name  score_1  score_2  score_3
0   Foo        5       10       10
1  Baar       10       15       20
2   Foo       15       10       30
3  Baar       10       25       40

In [276]: df.groupby(["name", "score_1"]).agg({"score_3" :[np.sum, np.min, np.mean, np.max], "score_2":lambda x : x.mean()})
Out[276]: 
              score_2 score_3               
             <lambda>     sum amin mean amax
name score_1                                
Baar 10            20      60   20   30   40
Foo  5             10      10   10   10   10
     15            10      30   30   30   30

    Donc .apa( ) pourrait être vraiment pratique à la manipulation de la DataFrameGroupBy objets, comme par rapport à .appliquer( ). Mais, si vous manipulez seulement pur dataframe objets, et pas DataFrameGroupBy les objets, puis appliquer() peut être très utile, comme appliquer( ) peut appliquer une fonction le long de tout axe de la dataframe.

    (Pour exemple: l'axe = 0 implique les colonnes de l'opération .appliquer(), qui est un mode par défaut, et axis = 1 implique pour ligne-sage de l'opération tout en traitant avec de la pure dataframe objets )