Python
Dict to Dataframe

Convertir facilement un dictionnaire en DataFrame : Guide pour débutants

MoeNagy Dev

Pourquoi convertir un dictionnaire en DataFrame ?

Les dictionnaires sont une structure de données fondamentale en Python, offrant un moyen flexible et efficace de stocker et de récupérer des paires clé-valeur. Cependant, à mesure que vos données deviennent plus complexes, travailler avec des dictionnaires peut devenir fastidieux, en particulier lorsque vous avez besoin d'effectuer des analyses ou des manipulations de données avancées. C'est là que les DataFrames Pandas entrent en jeu.

Avantages d'utiliser un DataFrame par rapport à un dictionnaire

  1. Structure de données tabulaire : Les DataFrames Pandas fournissent une structure de données tabulaire, ce qui facilite le travail avec des données ayant une structure bien définie, comme des lignes et des colonnes. Cette structure facilite des opérations telles que le filtrage, le tri et le regroupement, qui sont essentielles pour l'analyse de données.

  2. Puissants outils d'analyse de données : Les DataFrames Pandas sont livrés avec un ensemble complet d'outils et de fonctions d'analyse de données, tels que le support intégré pour la gestion des données manquantes, l'application d'opérations mathématiques et l'analyse statistique avancée.

  3. Utilisation efficace de la mémoire : Les DataFrames Pandas sont optimisés pour une utilisation de la mémoire, en particulier lorsqu'il s'agit de travailler avec de grands ensembles de données. Ils peuvent manipuler les données de manière plus efficace qu'une collection de dictionnaires.

  4. Interopérabilité avec d'autres bibliothèques : Les DataFrames s'intègrent bien avec d'autres bibliothèques populaires de science des données en Python, telles que NumPy, Matplotlib et Scikit-learn, vous permettant d'incorporer facilement vos données dans une plus large gamme de flux de travail de traitement et de visualisation des données.

Scénarios où cette conversion est utile

  • Nettoyage et prétraitement des données : Lorsque vous travaillez avec des données provenant de sources diverses, il est courant de recevoir les données sous forme de dictionnaires. Convertir ces dictionnaires en DataFrames simplifie les étapes de nettoyage et de prétraitement des données.

  • Analyse et visualisation des données : Les DataFrames fournissent un format structuré qui convient parfaitement à l'analyse des données, vous permettant d'appliquer un large éventail de techniques analytiques et de créer des visualisations informatives.

  • Apprentissage automatique et modélisation : De nombreuses bibliothèques d'apprentissage automatique, telles que Scikit-learn, attendent des données au format tabulaire, ce qui rend la conversion des dictionnaires en DataFrames une étape cruciale dans le processus de développement du modèle.

  • Manipulation et transformation des données : Les DataFrames offrent un ensemble complet de fonctions et de méthodes pour manipuler les données, y compris le filtrage, le tri, le regroupement et les calculs, qui sont souvent plus difficiles à mettre en œuvre avec une collection de dictionnaires.

Création d'un dictionnaire

Commençons par définir un simple dictionnaire :

personne = {
    "nom": "John Doe",
    "âge": 35,
    "ville": "New York"
}

Ce dictionnaire comporte trois paires clé-valeur, où les clés sont des chaînes de caractères et les valeurs sont soit des chaînes de caractères, soit des entiers.

Gestion des dictionnaires avec des structures imbriquées

Les dictionnaires peuvent également comporter des structures imbriquées, où les valeurs peuvent être d'autres dictionnaires ou des listes. Voici un exemple :

personne = {
    "nom": "John Doe",
    "âge": 35,
    "adresse": {
        "rue": "123 Main St",
        "ville": "New York",
        "état": "NY"
    },
    "loisirs": ["lecture", "randonnée", "photographie"]
}

Dans cet exemple, la clé "adresse" a un dictionnaire comme valeur et la clé "loisirs" a une liste comme valeur.

Conversion d'un dictionnaire en DataFrame

Pour convertir un dictionnaire en DataFrame Pandas, vous pouvez utiliser la fonction pd.DataFrame() :

import pandas as pd
 
df = pd.DataFrame(personne)

Cela créera un DataFrame avec les clés du dictionnaire comme noms de colonnes et les valeurs correspondantes comme lignes.

Gestion des dictionnaires avec différents types de valeurs

Pandas est capable de gérer des dictionnaires avec différents types de données pour les valeurs. Par exemple :

