Les 10 fonctions les plus importantes de Pandas que tout débutant devrait connaître

Pandas est la bibliothèque de référence pour les analystes de données et les programmeurs Python qui s'aventurent dans le monde de la manipulation et de l'analyse des données. Sa syntaxe intuitive et ses structures de données puissantes rendent la manipulation de vastes ensembles de données non seulement gérable, mais aussi efficace. Qu'il s'agisse d'importer des fichiers CSV, de nettoyer des ensembles de données désordonnés ou d'analyser des tendances, Pandas possède les outils dont vous avez besoin.

Si vous commencez tout juste votre apprentissage de Pandas, ce billet vous présentera 10 fonctions et méthodes essentielles que tout débutant devrait maîtriser. Ces fonctions vous aideront à charger, inspecter, nettoyer et analyser les données avec facilité.
Voici un aperçu rapide de chaque méthode et de ce qu'elle fait :

• read_csv(): Charge les données d'un fichier CSV dans un DataFrame Pandas.
• tête(): Affiche les premières lignes du DataFrame.
• info(): Fournit un résumé concis du DataFrame, y compris les types de colonnes et les valeurs manquantes.
• décrire(): Génère des statistiques descriptives pour les colonnes numériques.
• isnull(): Identifie les données manquantes dans le DataFrame.
• dropna(): Supprime les lignes ou les colonnes dont les données sont manquantes.
• fillna(): Remplace les données manquantes par les valeurs spécifiées.
• groupby(): Regroupe les données sur la base d'une ou plusieurs colonnes et applique des fonctions d'agrégation.
• sort_values(): Trie le DataFrame par une ou plusieurs colonnes.
• appliquer(): Applique des fonctions personnalisées aux lignes ou aux colonnes du DataFrame.

Conditions préalables

Tout d'abord, assurez-vous que Python est installé sur votre machine. Si ce n'est pas le cas, vous pouvez le télécharger à partir de ce lien.
Une fois Python installé, vérifiez que la bibliothèque Pandas est installée. Si ce n'est pas le cas, vous pouvez facilement l'ajouter en utilisant la commande suivante :

pip install pandas

Pour nos exemples, nous utiliserons l'ensemble de données fictives sur l'immobilier suivant :

Les 10 meilleures fonctions et méthodes Pandas

1. read_csv() : Charge les données d'un fichier CSV dans un DataFrame Pandas.

La première étape de l'utilisation de pandas consiste à charger vos données pour les préparer au traitement ou à l'analyse. L'une des méthodes les plus courantes pour importer des données dans un DataFrame pandas est la fonction read_csv().

Exemple de code :

import pandas as pd
# Charger l'ensemble de données dans un DataFrame Pandas
file_path = "real_estate_listings.csv" # Remplacer par votre chemin de fichier réel

# Créer le DataFrame
df = pd.read_csv(file_path)

Nous commençons par importer la bibliothèque pandas. En utilisant comme pd est une convention courante parmi les développeurs pour simplifier le code. Par exemple, au lieu d'écrire pandas.read_csv()nous pouvons simplement utiliser pd.read_csv()ce qui rend le code plus concis et plus facile à lire.

Ensuite, indiquez le chemin d'accès au fichier CSV que vous souhaitez charger dans un DataFrame Pandas. Créez ensuite une variable et utilisez la méthode read_csv pour charger le fichier dans le DataFrame.

Paramètres clés :

Examinons à présent quelques paramètres importants qui découlent de cette méthode :

• délimiteur : Spécifiez le délimiteur utilisé dans le fichier CSV (par exemple, ,, ;, \t).

df = pd.read_csv(file_path, delimiter=',')

• index_col: Dans notre tableau, chaque annonce immobilière est identifiée par un ID qui se trouve dans le champ "PropertyID". Pour s'assurer que pandas utilise cette colonne comme identifiant unique pour chaque propriété, nous pouvons la définir explicitement comme colonne ID. Sinon, pandas générera et attribuera automatiquement ses propres valeurs d'identification à chaque liste.

df = pd.read_csv(file_path, index_col='PropertyID')

