Python
Convertissez rapidement un dictionnaire Pandas en DataFrame : Guide du débutant

Convertir rapidement un dictionnaire Pandas en DataFrame : Guide du débutant

MoeNagy Dev

Transformation d'un dictionnaire Python en DataFrame Pandas

DataFrame Pandas : La puissance de la manipulation des données

Comprendre le DataFrame Pandas

Le DataFrame Pandas est une structure de données puissante en Python qui offre un ensemble complet d'outils pour la manipulation, l'analyse et la visualisation des données. Il est basé sur la bibliothèque NumPy et offre un format de données tabulaire similaire à une feuille de calcul, vous permettant de stocker et de travailler avec des données structurées.

Caractéristiques clés et avantages

  • Structure de données tabulaire : Les DataFrames Pandas représentent les données dans un format semblable à une table en deux dimensions, avec des lignes et des colonnes.
  • Types de données hétérogènes : Les DataFrames peuvent stocker des données de différents types au sein de la même structure, ce qui les rend polyvalents pour traiter des ensembles de données diversifiés.
  • Manipulation efficace des données : Pandas fournit un ensemble riche de méthodes et de fonctions pour filtrer, trier, regrouper et transformer les données, facilitant ainsi les tâches d'analyse et de prétraitement des données.
  • Gestion des données manquantes : Les DataFrames ont une prise en charge intégrée pour la gestion des données manquantes, vous permettant d'identifier, de remplacer ou d'interpoler facilement les valeurs manquantes.
  • Visualisation intégrée : Pandas s'intègre parfaitement aux bibliothèques de visualisation des données telles que Matplotlib et Seaborn, vous permettant de générer directement à partir de votre DataFrame des graphiques et des diagrammes informatifs.
  • Évolutivité et performances : Pandas est optimisé pour les performances et peut traiter efficacement de grands ensembles de données, ce qui le rend adapté au traitement des big data.

Conversion d'un dictionnaire Python en DataFrame Pandas

Définition du dictionnaire

Commençons par créer un dictionnaire Python que nous utiliserons pour illustrer la conversion en DataFrame Pandas. Dans cet exemple, nous allons créer un dictionnaire représentant des informations sur différentes voitures :

car_data = {
    'make': ['Toyota', 'Honda', 'Ford', 'Chevrolet', 'Nissan'],
    'model': ['Camry', 'Civic', 'Mustang', 'Silverado', 'Altima'],
    'year': [2020, 2018, 2022, 2019, 2021],
    'price': [25000, 22000, 35000, 40000, 27000]
}

Création d'un DataFrame à partir d'un dictionnaire

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

import pandas as pd
 
df = pd.DataFrame(car_data)
print(df)

Résultat :

       make    model  year  price
0    Toyota   Camry  2020  25000
1     Honda   Civic  2018  22000
2      Ford  Mustang  2022  35000
3  Chevrolet Silverado  2019  40000
4     Nissan   Altima  2021  27000

La variable df résultante est un DataFrame Pandas qui contient les données du dictionnaire car_data.

Gestion des dictionnaires avec différents types de valeurs

Les DataFrames Pandas peuvent gérer des dictionnaires avec différents types de valeurs, tels que des listes, des tuples ou même d'autres dictionnaires. Modifions le dictionnaire car_data pour inclure des données imbriquées :

car_data = {
    'make': ['Toyota', 'Honda', 'Ford', 'Chevrolet', 'Nissan'],
    'model': ['Camry', 'Civic', 'Mustang', 'Silverado', 'Altima'],
    'year': [2020, 2018, 2022, 2019, 2021],
    'price': [25000, 22000, 35000, 40000, 27000],
    'features': [
        {'engine': 'V6', 'transmission': 'automatic', 'drivetrain': 'FWD'},
        {'engine': 'I4', 'transmission': 'manual', 'drivetrain': 'FWD'},
        {'engine': 'V8', 'transmission': 'automatic', 'drivetrain': 'RWD'},
        {'engine': 'V8', 'transmission': 'automatic', 'drivetrain': '4WD'},
        {'engine': 'I4', 'transmission': 'CVT', 'drivetrain': 'FWD'}
    ]
}
 