personne = {
    "nom": "John Doe",
    "âge": 35,
    "est_employé": True,
    "salaire": 50000.0
}
 
df = pd.DataFrame(personne)

Dans ce cas, le DataFrame aura des colonnes pour "nom", "âge", "est_employé" et "salaire", chacune avec le type de données approprié.

Préservation de la structure du dictionnaire dans le DataFrame

Si vous avez un dictionnaire avec des structures imbriquées, comme celui avec les clés "adresse" et "loisirs", Pandas préservera cette structure lors de la conversion en DataFrame :

personne = {
    "nom": "John Doe",
    "âge": 35,
    "adresse": {
        "rue": "123 Main St",
        "ville": "New York",
        "état": "NY"
    },
    "loisirs": ["lecture", "randonnée", "photographie"]
}
 
df = pd.DataFrame(personne)

Le DataFrame résultant aura les structures de dictionnaire et de liste imbriquées en tant que colonnes distinctes.

Personnalisation du DataFrame

Spécification des noms de colonnes

Vous pouvez spécifier les noms de colonnes lors de la création du DataFrame en passant une liste de noms de colonnes en tant qu'argument columns :

colonnes = ["nom_complet", "âge", "est_employé", "salaire_mensuel"]
df = pd.DataFrame(personne, columns=colonnes)

Cela créera un DataFrame avec les noms de colonnes spécifiés, même si les clés du dictionnaire d'origine ne correspondent pas.

Gestion des valeurs manquantes

Si votre dictionnaire contient des valeurs manquantes, Pandas les gérera automatiquement en insérant des valeurs NaN (Non un Nombre) dans les cellules correspondantes du DataFrame :

personne = {
    "nom": "Jane Doe",
    "âge": 28,
    "ville": None
}
 
df = pd.DataFrame(personne)

Le DataFrame résultant aura une colonne "ville" avec une valeur NaN.

Modification des types de données des colonnes

Vous pouvez également spécifier les types de données des colonnes lors de la création du DataFrame :

personne = {
    "nom": "John Doe",
    "age": "35",
    "is_employed": "True"
}
 
df = pd.DataFrame(person, dtype={"age": int, "is_employed": bool})

Dans cet exemple, la colonne "age" est convertie en entier et la colonne "is_employed" est convertie en boolean.

Gestion des dictionnaires avec des listes en tant que valeurs

Lorsque votre dictionnaire contient des listes en tant que valeurs, Pandas créera un DataFrame avec une ligne par entrée de dictionnaire et les éléments de la liste en tant que colonnes distinctes :

person = {
    "name": "John Doe",
    "age": 35,
    "hobbies": ["reading", "hiking", "photography"]
}
 
df = pd.DataFrame(person)

Le DataFrame résultant aura une colonne "hobbies" avec une liste de valeurs pour chaque ligne.

S'assurer de la longueur constante des colonnes

Si les listes de votre dictionnaire ont des longueurs différentes, Pandas remplira automatiquement les valeurs manquantes avec NaN :

persons = [
    {"name": "John Doe", "hobbies": ["reading", "hiking"]},
    {"name": "Jane Doe", "hobbies": ["painting", "gardening", "cooking"]}
]
 
df = pd.DataFrame(persons)

Le DataFrame résultant aura une colonne "hobbies" avec 3 éléments pour chaque ligne, avec des valeurs NaN lorsque la liste était plus courte.

Gérer les longueurs de liste inégales

Si vous devez vous assurer que toutes les lignes ont le même nombre d'éléments dans les colonnes de liste, vous pouvez utiliser la méthode explode() pour "éclater" les listes en lignes distinctes :

persons = [
    {"name": "John Doe", "hobbies": ["reading", "hiking"]},
    {"name": "Jane Doe", "hobbies": ["painting", "gardening", "cooking"]}
]
 
df = pd.DataFrame(persons)
df = df.explode("hobbies")

Cela créera un DataFrame avec une ligne par loisir, en préservant l'association entre les noms et leurs loisirs.

Dictionnaires avec des dictionnaires imbriqués

Lorsque votre dictionnaire contient des dictionnaires imbriqués en tant que valeurs, Pandas préservera cette structure dans le DataFrame résultant :

person = {
    "name": "John Doe",
    "age": 35,
    "address": {
        "street": "123 Main St",
        "city": "New York",
        "state": "NY"
    }
}
 
df = pd.DataFrame(person)