• usecols: Si votre fichier CSV contient de nombreuses colonnes mais que vous n'avez besoin que de quelques unes d'entre elles, pandas vous permet d'y parvenir facilement à l'aide d'un paramètre spécifique.

df = pd.read_csv(file_path, usecols=['Location', 'Price', 'Bedrooms'])

2. head() et tail() : Inspecter les données

Maintenant que les données sont chargées dans le DataFrame, nous pouvons commencer à les explorer. Pour ce faire, Pandas fournit deux méthodes très pratiques : tête() et queue(). Ces méthodes sont essentielles pour inspecter rapidement les premières ou les dernières lignes de votre ensemble de données.

• head(): Cette méthode affiche par défaut les 5 premières lignes du jeu de données. Elle est particulièrement utile pour vérifier que les données ont été chargées correctement et pour contrôler leur structure.
• tail(): Cette méthode fonctionne de la même manière que head(), mais affiche les dernières lignes. Elle est utile pour examiner la fin de l'ensemble de données, en particulier pour vérifier si les données sont complètes ou si les enregistrements suivants ont des valeurs manquantes.

Exemple de code :

# Afficher les 5 premières lignes
print(df.head())
# Afficher les 3 dernières lignes
print(df.tail(3))

Sortie de tête():

Sortie de queue():

3. info() - Comprendre la structure du DataFrame

La fonction info() fournit un résumé concis du DataFrame. Elle inclut des détails tels que :

• Le nombre de lignes et de colonnes.
• Noms des colonnes et leurs types de données.
• Le nombre de valeurs non nulles dans chaque colonne.

Cette méthode est utile pour comprendre rapidement la structure de votre ensemble de données et pour repérer des problèmes tels que des valeurs manquantes ou des types de données incorrects.

Exemple de code :

# Obtenir un résumé concis du DataFrame
print(df.info())

Le code ci-dessus produit le résultat suivant :

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 7 columns):
#   Column          Non-Null Count  Dtype 
---  ------          --------------  ----- 
0   PropertyID      6 non-null      int64 
1   Location        6 non-null      object
2   Bedrooms        6 non-null      int64 
3   Bathrooms       6 non-null      int64 
4   Price           5 non-null      float64
5   SquareFootage   6 non-null      int64 
6   ListingDate     5 non-null      object
dtypes: float64(1), int64(4), object(2)
memory usage: 464.0+ bytes

4. describe() : Générer des statistiques sommaires

Le décrire() permet d'obtenir un résumé rapide des principales données statistiques, telles que moyen, écart-type, centileset bien d'autres choses encore. Par défaut, décrire() fonctionne avec des données numériques mais peut également traiter des données catégorielles, offrant ainsi des informations personnalisées basées sur le type de données.

Paramètres clés :

• centiles: Une liste de nombres entre 0 et 1, spécifiant les percentiles à renvoyer. La valeur par défaut est None, qui renvoie les 25e, 50e et 75e centiles. Plus d'informations ici.
• inclure: Liste des types de données à inclure dans le résumé. Vous pouvez spécifier des types de données tels que int, float, object (pour les chaînes de caractères), etc. La valeur par défaut est None, ce qui signifie que tous les types numériques sont inclus.
• exclure: Une liste de types de données à exclure du résumé. Ce paramètre est également Aucun par défaut, ce qui signifie qu'aucun type n'est exclu.

Exemple de code :

print(df.describe())

La sortie du code est la suivante :

       PropertyID Emplacement Chambres ...         Prix Pieds carrés Date d'inscription
nombre 6.000000 6 6.000000... 5.000000e+00 6.000000 5
unique NaN 6 NaN ...           NaN NaN 5
top NaN New York NaN ...           NaN NaN 2023-05-15
freq NaN 1 NaN ...           NaN NaN 1
moyenne 103.500000 NaN 3.500000... 7.800000e+05 2150.000000 NaN
std 1.870829 NaN 1.048809... 2.774887e+05 755.645419 NaN
min 101.000000 NaN 2.000000... 4.500000e+05 1400.000000 NaN
25% 102.250000 NaN 3.000000... 6.500000e+05 1725.000000 NaN
50% 103.500000 NaN 3.500000... 7.500000e+05 1900.000000 NaN
75% 104.750000 NaN 4.000000... 8.500000e+05 2375.000000 NaN
max 106.000000 NaN 5.000000... 1.200000e+06 3500.000000 NaN

