Pandas DataFrame : manipuler des tableaux en Python de façon efficace et intuitive

Le DataFrame de Pandas est une structure de données Python qui permet de créer et de manipuler des tableaux. Nous vous ex­pli­quons l’ar­chi­tec­ture de cette structure de données ainsi que ses prin­ci­pales méthodes et pro­prié­tés.

Comment fonc­tion­nent les Da­ta­Frames de Pandas ?

Les Da­ta­Frames de Pandas sont au cœur de la bi­blio­thèque Python Pandas et offrent une analyse de données à la fois flexible et efficace en Python. Un DataFrame est une structure de données tabulaire bi­di­men­sion­nelle, composée de lignes indexées et de colonnes éti­que­tées. Cette or­ga­ni­sa­tion permet de struc­tu­rer les données de manière claire et facile à manipuler, similaire aux tableurs comme Excel ou Li­breOf­fice. Chaque colonne d’un DataFrame peut contenir dif­fé­rents types de données Python, ce qui permet de stocker des données hé­té­ro­gènes comme des valeurs nu­mé­riques, des chaînes de ca­rac­tères ou des booléens au sein d’une seule et même table.

Comment est structuré un DataFrame de Pandas ?

Un DataFrame se compose de trois éléments prin­ci­paux : les données elles-mêmes, les index de ligne et les noms de colonne. L’index de ligne (ou sim­ple­ment l’index) sert d’iden­ti­fi­ca­teur unique pour chaque ligne. Par défaut, les lignes sont indexées avec des valeurs nu­mé­riques, mais celles-ci peuvent être rem­pla­cées par des chaînes de ca­rac­tères. Notez que les Da­ta­Frames de Pandas sont indexés à zéro, c’est-à-dire que les index com­men­cent à 0.

Close

L’uti­li­sa­tion des Da­ta­Frames de Pandas

Les Da­ta­Frames de Pandas offrent une multitude de tech­niques et de méthodes qui per­met­tent de traiter, d’analyser et de vi­sua­li­ser ef­fi­ca­ce­ment les données. Dans ce qui suit, vous ap­pren­drez quelques-uns des concepts et des méthodes les plus im­por­tants pour la ma­ni­pu­la­tion des données avec Pandas Da­ta­Frames.

Créer un DataFrame Pandas

Si vous avez déjà en­re­gis­tré les données sou­hai­tées dans une liste Python ou un dic­tion­naire Python, vous pouvez très fa­ci­le­ment créer un DataFrame à partir de ces données. Pour cela, il vous suffit de trans­mettre la structure de données existante en argument au cons­truc­teur pandas.DataFrame([Données]). Toutefois, la manière dont Pandas in­ter­prète vos données dépend de la structure que vous passez au cons­truc­teur. Par exemple, vous pouvez créer un DataFrame Pandas à partir d’une liste Python :

import pandas
liste = ["Ahmed", "Beatrice", "Candice", "Donovan", "Elisabeth", "Frank"]
df = pandas.DataFrame(liste)
print(df)
# Sortie :
# 0
# 0 Ahmed
# 1 Béatrice
# 2 Candice
# 3 Donovan
# 4 Elisabeth
# 5 Frank

Comme vous pouvez le voir dans l’exemple ci-dessus, les listes simples ne per­met­tent de créer que des Da­ta­Frames avec une colonne unique non étiquetée. C’est pourquoi il est re­com­mandé de créer des Da­ta­Frames à partir de dic­tion­naires contenant des listes. Dans ce cas, les clés sont in­ter­pré­tées comme des noms de colonnes et les listes comme les données cor­res­pon­dantes. Découvrez notre exemple :

import pandas
données = {
    'Nom' : ['Arthur', 'Bruno', 'Christophe'],
    'Âge' : [34, 30, 55],
    'Salaire' : [75000.0, 60000.5, 90000.3],
}
df = pandas.DataFrame(données)
print(df)
# Sortie :
# Nom Âge Salaire
# 0 Arthur 34 75000.0
# 1 Bruno 30 60000.5
# 2 Christophe 55 90000.3

Avec cette méthode, le DataFrame a im­mé­dia­te­ment le format et les titres souhaités. Si vous ne souhaitez pas vous fier aux struc­tures de données Python intégrées, vous pouvez également charger vos données à partir d’une source externe, comme un fichier CSV ou une base de données SQL. Pour cela, il vous suffit d’appeler la fonction Pandas ap­pro­priée :

import pandas
import sqlalchemy
# DataFrame de CSV :
csv = pandas.read_csv("fichiers.csv/donnees.csv")
# DataFrame de SQL :
engine = create_engine('postgresql://nom_d_utilisateur:mot_de_passe@localhost:5432/ma_base_de_données')
sql = pandas.read_sql_query('SELECT * FROM tabelle', engine)

