Conversion d'un dictionnaire en DataFrame en Python avec Pandas

Name

Rajiv Chandra

Updated on 02/08/2023

En tant que Data Scientist, travailler avec des données est l'un des aspects essentiels du travail. L'une des structures de données les plus couramment utilisées en Python à cette fin est le dictionnaire. Un dictionnaire est une collection de paires clé-valeur, où chaque clé est unique. Pandas est une bibliothèque Python populaire pour l'analyse de données et offre des fonctionnalités puissantes pour la manipulation de données. L'une des tâches les plus courantes en analyse de données est la conversion d'un dictionnaire en un DataFrame Pandas. Dans cet article de blog, nous discuterons du processus de conversion d'un dictionnaire en DataFrame avec Pandas.

Vous souhaitez créer rapidement des visualisations de données en Python ?

PyGWalker est un projet Python Open Source qui peut aider à accélérer le flux de travail d'analyse et de visualisation de données directement au sein d'environnements basés sur Jupyter Notebook.

PyGWalker (opens in a new tab) transforme votre DataFrame Pandas (ou DataFrame Polars) en une interface utilisateur visuelle où vous pouvez faire glisser et déposer des variables pour créer des graphiques facilement. Utilisez simplement le code suivant :

pip install pygwalker
import pygwalker as pyg
gwalker = pyg.walk(df)

Vous pouvez exécuter PyGWalker dès maintenant avec ces notebooks en ligne :

Et n'oubliez pas de nous donner une ⭐️ sur GitHub !

Exécuter PyGWalker dans un notebook Kaggle (opens in a new tab)	Exécuter PyGWalker dans Google Colab (opens in a new tab)	Donner une ⭐️ à PyGWalker sur GitHub (opens in a new tab)
(opens in a new tab)	(opens in a new tab)	(opens in a new tab)

Qu'est-ce qu'un dictionnaire ?

En Python, un dictionnaire est une collection de paires clé-valeur. Chaque clé est unique et correspond à une valeur. Les dictionnaires sont utilisés pour stocker et manipuler des données qui peuvent être accédées à l'aide de clés. Les dictionnaires en Python sont définis à l'aide des accolades {} et peuvent être imbriqués.

Qu'est-ce qu'un DataFrame ?

Un DataFrame est une structure de données bidimensionnelle semblable à un tableau en Pandas. Il est composé de lignes et de colonnes, où chaque colonne peut contenir des données de type différent. Les DataFrames sont un excellent moyen d'analyser et de manipuler des données, et Pandas fournit une large gamme de fonctions pour manipuler les données dans un DataFrame.

Conversion d'un dictionnaire en DataFrame

Pandas fournit une méthode simple pour convertir un dictionnaire en DataFrame en utilisant la fonction pd.DataFrame.from_dict(). La fonction from_dict() prend un dictionnaire en entrée et renvoie un DataFrame. Le comportement par défaut de cette fonction suppose que les clés du dictionnaire correspondent aux noms des colonnes et que les valeurs correspondent aux données des lignes.

Prenons un exemple où nous avons un dictionnaire contenant des informations sur des étudiants, leurs notes et leurs matières :

student_data = {'name': ['Alice', 'Bob', 'Charlie'], 'grade': [95, 87, 92], 'subject': ['Math', 'English', 'Science']}

Pour convertir ce dictionnaire en DataFrame, nous utilisons simplement la fonction from_dict() :

import pandas as pd
 
df = pd.DataFrame.from_dict(student_data)
print(df)

La sortie de cet extrait de code ressemblera à ceci :

       name  grade  subject
0     Alice     95     Math
1       Bob     87  English
2  Charlie     92  Science

Comme nous pouvons le voir, les clés du dictionnaire (name, grade et subject) ont été utilisées comme noms de colonnes du DataFrame résultant, et les valeurs correspondantes ont été utilisées comme données de lignes.

Utilisation du paramètre orient

Dans les cas où le dictionnaire a une structure différente, nous pouvons utiliser le paramètre orient pour spécifier comment le DataFrame doit être créé. Le paramètre orient accepte plusieurs valeurs, telles que index, columns, split et values. La valeur par défaut est columns. Prenons un exemple où nous avons un dictionnaire contenant des listes de longueurs différentes :

data = {'name': ['Alice', 'Bob', 'Charlie'], 'grade': [95, 87], 'subject': ['Math', 'English', 'Science']}

Si nous essayons de convertir ce dictionnaire en DataFrame en utilisant le comportement par défaut, nous obtiendrons une ValueError :

df = pd.DataFrame.from_dict(data)

ValueError: arrays must all be same length

Pour éviter cette erreur, nous pouvons utiliser le paramètre orient avec la valeur index pour créer un DataFrame où les clés du dictionnaire deviennent les indices de lignes et les valeurs correspondantes deviennent les données de lignes :

