Python >> Tutoriel Python >  >> Python Tag >> Pandas

Pandas apply () - Un guide illustré utile

Les Pandas apply( ) La fonction est utilisée pour appliquer les fonctions sur les objets Pandas. Nous avons tellement de fonctions d'agrégation intégrées dans les pandas sur les objets Series et DataFrame. Mais, pour appliquer certaines fonctions spécifiques à l'application, nous pouvons tirer parti du apply( ) fonction. Pandas apply( ) est à la fois la méthode Series et la méthode DataFrame.

Les pandas appliquent la fonction à une colonne – appliquez () comme méthode de série

Construisons un DataFrame dans lequel nous avons les informations de 4 personnes.

>>> import pandas as pd
>>> df = pd.DataFrame(
...         {
...             'Name': ['Edward', 'Natalie', 'Chris M', 'Priyatham'],
...             'Sex' : ['M', 'F', 'M', 'M'],
...             'Age': [45, 35, 29, 26],
...             'weight(kgs)': [68.4, 58.2, 64.3, 53.1]
...         }
...     )

>>> print(df)
        Name Sex  Age  weight(kgs)
0     Edward   M   45         68.4
1    Natalie   F   35         58.2
2    Chris M   M   29         64.3
3  Priyatham   M   26         53.1

pandas.Series.apply prend l'un des deux types de fonctions ci-dessous comme argument. Ce sont :

  • Fonctions Python
  • Fonctions universelles de Numpy (ufuncs)

1. Fonctions Python

En Python, il existe 3 types de fonctions différentes en général ;

  • Fonctions intégrées
  • Fonctions définies par l'utilisateur
  • Fonctions Lambda

a) Application des fonctions intégrées de Python sur les séries

Si nous souhaitons connaître la longueur des noms de chaque personne, nous pouvons le faire en utilisant le len( ) fonction en python.

Par exemple, si nous voulons connaître la longueur de la chaîne "Python", nous pouvons obtenir par le code suivant ;

>>> len("Python")
6

Une seule colonne dans le DataFrame est un objet Series. Maintenant, nous aimerions appliquer le même len( ) fonction sur toute la colonne "Name" du DataFrame. Ceci peut être réalisé en utilisant le apply( ) fonction dans le code ci-dessous ;

>>> df['Name'].apply(len)
0    6
1    7
2    7
3    9
Name: Name, dtype: int64

Si vous observez l'extrait de code ci-dessus, le len à l'intérieur du apply( ) la fonction ne prend aucun argument. En général, toute fonction nécessite des données pour fonctionner dessus. Dans le len(“Python”) extrait de code, il prend le “Python” chaîne comme donnée d'entrée pour calculer sa longueur. Ici, les données d'entrée sont directement extraites de l'objet Series qui a appelé la fonction à l'aide de apply( ) .

Lors de l'application des fonctions Python, chaque valeur de la série est appliquée une par une et renvoie l'objet de la série.

Le processus ci-dessus peut être visualisé comme :

Dans la visualisation ci-dessus, vous pouvez observer que chaque élément de la série est appliqué à la fonction un par un.

b) Application de fonctions définies par l'utilisateur sur la série

Supposons que les données dont nous disposons remontent à un an. Donc, nous aimerions mettre à jour l'âge de chaque personne en ajoutant 1. Nous pouvons le faire en appliquant une fonction définie par l'utilisateur sur l'objet Series en utilisant le apply( ) méthode.

Le code pour cela est,

>>> def add_age(age):
...     return age + 1

>>> df['Age'].apply(add_age)
0    46
1    36
2    30
3    27
Name: Age, dtype: int64

>>> df['Age'] = df['Age'].apply(add_age)

>>> df
        Name Sex  Age  weight(kgs)
0     Edward   M   46         68.4
1    Natalie   F   36         58.2
2    Chris M   M   30         64.3
3  Priyatham   M   27         53.1

D'après le résultat ci-dessus, le point principal à noter est,

  • L'index de la série résultante est égal à l'index de l'objet Series appelant. Cela facilite le processus d'ajout de la série résultante en tant que colonne au DataFrame.

Il fonctionne de la même manière que l'application de fonctions intégrées. Chaque élément de la série est passé un par un à la fonction.

  • Les fonctions définies par l'utilisateur sont principalement utilisées lorsque nous souhaitons appliquer des fonctions complexes spécifiques à une application.