df = pd.DataFrame(car_data)
print(df)

Résultat :

       make    model  year  price                                           features
0    Toyota   Camry  2020  25000  {'engine': 'V6', 'transmission': 'automatic', 'd...
1     Honda   Civic  2018  22000  {'engine': 'I4', 'transmission': 'manual', 'driv...
2      Ford  Mustang  2022  35000  {'engine': 'V8', 'transmission': 'automatic', 'd...
3  Chevrolet Silverado  2019  40000  {'engine': 'V8', 'transmission': 'automatic', 'd...
4     Nissan   Altima  2021  27000  {'engine': 'I4', 'transmission': 'CVT', 'drivet...

Dans cet exemple, la colonne features contient un dictionnaire pour chaque voiture, représentant des informations supplémentaires sur le véhicule.

Traitement des dictionnaires imbriqués

Si vous avez un dictionnaire de dictionnaires, vous pouvez toujours en créer un DataFrame. Prenons l'exemple où chaque voiture a un dictionnaire imbriqué pour les features :

car_data = {
    'make': ['Toyota', 'Honda', 'Ford', 'Chevrolet', 'Nissan'],
    'model': ['Camry', 'Civic', 'Mustang', 'Silverado', 'Altima'],
    'year': [2020, 2018, 2022, 2019, 2021],
    'price': [25000, 22000, 35000, 40000, 27000],
    'features': {
        'Camry': {'engine': 'V6', 'transmission': 'automatic', 'drivetrain': 'FWD'},
        'Civic': {'engine': 'I4', 'transmission': 'manual', 'drivetrain': 'FWD'},
        'Mustang': {'engine': 'V8', 'transmission': 'automatic', 'drivetrain': 'RWD'},
        'Silverado': {'engine': 'V8', 'transmission': 'automatic', 'drivetrain': '4WD'},
        'Altima': {'engine': 'I4', 'transmission': 'CVT', 'drivetrain': 'FWD'}
    }
}
 
df = pd.DataFrame(car_data)
print(df)

Résultat :

       make    model  year  price                                           features
0    Toyota   Camry  2020  25000  {'engine': 'V6', 'transmission': 'automatic', 'd...
1     Honda   Civic  2018  22000  {'engine': 'I4', 'transmission': 'manual', 'driv...
2      Ford  Mustang  2022  35000  {'engine': 'V8', 'transmission': 'automatic', 'd...
3  Chevrolet Silverado  2019  40000  {'engine': 'V8', 'transmission': 'automatic', 'd...
4     Nissan   Altima  2021  27000  {'engine': 'I4', 'transmission': 'CVT', 'drivet...

Dans ce cas, la colonne "features" contient toujours un dictionnaire pour chaque voiture, mais la structure est différente de l'exemple précédent.

Personnalisation du DataFrame

Spécifier l'ordre des colonnes

Vous pouvez réorganiser l'ordre des colonnes du DataFrame en passant une liste de noms de colonnes à la fonction pd.DataFrame() :

df = pd.DataFrame(car_data, columns=['make', 'model', 'price', 'year', 'features'])
print(df)

Output:

       make    model  price  year                                           features
0    Toyota   Camry  25000  2020  {'engine': 'V6', 'transmission': 'automatic', 'd...
1     Honda   Civic  22000  2018  {'engine': 'I4', 'transmission': 'manual', 'driv...
2      Ford  Mustang  35000  2022  {'engine': 'V8', 'transmission': 'automatic', 'd...
3  Chevrolet Silverado  40000  2019  {'engine': 'V8', 'transmission': 'automatic', 'd...
4     Nissan   Altima  27000  2021  {'engine': 'I4', 'transmission': 'CVT', 'drivet...

Renommer les colonnes

Vous pouvez renommer les colonnes du DataFrame en utilisant la méthode rename() :

df = df.rename(columns={'make': 'Constructeur', 'model': 'Modèle', 'price': 'Prix', 'year': 'Année', 'features': 'Caractéristiques de la voiture'})
print(df)

Output:

   Constructeur    Modèle  Prix  Année                   Caractéristiques de la voiture
0        Toyota   Camry  25000  2020  {'engine': 'V6', 'transmission': 'automatic', 'd...
1         Honda   Civic  22000  2018  {'engine': 'I4', 'transmission': 'manual', 'driv...
2          Ford  Mustang  35000  2022  {'engine': 'V8', 'transmission': 'automatic', 'd...
3    Chevrolet Silverado  40000  2019  {'engine': 'V8', 'transmission': 'automatic', 'd...
4         Nissan   Altima  27000  2021  {'engine': 'I4', 'transmission': 'CVT', 'drivet...

Gestion des données manquantes

Si votre dictionnaire contient des valeurs manquantes, Pandas les gère automatiquement dans le DataFrame. Par exemple, si nous ajoutons une valeur manquante pour le 'prix' de la voiture 'Altima' :

car_data = {
    'make': ['Toyota', 'Honda', 'Ford', 'Chevrolet', 'Nissan'],
    'model': ['Camry', 'Civic', 'Mustang', 'Silverado', 'Altima'],
    'year': [2020, 2018, 2022, 2019, 2021],
    'price': [25000, 22000, 35000, 40000, None],
    'features': {
        'Camry': {'engine': 'V6', 'transmission': 'automatic', 'drivetrain': 'FWD'},
        'Civic': {'engine': 'I4', 'transmission': 'manual', 'drivetrain': 'FWD'},
        'Mustang': {'engine': 'V8', 'transmission': 'automatic', 'drivetrain': 'RWD'},
        'Silverado': {'engine': 'V8', 'transmission': 'automatic', 'drivetrain': '4WD'},
        'Altima': {'engine': 'I4', 'transmission': 'CVT', 'drivetrain': 'FWD'}
    }
}
 
df = pd.DataFrame(car_data)
print(df)

Output:

       make    model  year   price                                           features
0    Toyota   Camry  2020  25000.0  {'engine': 'V6', 'transmission': 'automatic', 'd...
1     Honda   Civic  2018  22000.0  {'engine': 'I4', 'transmission': 'manual', 'driv...
2      Ford  Mustang  2022  35000.0  {'engine': 'V8', 'transmission': 'automatic', 'd...
3  Chevrolet Silverado  2019  40000.0  {'engine': 'V8', 'transmission': 'automatic', 'd...
4     Nissan   Altima  2021       NaN  {'engine': 'I4', 'transmission': 'CVT', 'drivet...

La valeur manquante du 'prix' pour la voiture 'Altima' est représentée par NaN.

Fonctions

Les fonctions en Python sont des blocs de code réutilisables qui effectuent une tâche spécifique. Elles vous permettent de diviser votre programme en morceaux plus petits et plus gérables. Les fonctions peuvent prendre des arguments (entrées) et renvoyer des valeurs (sorties).

Voici un exemple d'une fonction simple qui prend deux nombres comme arguments et renvoie leur somme :

def add_numbers(a, b):
    return a + b
 
result = add_numbers(5, 3)
print(result)  # Output: 8

Dans cet exemple, la fonction add_numbers prend deux arguments, a et b, et renvoie leur somme. Nous appelons ensuite la fonction avec les arguments 5 et 3, et stockons le résultat dans la variable result, que nous affichons ensuite.

Les fonctions peuvent également avoir des arguments par défaut, qui sont utilisés si l'appelant ne fournit pas de valeur pour cet argument :

def greet(name, message="Hello"):
    print(f"{message}, {name}!")
 
greet("Alice")  # Output: Hello, Alice!
greet("Bob", "Hi")  # Output: Hi, Bob!

Dans cet exemple, la fonction greet a un argument par défaut message avec une valeur de "Hello". Si l'appelant ne fournit pas de valeur pour message, la valeur par défaut est utilisée.

Portée des fonctions

En Python, les variables ont une portée spécifique, qui détermine où elles peuvent être accessibles. Les variables définies à l'intérieur d'une fonction sont considérées comme locales à cette fonction et ne peuvent être accédées qu'à l'intérieur de la fonction. Les variables définies à l'extérieur d'une fonction sont considérées comme globales et peuvent être accédées de n'importe où dans le programme.

Voici un exemple qui montre la différence entre les variables locales et globales :

global_variable = 10
 
def my_function():
    local_variable = 5
    print(f"Local variable: {local_variable}")
    print(f"Global variable: {global_variable}")
 
my_function()  # Output: Local variable: 5, Global variable: 10
 
print(local_variable)  # NameError: name 'local_variable' is not defined

Dans cet exemple, global_variable est une variable globale qui peut être accédée à la fois à l'intérieur et à l'extérieur de la fonction my_function. Cependant, local_variable est une variable locale qui ne peut être accédée qu'à l'intérieur de la fonction my_function.

Modules et paquets

En Python, les modules sont des fichiers Python individuels qui contiennent des définitions et des déclarations. Les paquets sont des collections de modules associés.

Pour utiliser un module, vous pouvez l'importer au début de votre script Python. Voici un exemple :

import math
 
result = math.sqrt(16)
print(result)  # Output: 4.0

Dans cet exemple, nous importons le module math, qui fournit une variété de fonctions mathématiques. Nous utilisons ensuite la fonction sqrt du module math pour calculer la racine carrée de 16.

Vous pouvez également importer des fonctions spécifiques ou des variables à partir d'un module à l'aide du mot-clé from :

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

Dans cet exemple, nous importons la fonction sqrt directement du module math, ce qui nous permet de l'utiliser sans le préfixe math..

Les packages sont des collections de modules liés. Vous pouvez créer vos propres packages en organisant vos fichiers Python dans des répertoires et en ajoutant un fichier __init__.py à chaque répertoire. Voici un exemple :

my_package/
    __init__.py
    module1.py
    module2.py

Dans cet exemple, my_package est un package qui contient deux modules, module1.py et module2.py. Le fichier __init__.py est requis pour faire du répertoire un package.

Vous pouvez ensuite importer des modules du package en utilisant la syntaxe suivante :

import my_package.module1
result = my_package.module1.my_function()

Ou vous pouvez importer des fonctions spécifiques ou des variables du package :

from my_package.module2 import my_variable, my_function
print(my_variable)
my_function()

Exceptions

Les exceptions sont des événements qui se produisent lors de l'exécution d'un programme et perturbent le déroulement normal des instructions du programme. Python dispose d'un système intégré de gestion des exceptions qui vous permet de gérer ces événements de manière élégante.

Voici un exemple de gestion de l'exception ZeroDivisionError :

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Erreur : Division par zéro")

Dans cet exemple, nous essayons de diviser 10 par 0, ce qui va soulever une ZeroDivisionError. Nous capturons cette exception à l'aide du bloc except et affichons un message d'erreur.

Vous pouvez également gérer plusieurs exceptions dans un seul bloc try-except :

try:
    result = int("abc")
except ValueError:
    print("Erreur : Format entier invalide")
except TypeError:
    print("Erreur : L'entrée doit être une chaîne de caractères")

Dans cet exemple, nous essayons de convertir la chaîne de caractères "abc" en entier, ce qui va soulever une ValueError. Nous gérons également une exception de type TypeError, qui pourrait se produire si nous passons un type incorrect à la fonction int().

Vous pouvez également utiliser le bloc finally pour exécuter du code indépendamment de la survenue ou non d'une exception :

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Erreur : Division par zéro")
finally:
    print("Ce code sera toujours exécuté")

Dans cet exemple, le code du bloc finally sera exécuté indépendamment de la réussite ou de la levée d'une exception lors de la division par zéro.

Conclusion

Dans ce tutoriel, vous avez appris divers concepts intermédiaires de Python, notamment les fonctions, la portée des fonctions, les modules et les packages, et la gestion des exceptions. Ces concepts sont essentiels pour créer des applications Python plus complexes et robustes.

N'oubliez pas que la meilleure façon d'améliorer vos compétences en Python est de pratiquer. Essayez d'appliquer ces concepts à vos propres projets et expérimentez différentes utilisations. Bonne chance !

MoeNagy Dev