View Categories

Manipulation de données avec Pandas

La manipulation des données est une tâche essentielle dans l’analyse des données et implique la transformation et la modification de tes données pour en tirer des informations ou les préparer à une analyse plus poussée. Pandas fournit un ensemble riche de méthodes de manipulation de données qui te permettent de façonner tes données pour répondre à tes besoins spécifiques.

Application de fonctions à des DataFrames #

Il existe une astuce pour effectuer des opérations élément par élément pour le Dataframe en utilisant python .iterrows(). Cependant, il est important de noter que Pandas est optimisé pour les opérations vectorielles, et l’itération à travers un DataFrame ligne par ligne n’est généralement pas la manière la plus efficace de travailler avec des données dans Pandas. Il est recommandé d’utiliser des opérations vectorielles dans la mesure du possible.

import pandas as pd

# Créer un DataFrame type
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35]}

df = pd.DataFrame(data)

# Itérer à travers les lignes
for index, row in df.iterrows():
    print(f"Indice : {index}, Prénom : {row['Name']}, Âge : {row['Age']}")

De manière efficace, tu peux utiliser les fonctions ci-dessous pour les colonnes ou les lignes d’un DataFrame afin d’effectuer des opérations par élément :

  • .apply() : Cette méthode permet d’appliquer une fonction personnalisée à une série ou à l’ensemble de la base de données.
    – Lorsque tu utilises cette méthode pour une série, chaque élément de la colonne d’origine sera transmis à la fonction.
    – Lorsque tu utilises cette méthode pour l’ensemble du DataFrame, en fonction de l’axe (1 – ligne, 0 – colonne), la ligne ou la colonne entière sera transmise à la fonction.
# Application d'une fonction personnalisée à une colonne
def square(x):
    return x ** 2

# Cela créera une nouvelle colonne portant le nom de "Squared_Column"
df['Squared_Column'] = df['Original_Column'].apply(square)
# Exemple de DataFrame
data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
df = pd.DataFrame(data)

# Définir une fonction pour calculer la moyenne d'une ligne
def average_row(row):
    return row.mean()

# Appliquer la fonction en ligne (axis=0). Pour les colonnes, utilisez (axis=1).
df['Row_Average'] = df.apply(average_row, axis=1)

df
--------------------------------------------------------------------------
output:

   A  B  Row_Average
0  1  4          2.5
1  2  5          3.5
2  3  6          4.5
  • .map() : Cette méthode applique une fonction à chaque élément d’une série. Elle est particulièrement utile pour transformer une colonne en fonction des valeurs d’une autre colonne.
# Mapping des valeurs d'une colonne sur la base d'un dictionnaire
mapping_dict = {'A': 1, 'B': 2, 'C': 3}
df['New_Column'] = df['Old_Column'].map(mapping_dict)
  • .applymap() : Lorsque tu souhaites appliquer une fonction à chaque élément de l’ensemble du DataFrame, tu peux utiliser .applymap().
# Exemple de DataFrame
data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
df = pd.DataFrame(data)

# Définir une fonction pour ajouter 10 à une valeur
def add_10(x):
    return x + 10

# Appliquer la fonction à l'ensemble du DataFrame
df = df.applymap(add_10)

df
--------------------------------------------------------------------------
output:
    A   B
0  11  14
1  12  15
2  13  16

Ajout et suppression de colonnes #

Tu peux ajouter et supprimer des colonnes pour adapter ton DataFrame à l’analyse :

  • Ajout de colonnes : Pour ajouter une nouvelle colonne ou remplacer une colonne existante, il suffit de lui attribuer des valeurs.
  • Suppression de colonnes : Utilise la méthode .drop() pour supprimer des colonnes. Tu peux choisir de supprimer les étiquettes de l’index (0 ou 'index') ou des colonnes (1 ou 'columns'). Tu peux utiliser axis=1/ 'columns' pour supprimer une colonne, ou utiliser axis=0/ 'index' pour supprimer une ligne.
# Crée une nouvelle colonne avec le nom New_Column
df['New_Column'] = [1, 2, 3, 4]