Explication de chaque statistique

• Compter: Le nombre d'entrées non manquantes pour chaque colonne.
  • Exemple : compte = 6 pour Chambres à coucherindiquant que toutes les lignes contiennent des données valides.
• Moyenne: La valeur moyenne de la colonne.
  • Exemple : moyenne = 3,5 pour Chambres à coucherindiquant une moyenne de 3,5 chambres à coucher par propriété.
• Std: L'écart-type, qui montre la dispersion des valeurs par rapport à la moyenne.
  • Exemple : std = 1,048809 pour Chambres à coucherCela signifie que le nombre de chambres à coucher varie modérément.
• Min/Max: La plus petite et la plus grande valeur.
  • Exemple : min = 2 et max = 5 pour Chambres à coucher.
• 25%, 50%, 75% (Quartiles): Ils représentent la diffusion des données :
  • 25%: Valeur en dessous de laquelle se situent 25% des données (premier quartile).
  • 50%: La valeur médiane.
  • 75%: Valeur en dessous de laquelle se situent 75% des données (troisième quartile).

5. isnull() : Identifier les données manquantes

Le isnull() permet d'identifier les données manquantes dans un DataFrame. Elle renvoie un DataFrame de la même forme que l'original, avec des données Vrai lorsque les données sont manquantes NaN et Faux autrement. Elle est couramment utilisée avec d'autres fonctions telles que somme() pour compter les valeurs manquantes dans les colonnes ou les lignes.

Exemple de code :

# Identifier les valeursmanquantes
print(df.isnull())
# Compter les valeurs manquantes pour chaque colonne
print(df.isnull().sum())

df.isnull() Sortie :

  Identifiant de propriété  Emplacement  Salle de bains  Salle de bain  Prix  Pieds carrés  Date d'inscription
0       Faux     Faux     Faux      Faux  Faux          Faux        Faux
1       Faux     Faux     Faux      Faux  Faux          Faux        Faux
2       Faux     Faux     Faux      Faux   Vrai          Faux        Faux
3       Faux     Faux     Faux      Faux  Faux          Faux         Vrai
4       Faux     Faux     Faux      Faux  Faux          Faux        Faux
5       Faux     Faux     Faux      Faux  Faux          Faux        Faux

df.isnull().sum() Sortie :

PropertyID 0
Emplacement 0
Chambres 0
Salle de bain 0
Prix 1
Pieds carrés 0
ListingDate 1
dtype: int64

6. dropna() : Supprimer les données manquantes

Le dropna() La fonction supprime rangs ou colonnes avec données manquantes NaN du DataFrame. Par défaut, il supprime les lignes contenant des valeurs manquantes. Vous pouvez personnaliser son comportement pour ne supprimer que les colonnes, ou pour supprimer les lignes/colonnes dont toutes les valeurs ou un sous-ensemble spécifique de valeurs sont manquantes.

Exemple de code :

# Supprimer les lignes contenant des valeurs manquantes 
df_dropped_rows = df.dropna()
print(df_dropped_rows)

# Supprimez les colonnes contenant des valeurs manquantes 
df_dropped_columns = df.dropna(axis=1)
print(df_dropped_columns)

Voici à quoi ressemble le DataFrame après avoir supprimé tous les rangs contenant NaN valeurs :

Voici le cadre de données avec colonnes contenant NaN supprimées.

7. fillna() : Remplacer les données manquantes

Le fillna() remplace les données manquantes NaN avec les valeurs spécifiées. L'outil pandas dropna() gère et supprime efficacement les valeurs nulles d'un DataFrame, tandis que la méthode fillna() offre une solution flexible pour remplacer les NaN avec une valeur spécifiée de votre choix. Cette méthode offre une approche flexible de la gestion des données manquantes en vous permettant de combler les lacunes à l'aide d'une valeur fixe, la moyen, médiane, modeou d'autres statistiques calculées.

Exemple de code :