c) Application des fonctions Lambda sur la série

Les fonctions Lambda sont beaucoup utilisées avec le apply( ) méthode. Nous avons utilisé une fonction définie par l'utilisateur pour une opération d'ajout facile dans la section ci-dessus. Obtenons le même résultat en utilisant une fonction Lambda.

Le code pour cela est,

>>> df['Age'].apply(lambda x: x+1)
0    46
1    36
2    30
3    27
Name: Age, dtype: int64

>>> # Comparing the results of applying both the user-defined function and Lambda function
>>> df['Age'].apply(lambda x: x+1) == df['Age'].apply(add_age)
0    True
1    True
2    True
3    True
Name: Age, dtype: bool

À partir du résultat ci-dessus, vous pouvez observer que les résultats de l'application de la fonction définie par l'utilisateur et de la fonction Lambda sont identiques.

  • Les fonctions Lambda sont principalement utilisées lorsque nous souhaitons appliquer de petites fonctions spécifiques à l'application.

2. Les fonctions universelles de Numpy (ufuncs)

Numpy a tellement de fonctions universelles intégrées (ufuncs). Nous pouvons fournir n'importe lequel des ufuncs comme argument au apply( ) méthode sur Série. Un objet série peut être considéré comme un tableau NumPy.

La différence entre l'application de fonctions Python et ufuncs est ;

  • Lors de l'application des fonctions Python, chaque élément de la série est exploité un par un.
  • Lors de l'application des ufuncs, toute la série est exploitée en même temps.

Choisissons d'utiliser un ufunc pour plancher les valeurs à virgule flottante de la colonne de poids. Nous avons numpy.floor( ) ufunc pour y parvenir.

Le code pour cela est,

>>> import numpy as np

>>> df['weight(kgs)']
0    68.4
1    58.2
2    64.3
3    53.1
Name: weight(kgs), dtype: float64 
>>> df['weight(kgs)'].apply(np.floor)
0    68.0
1    58.0
2    64.0
3    53.0
Name: weight(kgs), dtype: float64

Dans le résultat ci-dessus, vous pouvez observer le plancher à la valeur décimale inférieure la plus proche et conserver son type de données float64.

Nous pouvons visualiser le processus ci-dessus comme :

Dans la visualisation ci-dessus, vous pouvez observer que tous les éléments de la série sont appliqués à la fonction en même temps.

  • Chaque fois que nous avons un ufunc pour réaliser notre fonctionnalité, nous pouvons l'utiliser au lieu de définir une fonction Python.

Pandas apply() en tant que méthode DataFrame

Nous allons jeter un œil à la documentation officielle du apply( ) méthode sur DataFrame :

pandas.DataFrame.apply a deux arguments importants ;

  • func – Fonction à appliquer le long de l'axe mentionné
  • axis – Axe le long duquel la fonction est appliquée

Encore une fois l'axe a aussi 2 valeurs possibles ;

  1. axis=0 – Appliquer la fonction à plusieurs colonnes
  2. axis=1 – Appliquer la fonction à chaque ligne

1. Les pandas appliquent la fonction à plusieurs colonnes

Disons que les personnes de notre ensemble de données ont fourni leurs informations de taille (en cm). Il peut être ajouté en utilisant le code suivant,

>>> df['height(cms)'] = [178, 160, 173, 168]
>>> df
        Name Sex  Age  weight(kgs)  height(cms)
0     Edward   M   45         68.4          178
1    Natalie   F   35         58.2          160
2    Chris M   M   29         64.3          173
3  Priyatham   M   26         53.1          168

Nous allons faire de la colonne "Name" l'index du DataFrame. De plus, nous obtiendrons le sous-ensemble du DataFrame avec les colonnes "Age", "weight(kgs)" et "height(cms)".

>>> data = df.set_index('Name')
>>> data
          Sex  Age  weight(kgs)  height(cms)
Name                                       
Edward      M   45         68.4          178
Natalie     F   35         58.2          160
Chris M     M   29         64.3          173
Priyatham   M   26         53.1          168

>>> data_subset = data[['Age', 'weight(kgs)', 'height(cms)']]
>>> data_subset
           Age  weight(kgs)  height(cms)
