Pandas : analyse de données

Qu'est-ce que Pandas ? Une bibliothèque pour l'analyse de données

Pandas est une bibliothèque Python open source qui fournit des structures de données et des outils d'analyse de données performants, flexibles et faciles à utiliser.

Pandas est construit au-dessus de NumPy, et il est conçu pour travailler avec des données *tabulaires* ou *structurées* (comme des feuilles de calcul Excel, des tables de bases de données, ou des données CSV).

Les deux structures de données principales de Pandas sont :

• Series : Un tableau unidimensionnel étiqueté, capable de contenir n'importe quel type de données (entiers, flottants, chaînes, objets Python, etc.). Une Series est similaire à une colonne d'une feuille de calcul.
• DataFrame : Une structure de données tabulaire bidimensionnelle, avec des lignes et des colonnes étiquetées. Un DataFrame est similaire à une feuille de calcul, une table SQL, ou un tableau de données. Vous pouvez le voir comme un dictionnaire de Series partageant le même index.

Pandas offre des fonctionnalités pour :

• Importer et exporter des données à partir de divers formats (CSV, Excel, JSON, SQL, etc.).
• Nettoyer et préparer les données (gérer les valeurs manquantes, supprimer les doublons, convertir les types de données, etc.).
• Transformer et remodeler les données (filtrer, trier, grouper, agréger, fusionner, etc.).
• Explorer et analyser les données (statistiques descriptives, visualisation, etc.).

Pandas est un outil essentiel pour tout analyste de données, data scientist, ou toute personne travaillant avec des données en Python.

Pandas est généralement importé avec l'alias `pd` :

import pandas as pd

Series : tableaux unidimensionnels étiquetés

Une Series est un tableau unidimensionnel étiqueté. Elle peut contenir des données de n'importe quel type (entiers, flottants, chaînes, objets Python, etc.).

Une Series est composée de deux tableaux principaux :

• Un tableau de *valeurs* (généralement un tableau NumPy).
• Un tableau d'*étiquettes*, appelé *index*, qui associe un nom (ou un identifiant) à chaque valeur.

Vous pouvez créer une Series à partir d'une liste, d'un tableau NumPy, d'un dictionnaire, etc.

Exemples :

import pandas as pd

# Créer une Series à partir d'une liste
serie1 = pd.Series([10, 20, 30, 40])
print(serie1)
# 0    10
# 1    20
# 2    30
# 3    40
# dtype: int64

# Les étiquettes (index) sont des entiers par défaut (0, 1, 2, ...)

# Créer une Series avec des étiquettes personnalisées
serie2 = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])
print(serie2)
# a    10
# b    20
# c    30
# d    40
# dtype: int64

# Créer une Series à partir d'un dictionnaire
serie3 = pd.Series({'a': 10, 'b': 20, 'c': 30})
print(serie3)
# a    10
# b    20
# c    30
# dtype: int64

Vous pouvez accéder aux éléments d'une Series par leur position (comme pour une liste) ou par leur étiquette (comme pour un dictionnaire) :

print(serie2[0])     # Accès par position : 10
print(serie2['b'])   # Accès par étiquette : 20

Les Series supportent également de nombreuses opérations vectorisées (comme les tableaux NumPy).

DataFrames : tableaux bidimensionnels étiquetés

Un DataFrame est une structure de données tabulaire, avec des lignes et des colonnes étiquetées. C'est la structure de données la plus couramment utilisée dans Pandas.

Vous pouvez voir un DataFrame comme un ensemble de Series qui partagent le même index (les étiquettes de lignes). Chaque colonne d'un DataFrame est une Series.

Vous pouvez créer un DataFrame à partir de plusieurs sources de données :

• Un dictionnaire de listes, de tableaux NumPy, ou de Series.
• Un tableau NumPy bidimensionnel.
• Une liste de dictionnaires.
• Un fichier CSV, Excel, JSON, etc.
• Une table de base de données.