Le DataFrame aura une colonne pour le dictionnaire imbriqué "address", qui peut être ensuite accédée et manipulée selon les besoins.

Aplatir la structure imbriquée

Si vous préférez avoir un DataFrame "aplati" avec les valeurs du dictionnaire imbriqué en tant que colonnes distinctes, vous pouvez utiliser la fonction pd.json_normalize() :

person = {
    "name": "John Doe",
    "age": 35,
    "address": {
        "street": "123 Main St",
        "city": "New York",
        "state": "NY"
    }
}
 
df = pd.json_normalize(person)

Cela créera un DataFrame avec les colonnes "name", "age", "address.street", "address.city" et "address.state".

Préserver la structure hiérarchique

Alternativement, vous pouvez préserver la structure hiérarchique du dictionnaire imbriqué en utilisant la fonction pd.DataFrame() avec le paramètre orient="index" :

person = {
    "name": "John Doe",
    "age": 35,
    "address": {
        "street": "123 Main St",
        "city": "New York",
        "state": "NY"
    }
}
 
df = pd.DataFrame.from_dict(person, orient="index")

Cela créera un DataFrame avec un index hiérarchique, où les clés du dictionnaire imbriqué sont représentées comme un index à plusieurs niveaux.

Gérer les clés en double

Si votre dictionnaire contient des clés en double, Pandas les gérera de différentes manières selon votre préférence.

Gérer les dictionnaires avec des clés en double

Considérez le dictionnaire suivant avec des clés en double :

person = {
    "name": "John Doe",
    "age": 35,
    "city": "New York",
    "city": "Los Angeles"
}

Lorsque vous convertissez ce dictionnaire en DataFrame, Pandas conservera la dernière occurrence de la clé en double :

df = pd.DataFrame(person)

Le DataFrame résultant aura une colonne "city" avec la valeur "Los Angeles".

Résoudre les conflits en utilisant différentes stratégies

Si vous souhaitez gérer les clés en double différemment, vous pouvez utiliser la fonction pd.DataFrame() avec le paramètre duplicates :

person = {
    "name": "John Doe",
    "age": 35,
    "city": "New York",
    "city": "Los Angeles"
}
 
df = pd.DataFrame([person], duplicates="keep_first")

Cela conservera la première occurrence de la clé en double, ce qui donnera un DataFrame avec "city" défini sur "New York".

Alternativement, vous pouvez utiliser "keep_last" pour conserver la dernière occurrence, ou "raise" pour lever une erreur lorsqu'une clé est en double.

Préserver la structure originale du dictionnaire

Si vous souhaitez préserver la structure originale du dictionnaire, y compris les clés en double, vous pouvez utiliser la fonction pd.DataFrame() avec le paramètre orient="index" :

person = {
    "name": "John Doe",
    "age": 35,
    "city": "New York",
    "city": "Los Angeles"
}
 
df = pd.DataFrame.from_dict(person, orient="index")

Cela créera un DataFrame avec un index à plusieurs niveaux, où les clés en double sont représentées sous la forme de lignes distinctes.

Combinaison de plusieurs dictionnaires

Souvent, vous pouvez avoir besoin de travailler avec plusieurs dictionnaires et les combiner en un seul DataFrame.

Fusion des dictionnaires en un seul DataFrame

Vous pouvez utiliser la fonction pd.DataFrame() pour créer un DataFrame à partir d'une liste de dictionnaires :

persons = [
    {"name": "John Doe", "age": 35, "city": "New York"},
    {"name": "Jane Doe", "age": 28, "city": "Los Angeles"},
    {"name": "Bob Smith", "age": 42, "city": "Chicago"}
]
 
df = pd.DataFrame(persons)

Cela créera un DataFrame avec les colonnes "name", "age" et "city".

Gérer les dictionnaires avec des clés qui se chevauchent

Si les dictionnaires ont des clés qui se chevauchent, Pandas gérera le conflit en se basant sur l'ordre des dictionnaires dans la liste :