# Remplir les valeurs manquantes de la colonne "Prix" avec le prix moyen df['Prix'] = 
df['Prix'].fillna(df['Prix'].mean()) 
print(df)

La sortie du code montre que le NaN a été remplacée avec succès par le prix moyen.

Le Date d'inscription La colonne contient également un NaN valeur. Au lieu d'effectuer un calcul, nous pouvons simplement utiliser un espace réservé tel que "inconnue. Voici comment procéder ;

# Remplir les valeurs manquantes de la colonne "ListingDate" avec un caractère générique
df['ListingDate'] = df['ListingDate'].fillna('Unknown')
print(df)

Le cadre de données se présente désormais comme suit :

8. groupby() : Grouper et agréger des données

La fonction groupby() de Pandas est un outil polyvalent et puissant qui permet de diviser un DataFrame en groupes sur la base d'une ou plusieurs colonnes, ce qui permet une analyse et une agrégation efficaces des données.
Elle fonctionne selon le principe " diviser-appliquer-combiner":
d'abord, les données sont divisées en groupes ;
ensuite, une fonction spécifiée est appliquée à chaque groupe ;
enfin, les résultats sont combinés dans un nouveau DataFrame.
Cette approche rationalisée simplifie les tâches complexes de manipulation des données et améliore l'efficacité de l'analyse.

Exemple de code :

Par exemple, vous pouvez calculer le prix moyen des biens par emplacement ou compter le nombre d'annonces par catégorie de chambre.

# Regroupement par "lieu" et calcul du prix moyen
avg_price_by_location = df.groupby('Location')['Price'].mean()
print(avg_prix_par_lieu)
# Grouper par 'Chambres' et calculer le total des pieds carrés
total_sqft_by_bedrooms = df.groupby('Bedrooms')['SquareFootage'].sum()
print(total_sqft_by_bedrooms)
# Grouper par plusieurs colonnes et calculer le nombre
count_by_location_bedrooms = df.groupby(['Location', 'Bedrooms']).size()
print(count_by_location_bedrooms)

Prix moyen par lieu :

Lieu de travail
Chicago 650000.0
Houston 450000.0
Los Angeles NaN
Miami 1200000.0
New York 750000.0
San Francisco 850000.0
Nom: Prix, dtype : float64

Surface totale par chambre :

Chambres
2    1400
3    3500
4    4500
5    3500

Dénombrement par lieu et par chambre :

Lieu Chambres
Chicago 3 1
Houston 4 1
Los Angeles 4 1
Miami 5 1
New York 3 1
San Francisco 2 1
dtype: int64

9. sort_values() : Trier les données

La fonction sort_values() permet de trier votre DataFrame en fonction d'une ou de plusieurs colonnes, par ordre croissant ou décroissant. Le tri est essentiel pour classer les données, identifier les extrêmes (par exemple, les biens immobiliers les plus chers) ou simplement organiser l'ensemble de données pour en améliorer la lisibilité.Vous pouvez effectuer un tri sur la base de colonnes numériques, catégorielles ou temporelles.

Exemple de code :

# Trier par "Prix" dans l'ordre décroissant
df_sorted_by_price = df.sort_values(by='Price', ascending=False)
print(df_sorted_by_price)
# Trier par 'Emplacement' dans l'ordre croissant
df_sorted_by_location = df.sort_values(by='Location')
print(df_sorted_by_location)
# Trier par plusieurs colonnes : d'abord par 'Chambres' (ordre croissant) et ensuite par 'Prix' (ordre décroissant)
df_sorted_by_bedrooms_price = df.sort_values(by=['Bedrooms', 'Price'], ascending=[True, False])
print(df_sorted_by_bedrooms_price)

Trier par prix (décroissant) :

  PropertyID Emplacement Chambres ...      Prix Pieds carrés Date d'inscription
4 105 Miami 5... 1200000.0 3500 2023-03-22
1 102 San Francisco 2...  850000.0 1400 2023-06-01
0 101 New York 3...  750000.0 1800 2023-05-15
3 104 Chicago 3...  650000.0 1700 NaN
5 106 Houston 4...  450000.0 2000 2023-07-01
2 103 Los Angeles 4...        NaN 2500 2023-04-10