Exemple (création à partir d'un dictionnaire) :

import pandas as pd

donnees = {
    'nom': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'ville': ['Paris', 'New York', 'Londres']
}

df = pd.DataFrame(donnees)
print(df)
#       nom  age     ville
# 0   Alice   25     Paris
# 1     Bob   30  New York
# 2  Charlie  35   Londres

Dans cet exemple :

• `donnees` est un dictionnaire où les clés sont les noms des colonnes et les valeurs sont des listes contenant les données de chaque colonne.
• `pd.DataFrame(donnees)` crée un DataFrame à partir de ce dictionnaire.
• Les étiquettes des lignes (l'index) sont des entiers par défaut (0, 1, 2, ...). Vous pouvez spécifier des étiquettes personnalisées lors de la création du DataFrame, ou les modifier ultérieurement.

Importer des données (CSV, Excel, etc.)

Pandas fournit des fonctions pour lire des données à partir de divers formats de fichiers. Ces fonctions retournent généralement un DataFrame.

Les fonctions les plus courantes sont :

• `pd.read_csv(fichier)` : Lit un fichier CSV (Comma Separated Values).
• `pd.read_excel(fichier)` : Lit un fichier Excel.
• `pd.read_json(fichier)` : Lit un fichier JSON.
• `pd.read_sql(requete, connexion)` : Lit des données à partir d'une base de données SQL.
• `pd.read_html(url)` : Lit des tables HTML à partir d'une URL.
• Et bien d'autres...

Exemple (lecture d'un fichier CSV) :

import pandas as pd

# Lire un fichier CSV
df = pd.read_csv("mon_fichier.csv")

# Afficher les premières lignes du DataFrame
print(df.head())

Ces fonctions ont de nombreux arguments optionnels pour contrôler la manière dont les données sont lues (séparateur, en-tête, types de données, gestion des valeurs manquantes, etc.). Consultez la documentation de Pandas pour plus de détails.

Explorer et manipuler un DataFrame : opérations de base

Une fois que vous avez un DataFrame, vous pouvez effectuer de nombreuses opérations pour explorer et manipuler les données.

Voici quelques opérations de base :

• `df.head(n)` : Affiche les `n` premières lignes du DataFrame (par défaut, `n=5`).
• `df.tail(n)` : Affiche les `n` dernières lignes du DataFrame.
• `df.shape` : Retourne un tuple contenant le nombre de lignes et de colonnes du DataFrame.
• `df.info()` : Affiche des informations sur le DataFrame (nombre de lignes, noms et types de colonnes, nombre de valeurs non nulles, utilisation de la mémoire).
• `df.describe()` : Affiche des statistiques descriptives pour les colonnes numériques (moyenne, écart-type, min, max, quartiles).
• `df.columns` : Retourne les noms des colonnes.
• `df.index` : Retourne les étiquettes des lignes.
• `df['nom_colonne']` : Sélectionne une colonne (retourne une Series).
• `df[['col1', 'col2']]` : Sélectionne plusieurs colonnes (retourne un DataFrame).
• `df.loc[ligne, colonne]` : Sélectionne des lignes et des colonnes par étiquette.
• `df.iloc[ligne, colonne]` : Sélectionne des lignes et des colonnes par position (entier).
• `df[condition]` : Filtre les lignes en fonction d'une condition booléenne.
• `df.sort_values(by='colonne')` : Trie le DataFrame selon une colonne.
• `df.groupby('colonne').mean()` : Regroupe les données par colonne et calcule la moyenne.
• Et bien d'autres...

Exemple :

import pandas as pd

donnees = {
    'nom': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'age': [25, 30, 35, 28, 42],
    'ville': ['Paris', 'New York', 'Londres', 'Paris', 'Berlin']
}
df = pd.DataFrame(donnees)

print(df.head(2)) # 2 premières lignes
#      nom  age     ville
# 0  Alice   25     Paris
# 1    Bob   30  New York

print(df.shape)  # (5, 3)

print(df.info())
# 
# RangeIndex: 5 entries, 0 to 4
# Data columns (total 3 columns):
#  #   Column  Non-Null Count  Dtype
# ---  ------  --------------  -----
#  0   nom     5 non-null      object
#  1   age     5 non-null      int64
#  2   ville   5 non-null      object
# dtypes: int64(1), object(2)
# memory usage: 248.0+ bytes

print(df.describe())
#              age
# count   5.000000
# mean   32.000000
# std     6.442049
# min    25.000000
# 25%    28.000000
# 50%    30.000000
# 75%    35.000000
# max    42.000000

print(df.columns) # Index(['nom', 'age', 'ville'], dtype='object')

print(df['age']) # Sélection de la colonne 'age'
# 0    25
# 1    30
# 2    35
# 3    28
# 4    42
# Name: age, dtype: int64

print(df[df['age'] > 30])  # Filtrage : personnes de plus de 30 ans
#       nom  age    ville
# 2  Charlie   35  Londres
# 4      Eve   42   Berlin

print(df.groupby('ville').mean())  # Moyenne d'âge par ville
#           age
# ville
# Berlin     42.0
# Londres    35.0
# New York   30.0
# Paris      26.5

Pandas offre une grande variété de fonctionnalités pour manipuler et analyser les données. La documentation de Pandas est une ressource précieuse pour explorer toutes ces fonctionnalités.

Nettoyage et transformation des données

Pandas est également très puissant pour nettoyer et transformer les données :

• Gestion des valeurs manquantes : `df.isna()`, `df.fillna()`, `df.dropna()`.
• Suppression des doublons : `df.drop_duplicates()`.
• Conversion de types de données : `df['colonne'].astype(int)`, `pd.to_datetime()`, etc.
• Application de fonctions : `df['colonne'].apply(fonction)`.
• Agrégation et regroupement : `df.groupby('colonne').agg({'colonne2': 'mean'})`.
• Fusion et jointure de DataFrames : `pd.merge()`, `pd.concat()`.
• Et bien plus encore...

Pandas permet de préparer les données pour l'analyse et la modélisation de manière efficace et intuitive.