persons = [
    {"name": "John Doe", "age": 35, "city": "New York"},
    {"name": "Jane Doe", "age": 28, "city": "Los Angeles
 
## Déclarations conditionnelles
Les déclarations conditionnelles en Python vous permettent d'exécuter différents blocs de code en fonction de certaines conditions. La déclaration conditionnelle la plus courante est la déclaration `if-elif-else`.
 
```python
age = 25
if age < 18:
    print("Vous êtes mineur.")
elif age >= 18 and age < 65:
    print("Vous êtes adulte.")
else:
    print("Vous êtes senior.")

Dans cet exemple, le programme vérifie l'âge et affiche le message approprié en fonction de la condition.

Boucles

Les boucles en Python vous permettent d'exécuter de manière répétée un bloc de code. Les deux types de boucles les plus courants sont les boucles for et les boucles while.

Boucles for

Les boucles for sont utilisées pour itérer sur une séquence, telle qu'une liste, un tuple ou une chaîne de caractères.

fruits = ["pomme", "banane", "cerise"]
for fruit in fruits:
    print(fruit)

Cela produira une sortie comme suit :

pomme
banane
cerise

Boucles while

Les boucles while sont utilisées pour exécuter un bloc de code tant qu'une certaine condition est vraie.

count = 0
while count < 5:
    print(count)
    count += 1

Cela produira une sortie comme suit :

0
1
2
3
4

Fonctions

Les fonctions en Python sont des blocs de code réutilisables qui effectuent une tâche spécifique. Elles peuvent prendre des arguments et renvoyer des valeurs.

def greet(name):
    print(f"Bonjour, {name}!")
 
greet("Alice")

Cela produira une sortie comme suit :

Bonjour, Alice!

Vous pouvez également définir des fonctions avec des arguments par défaut et des arguments de longueur variable.

def calculate_area(length, width, height=None):
    if height is None:
        return length * width
    else:
        return length * width * height
 
print(calculate_area(5, 10))       # Sortie : 50
print(calculate_area(2, 3, 4))     # Sortie : 24

Modules et packages

Les modules intégrés de Python offrent une large gamme de fonctionnalités, et vous pouvez également créer vos propres modules et packages.

import math
print(math.pi)  # Sortie : 3.141592653589793

Vous pouvez également importer des fonctions ou des attributs spécifiques d'un module.

from math import sqrt
print(sqrt(16))  # Sortie : 4.0

Les packages sont des collections de modules organisés dans des répertoires.

mon_package/
    __init__.py
    module1.py
    module2.py

Vous pouvez importer des modules à partir d'un package en utilisant la notation par point.

import mon_package.module1
mon_package.module1.ma_fonction()

Entrées/sorties de fichiers

Python fournit des fonctions intégrées pour la lecture à partir de fichiers et l'écriture dans des fichiers.

# Écriture dans un fichier
with open("exemple.txt", "w") as fichier:
    fichier.write("Bonjour, le monde !")
 
# Lecture à partir d'un fichier
with open("exemple.txt", "r") as fichier:
    contenu = fichier.read()
    print(contenu)  # Sortie : Bonjour, le monde !

L'instruction with garantit que le fichier est correctement fermé une fois les opérations terminées.

Gestion des exceptions

Le mécanisme de gestion des exceptions de Python vous permet de gérer les erreurs et les situations inattendues dans votre code.

try:
    résultat = 10 / 0
except ZeroDivisionError:
    print("Erreur : division par zéro")
else:
    print(f"Résultat : {résultat}")
finally:
    print("Ce bloc sera toujours exécuté.")

Cela produira une sortie comme suit :

Erreur : division par zéro
Ce bloc sera toujours exécuté.

Programmation orientée objet (POO)

Python prend en charge la programmation orientée objet, ce qui vous permet de créer des classes et des objets personnalisés.

class Chien:
    def __init__(self, nom, race):
        self.nom = nom
        self.race = race
 
    def aboyer(self):
        print("Woof !")
 
mon_chien = Chien("Buddy", "Labrador")
print(mon_chien.nom)  # Sortie : Buddy
mon_chien.aboyer()   # Sortie : Woof !

Dans cet exemple, nous définissons une classe Chien avec une méthode __init__ pour initialiser les attributs de l'objet et une méthode aboyer pour faire aboyer le chien.

Conclusion

Dans ce tutoriel, nous avons couvert un large éventail de concepts de Python, notamment les déclarations conditionnelles, les boucles, les fonctions, les modules et les packages, les entrées/sorties de fichiers, la gestion des exceptions et la programmation orientée objet. Ce sont des blocs de construction essentiels pour créer des applications Python puissantes et polyvalentes. Au fur et à mesure que vous continuez à apprendre et à explorer Python, n'oubliez pas de vous exercer régulièrement, d'expérimenter différentes techniques et de rechercher des ressources pour approfondir votre compréhension. Bon codage !

MoeNagy Dev