# Utilisation de .drop() pour supprimer des colonnes
df.drop(['Column1', 'Column2'], axis=1, inplace=True)

Combinaison de DataFrames (Concaténation, Jointure, Fusion) #

Pandas propose des méthodes puissantes pour combiner les DataFrames :

  • Concaténation : Tu peux concaténer les DataFrames verticalement ou horizontalement en utilisant pd.concat(). axis=0 les concaténera dans les lignes, axis=1 les concaténera dans les colonnes. Il vérifiera les colonnes communes entre les deux DataFrames et concaténera les colonnes correspondantes dans les lignes.
import pandas as pd

# Exemples de DataFrames avec les mêmes noms de colonnes
data1 = {'A': [1, 2, 3], 'B': [4, 5, 6], 'C':[1,2,3]}
data2 = {'A': [7, 8, 9], 'B': [10, 11, 12], 'D':[1,2,3]}
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)

# Concaténer df1 et df2 horizontalement (le long des colonnes) avec les mêmes noms de colonnes
result = pd.concat([df1, df2], axis=0)

# Afficher le DataFrame concaténé
print(result)

# Conseil : pour que l'index soit correct, tu peux utiliser -> result.reset_index(drop=True)
------------------------------------------------------------------------
output:
   A   B    C    D
0  1   4  1.0  NaN
1  2   5  2.0  NaN
2  3   6  3.0  NaN
0  7  10  NaN  1.0
1  8  11  NaN  2.0
2  9  12  NaN  3.0
  • Jointure : Tu peux effectuer des jointures de type SQL sur les DataFrames à l’aide de la méthode .merge().
  • Fusion : Pandas te permet de fusionner des DataFrames sur la base de colonnes communes. En utilisant la méthode merge, tu peux effectuer différentes jointures telles que les jointures internes, externes, gauche et droite.
    – Une jointure interne ne conservera que les cellules des colonnes communes qui correspondent.
    – Une jointure externe conservera toutes les lignes des deux DataFrames. La jointure gauche conservera toutes les lignes du tableau gauche et la jointure droite toutes les lignes du tableau droit.
    – Si tu souhaites faire correspondre une colonne d’un tableau à l’index d’un autre tableau, spécifie left_index=True ou right_index=True en conséquence pour le tableau dont tu souhaites faire correspondre la colonne à l’index. Et pour l’autre table sur laquelle la colonne doit correspondre, tu dois spécifier left_on=nom_de_colonne ou right_on=nom_de_colonne en conséquence.
# Inner Join
import pandas as pd

# Exemples de DataFrames
df1 = pd.DataFrame({'ID': [1, 2, 3], 'Name': ['Alice', 'Bob', 'Charlie']})
df2 = pd.DataFrame({'ID': [2, 3, 4], 'Age': [25, 30, 22]})

# Inner join sur 'ID'
result = pd.merge(df1, df2, on='ID', how='inner')

# Afficher le DataFrame fusionné
print("Inner Join")
print(result)

# Left join sur 'ID'
result = pd.merge(df1, df2, on='ID', how='left')

# Afficher le DataFrame fusionné
print("Left Join")
print(result)

# Si les noms des colonnes correspondantes sont différents dans les deux DataFrames
# tu peux les spécifier manuellement
# Considérant que la table de gauche a l'ID1 et la table de droite l'ID2
pd.merge(df1,df2, left_on="ID1", right_on="ID2")

# Ici, il essaiera de faire correspondre l'index du DataFrame de gauche avec la colonne ID de droite.
pd.merge(df1,df2, left_index=True,right_on="ID")
------------------------------------------------------------------------
output:
Inner Join
   ID     Name  Age
0   2      Bob   25
1   3  Charlie   30

Left Join
   ID     Name   Age
0   1    Alice   NaN
1   2      Bob  25.0
2   3  Charlie  30.0

Jusqu’à maintenant, nous avons exploré les subtilités des structures de données, du chargement des données, de l’inspection, de la sélection, du nettoyage et des manipulations – les outils essentiels que tout passionné de données devrait manier.

T'en as pensé quoi ?