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 expliquons l’architecture de cette structure de données ainsi que ses principales méthodes et propriétés.

Comment fonctionnent les DataFrames de Pandas ?

Les DataFrames de Pandas sont au cœur de la bibliothè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 bidimensionnelle, composée de lignes indexées et de colonnes étiquetées. Cette organisation permet de structurer les données de manière claire et facile à manipuler, similaire aux tableurs comme Excel ou LibreOffice. Chaque colonne d’un DataFrame peut contenir différents types de données Python, ce qui permet de stocker des données hétérogènes comme des valeurs numériques, des chaînes de caractè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 principaux : les données elles-mêmes, les index de ligne et les noms de colonne. L’index de ligne (ou simplement l’index) sert d’identificateur unique pour chaque ligne. Par défaut, les lignes sont indexées avec des valeurs numériques, mais celles-ci peuvent être remplacées par des chaînes de caractères. Notez que les DataFrames de Pandas sont indexés à zéro, c’est-à-dire que les index commencent à 0.

Close

L’utilisation des DataFrames de Pandas

Les DataFrames de Pandas offrent une multitude de techniques et de méthodes qui permettent de traiter, d’analyser et de visualiser efficacement les données. Dans ce qui suit, vous apprendrez quelques-uns des concepts et des méthodes les plus importants pour la manipulation des données avec Pandas DataFrames.

Créer un DataFrame Pandas

Si vous avez déjà enregistré les données souhaitées dans une liste Python ou un dictionnaire Python, vous pouvez très facilement créer un DataFrame à partir de ces données. Pour cela, il vous suffit de transmettre la structure de données existante en argument au constructeur pandas.DataFrame([Données]). Toutefois, la manière dont Pandas interprète vos données dépend de la structure que vous passez au constructeur. 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 permettent de créer que des DataFrames avec une colonne unique non étiquetée. C’est pourquoi il est recommandé de créer des DataFrames à partir de dictionnaires contenant des listes. Dans ce cas, les clés sont interprétées comme des noms de colonnes et les listes comme les données correspondantes. 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 immédiatement le format et les titres souhaités. Si vous ne souhaitez pas vous fier aux structures 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 approprié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 DataFrames csv et sql de l’exemple ci-dessus contiennent maintenant respectivement 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 supplémentaires, par exemple si les index numériques doivent être inclus ou non dans le DataFrame. Vous trouverez plus de détails sur les arguments supplémentaires des deux fonctions sur la page de documentation officielle sur les DataFrames de Pandas.

Pandas DataFrames : afficher les données

Avec Pandas DataFrames, vous pouvez non seulement afficher le tableau entier, mais aussi des lignes et des colonnes individuelles. 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 individuelles 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érencement d’une colonne, on n’utilise que le nom de la colonne entre apostrophes simples, comme dans les dictionnaires Python. En revanche, pour référencer une ligne, on utilise toujours l’attribut loc. Avec loc, il est aussi possible d’appliquer des conditions 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 supérieure à 30 sont affichées :

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

Mais on peut aussi utiliser l’attribut iloc pour sélectionner 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 DataFrames : itérer sur des lignes

Lors du traitement de données en Python, il est très souvent nécessaire 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 différentes pour itérer sur les lignes d’un DataFrame : itertuples() et iterrows(). Les deux méthodes ont leurs avantages et leurs inconvénients en termes de performances et de convivialité.

La méthode iterrows() renvoie pour chaque ligne du DataFrame un tuple contenant l’index et la série correspondante. 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 meilleures performances. L’accès aux éléments individuels dans la série se fait par le nom de la colonne, ce qui facilite considérablement la manipulation 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 performance. C’est pourquoi la méthode itertuples() est surtout recommandée pour les très grands DataFrames. Contrairement à iterrows(), itertuples() renvoie la ligne entière, y compris l’index, sous forme de tuples, qui sont beaucoup plus performants que les séries. Dans les tuples, on accède à des éléments individuels au moyen d’un point, comme pour les attributs d’un objet.

Une autre différence importante entre les séries et les tuples est que les tuples ne sont pas mutables (modifiables). Si l’on veut utiliser itertuples() pour itérer sur un DataFrame et modifier des valeurs, il faut référencer le DataFrame avec l’attribut at et l’index du tuple. Cet attribut fonctionne de manière très similaire à loc. L’exemple suivant sert à illustrer les diffé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