Trier par lieu (croissant) :

[6 lignes x 7 colonnes]
  PropertyID Location Bedrooms ...      Prix Pieds carrés Date d'inscription
3  104  Chicago  3 . ..   650000.0  1700  NaN
5  106  Houston  4 .. .   450000.0  2000  2023-07-01
2  103  Los Angeles  4 . ..        NaN  2500  2023-04-10
4  105  Miami  5 .. .  1200000.0  3500  2023-03-22
0  101  New York  3 . ..   750000.0  1800  2023-05-15
1  102  San Francisco  2 .. .   850000.0  1400  2023-06-01

Trier par chambres (croissant) et par prix (décroissant) :

  PropertyID Emplacement Chambres ...      Prix Pieds carrés Date d'inscription
1 102 San Francisco 2...  850000.0 1400 2023-06-01
0 101 New York 3...  750000.0 1800 2023-05-15
3 104 Chicago 3...  650000.0 1700 NaN
5 106 Houston 4...  450000.0 2000 2023-07-01
2 103 Los Angeles 4...        NaN 2500 2023-04-10
4 105 Miami 5... 1200000.0 3500 2023-03-22

10. apply() : Appliquer des fonctions personnalisées aux données

La fonction apply() vous permet d'appliquer des fonctions personnalisées aux lignes ou aux colonnes d'un DataFrame. Il s'agit d'une méthode puissante pour effectuer des transformations, des calculs ou des opérations conditionnelles par élément qui vont au-delà des fonctions Pandas intégrées.

Exemple de code :

Prenons un exemple dans lequel nous voulons créer une nouvelle colonne pour calculer le prix par pied carré.

# Définir une fonction personnalisée pour calculer le prix par pied carré
def price_per_sqft(price, sqft) :
  return price / sqft if sqft != 0 else 0

# Appliquer la fonction personnalisée pour créer une nouvelle colonne
df['PricePerSqFt'] = df.apply(lambda row: price_per_sqft(row['Price'], row['SquareFootage'])), axis=1)
print(df)

Voici le résultat du code ci-dessus :

  PropertyID Location Bedrooms ...  Pieds carrés ListingDate PrixPerSqFt
0 101 New York 3...          1800 2023-05-15 416.666667
1 102 San Francisco 2...          1400 2023-06-01 607.142857
2 103 Los Angeles 4... 2500 2023-04-10 NaN
3 104 Chicago 3...          1700 NaN 382.352941
4 105 Miami 5...          3500 2023-03-22 342.857143
5 106 Houston 4... 2000 2023-07-01 225.000000

Un autre exemple pourrait être la conversion des noms de lieux en majuscules ;

# Appliquer une transformation pour mettre en majuscules tous les noms de lieux
df['Emplacement'] = df['Emplacement'].apply(lambda x : x.upper())
print(df)

Voici à quoi cela ressemble :

   PropertyID Emplacement Chambres ...      Prix Pieds carrés Date d'inscription
0 101 NEW YORK 3...  750000.0 1800 2023-05-15
1 102 SAN FRANCISCO 2...  850000.0 1400 2023-06-01
2 103 LOS ANGELES 4...        NaN 2500 2023-04-10
3 104 CHICAGO 3...  650000.0 1700 NaN
4 105 MIAMI 5... 1200000.0 3500 2023-03-22
5 106 HOUSTON 4...  450000.0 2000 2023-07-01

Conclusion

Dans ce guide, nous avons exploré 10 fonctions Pandas essentielles pour l'analyse des données, du chargement et de l'inspection des données avec la fonction read_csv() et info() au nettoyage et à la transformation en utilisant des méthodes telles que isnull(), fillna()et appliquer(). Ces fonctions constituent la base de tout flux de travail d'analyse de données, vous permettant de nettoyer, de manipuler et de résumer efficacement les ensembles de données. En les maîtrisant, vous serez en mesure de relever les défis liés aux données du monde réel en toute confiance. Commencez à vous entraîner dès aujourd'hui et découvrez comment ces outils peuvent simplifier vos tâches d'analyse !