df = pd.DataFrame.from_dict(data, orient='index')
print(df)

La sortie de cet extrait de code ressemblera à ceci :

            0     1        2
name    Alice   Bob  Charlie
grade      95    87     None
subject  Math  English  Science

Utilisation d'une liste de dictionnaires

Une autre façon de créer un DataFrame à partir d'un dictionnaire est d'utiliser une liste de dictionnaires. Dans ce scénario, chaque dictionnaire dans la liste correspondra à une ligne dans le DataFrame résultant, et les clés dans le dictionnaire correspondront aux noms de colonnes. Prenons l'exemple où nous avons une liste de dictionnaires représentant des étudiants et leurs notes :

donnees_etudiants = [{'nom': 'Alice', 'note': 95, 'matiere': 'Math'},
                {'nom': 'Bob', 'note': 87, 'matiere': 'Anglais'},
                {'nom': 'Charlie', 'note': 92, 'matiere': 'Science'}]

Pour convertir cette liste de dictionnaires en DataFrame, nous utilisons simplement la fonction pd.DataFrame() :

df = pd.DataFrame(donnees_etudiants)
print(df)

La sortie de cet extrait de code ressemblera à ceci :

      nom  note  matiere
0   Alice    95     Math
1     Bob    87  Anglais
2  Charlie    92  Science

Comme nous pouvons le voir, le DataFrame résultant est le même que celui créé à partir du dictionnaire dans l'exemple précédent.

Utilisation des clés comme colonnes

Par défaut, la fonction from_dict() utilise les clés du dictionnaire comme noms de colonnes dans le DataFrame résultant. Dans les cas où nous voulons utiliser un ensemble différent de clés, nous pouvons utiliser le paramètre columns. Par exemple, si nous avons un dictionnaire avec les clés a, b et c, mais que nous voulons utiliser x, y et z comme noms de colonnes, nous pouvons faire ce qui suit :

donnees = {'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]}
df = pd.DataFrame.from_dict(donnees, columns=['x', 'y', 'z'])
print(df)

La sortie de cet extrait de code ressemblera à ceci :

   x  y  z
0  1  4  7
1  2  5  8
2  3  6  9

Utilisation d'une orientation serrée

La fonction from_dict() peut également être utilisée pour créer un DataFrame à partir d'un dictionnaire avec une orientation serrée. Une orientation serrée signifie que chaque clé du dictionnaire contient un dictionnaire avec le même ensemble de clés. Considérez l'exemple suivant :

donnees = {'a': {'x': 1, 'y': 2, 'z': 3}, 'b': {'x': 4, 'y': 5, 'z': 6}, 'c': {'x': 7, 'y': 8, 'z': 9}}

Pour créer un DataFrame à partir de ce dictionnaire avec une orientation serrée, nous pouvons utiliser le paramètre orient et lui donner la valeur index :

df = pd.DataFrame.from_dict(donnees, orient='index')
print(df)

La sortie de cet extrait de code ressemblera à ceci :

   x  y  z
a  1  2  3
b  4  5  6
c  7  8  9

Noms des index et des colonnes

Lors de la conversion d'un dictionnaire en DataFrame, nous pouvons également spécifier les noms des index et des colonnes. Prenons l'exemple suivant :

donnees = {'nom': ['Alice', 'Bob', 'Charlie'], 'note': [95, 87, 92], 'matiere': ['Math', 'Anglais', 'Science']}
 
df = pd.DataFrame.from_dict(donnees, orient='columns', columns=['nom', 'matiere', 'note'], index=['etudiant1', 'etudiant2', 'etudiant3'])
print(df)

La sortie de cet extrait de code ressemblera à ceci :

              nom  matiere  note
etudiant1   Alice     Math    95
etudiant2     Bob  Anglais    87
etudiant3  Charlie  Science    92

Comme nous pouvons le voir dans cet exemple, nous pouvons spécifier les noms des colonnes en utilisant le paramètre columns et les noms des index en utilisant le paramètre index.

Conclusion

Dans cet article de blog, nous avons appris comment convertir facilement un dictionnaire en DataFrame en utilisant la fonction pd.DataFrame.from_dict() de Pandas. Nous avons également appris comment spécifier l'orientation du dictionnaire et personnaliser les noms des colonnes et des index. La possibilité de convertir facilement des dictionnaires en data frames facilite la manipulation des données en Python, ce qui permet aux data scientists d'effectuer plusieurs tâches d'analyse des données telles que la manipulation des données et l'apprentissage automatique qui peuvent être utiles dans leur profession. Les compétences acquises dans la manipulation des dictionnaires vers les data frames peuvent également être transférées à un autre langage comme R, un autre outil populaire en science des données et dans le domaine général de l'analyse et de la manipulation des données en Python.