Name                                   
Edward      45         68.4          178
Natalie     35         58.2          160
Chris M     29         64.3          173
Priyatham   26         53.1          168

Si nous souhaitons obtenir l'âge, le poids et la taille moyens de toutes les personnes, nous pouvons utiliser le numpy ufunc numpy.mean( ) .

Le code pour cela est,

>>> import numpy as np
>>> data_subset.apply(np.mean, axis=0)
Age             33.75
weight(kgs)     61.00
height(cms)    169.75
dtype: float64

Nous avons directement une fonction d'agrégation Pandas DataFrame appelée mean( ) qui fait la même chose que ci-dessus ;

>>> data_subset.mean()
Age             33.75
weight(kgs)     61.00
height(cms)    169.75
dtype: float64

Si vous observez les résultats ci-dessus, les résultats de la fonction d'agrégation Pandas DataFrame et l'application de ufunc sont égaux. Donc, nous n'utilisons pas le apply( ) méthode dans des scénarios aussi simples où nous avons des fonctions d'agrégation disponibles.

  • Chaque fois que vous devez appliquer des fonctions complexes sur des DataFrames, utilisez le apply( ) méthode.

2. Les pandas appliquent la fonction à chaque ligne

En fonction de la taille et du poids, nous pouvons savoir s'ils sont en forme, minces ou obèses. Les critères de condition physique sont différents pour les hommes et les femmes selon les normes internationales. Prenons les données des critères de condition physique pour les tailles et les poids des personnes dans nos données.

Cela peut être représenté à l'aide d'un dictionnaire ;

>>> male_fitness = {
...     #height  : (weight_lower_cap, weight_upper_cap)
...     178      : (     67.5       ,      83         ),
...     173      : (     63         ,      70.6       ),
...     168      : (     58         ,      70.7       )
... }
>>> female_fitness = {
...     #height  : (weight_lower_cap, weight_upper_cap)
...     160      : (     47.2       ,      57.6       )
... }

Dans le dictionnaire ci-dessus, les clés sont les hauteurs et les valeurs sont respectivement les tuples des limites inférieure et supérieure du poids idéal.

Si quelqu'un est en dessous du poids idéal pour sa taille respective, il est "mince". Si quelqu'un est au-dessus du poids idéal pour sa taille respective, il est "obèse". Si quelqu'un se situe dans la fourchette de poids idéal pour sa taille respective, il est « en forme ».

Construisons une fonction qui peut être utilisée dans le apply( ) méthode qui prend toutes les lignes une par une.

>>> def fitness_check(seq):
...     if seq.loc['Sex'] == 'M':
...         if (seq.loc['weight(kgs)'] > male_fitness[seq.loc['height(cms)']][0]) & (seq.loc['weight(kgs)'] < male_fitness[seq.loc['height(cms)']][1]):
...             return "Fit"
...         elif (seq.loc['weight(kgs)'] < male_fitness[seq.loc['height(cms)']][0]):
...             return "Thin"
...         else:
...             return "Obese"
...     else:
...         if (seq.loc['weight(kgs)'] > female_fitness[seq.loc['height(cms)']][0]) & (seq.loc['weight(kgs)'] < female_fitness[seq.loc['height(cms)']][1]):
...             return "Fit"
...         elif (seq.loc['weight(kgs)'] < female_fitness[seq.loc['height(cms)']][0]):
...             return "Thin"
...         else:
...             return "Obese"

La fonction indique si une personne donnée est « en forme », « mince » ou « obèse ». Il utilise les différents dictionnaires de critères de condition physique pour les hommes et les femmes créés ci-dessus.

Enfin, appliquons la fonction ci-dessus à chaque ligne en utilisant le apply( ) méthode ;

>>> data.apply(fitness_check, axis=1)
Name
Edward         Fit
Natalie      Obese
Chris M        Fit
Priyatham     Thin
dtype: object

À partir du résultat ci-dessus, nous avons appris qui est en forme, mince ou obèse.

Conclusion et prochaines étapes

Utilisation du apply( ) Lorsque vous souhaitez obtenir des fonctionnalités complexes, il est préférable et recommandé. La plupart des fonctions d'agrégation intégrées dans Pandas sont pratiques. Si vous avez aimé ce tutoriel sur le apply( ) et comme l'apprentissage basé sur des quiz, pensez à essayer de lire notre livre Coffee Break Pandas.