Les Da­ta­Frames csv et sql de l’exemple ci-dessus con­tien­nent main­te­nant res­pec­ti­ve­ment toutes les données du fichier data.csv et de la table SQL table. Lors de la création d’un DataFrame à partir d’une source externe, vous pouvez également spécifier des détails sup­plé­men­taires, par exemple si les index nu­mé­riques doivent être inclus ou non dans le DataFrame. Vous trouverez plus de détails sur les arguments sup­plé­men­taires des deux fonctions sur la page de do­cu­men­ta­tion of­fi­cielle sur les Da­ta­Frames de Pandas.

Pandas Da­ta­Frames : afficher les données

Avec Pandas Da­ta­Frames, vous pouvez non seulement afficher le tableau entier, mais aussi des lignes et des colonnes in­di­vi­duelles. De plus, vous pouvez choisir les lignes et les colonnes que vous souhaitez voir. L’exemple suivant montre comment vous pouvez afficher des lignes ou des colonnes in­di­vi­duelles ou multiples :

# Afficher la 0e ligne
print(df.loc[0])
# Imprimer les lignes 3 à 6
print(df.loc[3:6])
# Imprimer les lignes 3 et 6
print(df.loc[[3, 6]])
# Imprimer la colonne "Profession"
print(df["Profession"])
# Imprimer les colonnes "Profession" et "Âge"
print(df[["Profession", "Âge"]])
# Sélectionner plusieurs lignes et colonnes
print(df.loc[[3, 6], ['Profession', 'Âge']])

Comme on peut le voir dans l’exemple, lors du ré­fé­ren­ce­ment d’une colonne, on n’utilise que le nom de la colonne entre apos­trophes simples, comme dans les dic­tion­naires Python. En revanche, pour ré­fé­ren­cer une ligne, on utilise toujours l’attribut loc. Avec loc, il est aussi possible d’appliquer des con­di­tions logiques pour filtrer les données. C’est ce que montre le bloc de code suivant, dans lequel seules les lignes dont la valeur « Âge » est su­pé­rieure à 30 sont affichées :

print(df.loc[df['Âge'] > 30])

Mais on peut aussi utiliser l’attribut iloc pour sé­lec­tion­ner des lignes et des colonnes sur la base de leur position dans le DataFrame. Ainsi, on peut par exemple afficher la cellule qui se trouve sur la troisième ligne et la quatrième colonne :

print(df.iloc[3, 4])
# Sortie :
# Paris
print(df.iloc[[3, 4, 6], 4])
# Sortie :
# 3 Paris
# 4 Marseille
# 6 Lyon

Pandas Da­ta­Frames : itérer sur des lignes

Lors du trai­te­ment de données en Python, il est très souvent né­ces­saire d’itérer sur les lignes d’un DataFrame Pandas, par exemple pour appliquer la même opération à toutes les données. Pandas propose deux méthodes dif­fé­rentes pour itérer sur les lignes d’un DataFrame : itertuples() et iterrows(). Les deux méthodes ont leurs avantages et leurs in­con­vé­nients en termes de per­for­mances et de con­vi­via­lité.

La méthode iterrows() renvoie pour chaque ligne du DataFrame un tuple contenant l’index et la série cor­res­pon­dante. Une série est une autre structure de données Pandas ou NumPy qui est très similaire à une liste Python sur de nombreux points, mais qui offre de meil­leures per­for­mances. L’accès aux éléments in­di­vi­duels dans la série se fait par le nom de la colonne, ce qui facilite con­si­dé­ra­ble­ment la ma­ni­pu­la­tion des données.

Bien que les Pandas Series soient beaucoup plus efficaces que les listes Python, cette structure de données a toujours un certain surcoût en termes de per­for­mance. C’est pourquoi la méthode itertuples() est surtout re­com­man­dée pour les très grands Da­ta­Frames. Con­trai­re­ment à iterrows(), itertuples() renvoie la ligne entière, y compris l’index, sous forme de tuples, qui sont beaucoup plus per­for­mants que les séries. Dans les tuples, on accède à des éléments in­di­vi­duels au moyen d’un point, comme pour les attributs d’un objet.

Une autre dif­fé­rence im­por­tante entre les séries et les tuples est que les tuples ne sont pas mutables (mo­di­fiables). Si l’on veut utiliser itertuples() pour itérer sur un DataFrame et modifier des valeurs, il faut ré­fé­ren­cer le DataFrame avec l’attribut at et l’index du tuple. Cet attribut fonc­tionne de manière très similaire à loc. L’exemple suivant sert à illustrer les dif­fé­rences entre iterrows() et itertuples() :

import pandas
df = pandas.DataFrame({
    'Name' : ['Alice', 'Bob', 'Charlie'],
    'Âge' : [25, 30, 35],
    'Salaire' : [70000.0, 80000.5, 90000.3]
})
for index, row in df.iterrows():
        row['Salaire'] += 1000
        print(f"Index : {index}, Âge : {row['Âge']}, Salaire : {row['Salaire']}")
for tup in df.itertuples():
        df.at[tup.Index, 'Salaire'] += 1000 # Modifier la valeur directement dans le DataFrame en utilisant at[]
        print(f"Index : {tup.Index}, Âge : {tup.Âge}, Salaire : {df.loc[tup.Index, 'Salaire']}")
# Les deux boucles ont la même sortie