Data Analysis avec Python et Pandas

La data analysis occupe aujourd’hui une place centrale dans presque tous les métiers liés au numérique, au marketing, à la finance, à la logistique, au produit, à la santé et même à l’éducation. Derrière chaque tableau de bord, chaque rapport, chaque KPI suivi dans un comité de pilotage, il y a presque toujours un travail d’analyse de données qui commence bien avant la visualisation finale. Ce travail ressemble rarement à une ligne droite. Il commence souvent dans le désordre, avec des fichiers CSV mal structurés, des colonnes incohérentes, des valeurs manquantes, des doublons, des formats de dates variés, et parfois même des données qui semblent s’opposer entre elles. C’est précisément là que Python et Pandas deviennent précieux. Ils ne servent pas seulement à “traiter des données”, mais à leur redonner du sens, à les nettoyer, à les comprendre, puis à en tirer une lecture qui aide vraiment à décider.

Python est devenu un langage naturel pour l’analyse de données parce qu’il est lisible, accessible et soutenu par un écosystème extrêmement riche. Pandas, de son côté, est la bibliothèque qui a rendu la manipulation tabulaire agréable, rapide et expressive. Grâce à elle, on peut charger un fichier, explorer les premières lignes, filtrer des enregistrements, regrouper des résultats, croiser des sources, corriger des incohérences et produire des agrégations en quelques lignes de code. Ce qui prenait autrefois du temps dans des outils plus rigides peut aujourd’hui être exploré de façon itérative, presque conversationnelle, comme si l’on avançait pas à pas dans une enquête. C’est sans doute cela, la vraie force de Pandas : il permet d’écrire une réflexion analytique sous forme de code.

Dans cet article, nous allons parcourir l’ensemble du cycle d’analyse de données avec Python et Pandas, depuis la découverte initiale d’un jeu de données jusqu’à l’extraction d’insights exploitables. L’objectif n’est pas seulement de montrer des commandes, mais de construire une manière de penser l’analyse. Vous verrez comment lire des fichiers, inspecter des structures, nettoyer des colonnes, gérer les valeurs manquantes, transformer les types, construire des indicateurs, créer des tableaux croisés, analyser des séries temporelles et préparer des données pour la visualisation ou pour des modèles plus avancés. L’idée est que vous ressortiez de cette lecture avec une vraie méthode, pas seulement avec une liste de fonctions.

Pourquoi Python et Pandas sont devenus incontournables

Avant même de parler de code, il faut comprendre pourquoi autant de professionnels choisissent Python et Pandas pour analyser des données. La première raison est la simplicité. Python a un style clair, presque narratif, qui permet de lire un script comme on lit un raisonnement. La seconde raison est la puissance. Avec Pandas, on peut traiter des centaines de milliers, voire des millions de lignes avec une logique très expressive. La troisième raison est la compatibilité. Python s’intègre facilement avec les formats les plus courants, comme CSV, Excel, JSON, SQL, Parquet, et sait aussi dialoguer avec des services web, des APIs, des notebooks et des environnements cloud. Enfin, il y a la communauté. Lorsque l’on bloque sur un cas particulier, il existe presque toujours une solution documentée, testée, commentée, discutée, améliorée.

Mais au-delà des avantages techniques, il existe une raison plus humaine. L’analyse de données est rarement une activité linéaire. Elle demande de tester des hypothèses, de revenir en arrière, d’examiner les anomalies, d’imaginer ce qui manque, de comparer plusieurs angles d’approche. Pandas épouse bien cette réalité parce qu’il favorise des transformations explicites et reproductibles. Vous pouvez ouvrir un notebook, tester une intuition, corriger une hypothèse, affiner un filtre, puis recommencer sans perdre le fil. C’est ce mélange de rigueur et de souplesse qui en fait un outil aussi apprécié.

Installer l’environnement et préparer son espace de travail

Pour démarrer, il est utile d’avoir un environnement propre. En pratique, un projet d’analyse de données commence souvent par un environnement virtuel Python, puis par l’installation des bibliothèques de base. Même si l’on peut aller très loin avec seulement Pandas, il est souvent pratique d’ajouter NumPy pour les opérations numériques, Matplotlib et Seaborn pour les graphiques, et Jupyter pour l’exploration interactive.

python -m venv .venv
source .venv/bin/activate  # sous Linux / macOS
# .venv\Scripts\activate   # sous Windows

pip install pandas numpy matplotlib seaborn jupyter

Dans un projet réel, je conseille de travailler dans un notebook au début, parce qu’il facilite l’exploration, puis de transférer ensuite les étapes importantes dans un script lorsque le flux d’analyse se stabilise. Le notebook est excellent pour comprendre les données. Le script est excellent pour les industrialiser. Les deux se complètent très bien.

Une fois l’environnement prêt, on importe les bibliothèques principales.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

Et pour afficher les sorties de façon un peu plus lisible dans un notebook, on peut aussi ajuster quelques paramètres d’affichage.

pd.set_option("display.max_columns", 100)
pd.set_option("display.max_rows", 100)
pd.set_option("display.width", 120)

Ces petites lignes paraissent anodines, mais elles améliorent beaucoup le confort de lecture quand on manipule de vraies tables.

Charger un fichier et comprendre la structure initiale

Le moment où l’on ouvre pour la première fois un dataset est toujours particulier. Il y a une sorte de tension entre curiosité et prudence. On veut aller vite, mais il faut résister à l’envie de conclure trop tôt. La première étape consiste à charger les données et à examiner leur forme générale. Prenons un exemple simple avec un fichier CSV contenant des ventes.

df = pd.read_csv("ventes.csv")

Ensuite, on regarde les premières lignes.

df.head()

Puis on inspecte la structure globale.

df.shape
df.columns
df.dtypes
df.info()

Ces commandes sont souvent sous-estimées. Elles ne font pas de statistiques avancées, mais elles donnent une carte du territoire. On comprend combien il y a de lignes, combien de colonnes, quels types de données sont présents, où se situent les valeurs manquantes et quelles colonnes demandent une conversion. Une bonne analyse commence presque toujours par ce type de diagnostic.

Supposons que le tableau contient des colonnes comme date_commande, produit, categorie, quantite, prix_unitaire, region et client_id. Le simple fait de voir leurs types vous indique déjà des choses importantes. Si date_commande est encore au format texte, il faudra la convertir en date. Si quantite est lue comme chaîne de caractères, il faudra la corriger. Si certaines colonnes ont des valeurs manquantes, il faudra décider quoi en faire. L’analyse ne consiste pas à se précipiter dans les calculs ; elle consiste à rendre les données fiables avant de leur demander de parler.

Nettoyer les données sans perdre le sens métier

Le nettoyage est souvent la phase la plus longue, et pourtant c’est celle qui est la plus stratégique. Une analyse brillante basée sur des données mal nettoyées reste fragile. Pandas aide énormément dans cette phase, mais il faut surtout adopter une logique claire. Nettoyer ne veut pas dire effacer tout ce qui dérange. Nettoyer, c’est rendre les données cohérentes tout en préservant leur signification.

Commençons par les doublons.

df.duplicated().sum()
df = df.drop_duplicates()

Dans certains jeux de données, les doublons sont réellement des doublons. Dans d’autres, ils représentent des événements répétés qui ont du sens. Il ne faut donc jamais supprimer sans réfléchir. Si un client passe deux commandes identiques à deux minutes d’intervalle, est-ce un doublon ou un vrai comportement ? La réponse dépend du contexte métier.

Ensuite, il faut gérer les valeurs manquantes.

df.isna().sum()

La présence de valeurs manquantes est normale. Ce qui compte, c’est de comprendre pourquoi elles existent. Ont-elles été oubliées lors de la saisie ? Résultent-elles d’un problème technique ? Correspondent-elles à une absence d’information volontaire ? Une colonne manquante dans un fichier marketing n’a pas la même signification qu’un champ vide dans un système médical.

Pour supprimer des lignes trop incomplètes :

df = df.dropna()

Pour remplir intelligemment certaines valeurs :

df["quantite"] = df["quantite"].fillna(0)
df["categorie"] = df["categorie"].fillna("Inconnue")

Mais il vaut mieux éviter les solutions automatiques partout. Parfois, la meilleure approche consiste à utiliser une statistique représentative.

df["prix_unitaire"] = df["prix_unitaire"].fillna(df["prix_unitaire"].median())

Le choix entre moyenne, médiane, constante ou interpolation dépend toujours du contexte. En analyse de données, il faut apprendre à faire confiance au bon sens autant qu’au code.

Les espaces invisibles dans les textes sont aussi une source fréquente de confusion.

df["produit"] = df["produit"].str.strip()
df["region"] = df["region"].str.lower().str.strip()

Il arrive aussi que des colonnes numériques soient stockées comme texte.

df["quantite"] = pd.to_numeric(df["quantite"], errors="coerce")
df["prix_unitaire"] = pd.to_numeric(df["prix_unitaire"], errors="coerce")

Le paramètre errors="coerce" transforme les valeurs non convertibles en NaN, ce qui permet ensuite de les repérer et de les traiter. C’est souvent plus sûr que de laisser le programme échouer brutalement.

Convertir les dates et travailler correctement avec le temps

L’un des grands classiques de la data analysis consiste à convertir une colonne de date pour pouvoir ensuite regrouper les données par jour, mois, trimestre ou année. Le temps est une dimension très riche, mais uniquement si on la manipule correctement.

df["date_commande"] = pd.to_datetime(df["date_commande"], errors="coerce")

Une fois la conversion faite, on peut créer de nouvelles colonnes temporelles très utiles.

df["annee"] = df["date_commande"].dt.year
df["mois"] = df["date_commande"].dt.month
df["jour"] = df["date_commande"].dt.day
df["jour_semaine"] = df["date_commande"].dt.day_name()

On peut aussi créer un identifiant mensuel simple.

df["periode_mensuelle"] = df["date_commande"].dt.to_period("M")

Le temps devient alors un levier d’analyse, pas seulement une information technique. Il permet de suivre l’évolution d’un chiffre d’affaires, d’étudier la saisonnalité des ventes, de comparer les comportements en semaine et le week-end, ou de mesurer l’impact d’une campagne sur une période donnée. Une donnée temporelle bien préparée ouvre énormément de portes.

Faire une première exploration statistique

Une fois les données nettoyées de base, il faut apprendre à les écouter. L’exploration statistique permet de détecter des tendances globales, des valeurs extrêmes, des écarts surprenants et parfois des erreurs de saisie. Les commandes les plus simples sont souvent les plus révélatrices.

df.describe()

Cette fonction fournit un résumé statistique des colonnes numériques : moyenne, écart-type, minimum, maximum, quartiles. Elle peut sembler banale, mais elle donne rapidement une idée de la distribution d’une variable. Si la moyenne et la médiane sont très éloignées, cela peut signaler une asymétrie. Si le maximum semble absurde par rapport au reste, il faut vérifier s’il s’agit d’une vraie valeur ou d’une erreur.

Pour les colonnes textuelles :

df["categorie"].value_counts()
df["region"].value_counts(normalize=True)

Le mode de répartition des catégories révèle souvent des déséquilibres intéressants. Peut-être qu’une région représente la majorité des ventes. Peut-être qu’un produit domine le catalogue. Peut-être qu’une catégorie contient des libellés incohérents. L’exploration est le moment où l’on remarque les anomalies et les structures cachées.

On peut aussi calculer des statistiques personnalisées, par exemple le chiffre d’affaires.

df["chiffre_affaires"] = df["quantite"] * df["prix_unitaire"]

df["chiffre_affaires"].sum()
df["chiffre_affaires"].mean()
df["chiffre_affaires"].median()

Très souvent, la donnée brute n’est pas l’unité finale d’analyse. Il faut créer des variables dérivées qui donnent un sens plus métier. Le chiffre d’affaires, la marge, le taux de conversion, la durée moyenne ou la variation relative sont autant d’exemples de métriques construites à partir des colonnes existantes.

Filtrer et sélectionner les bonnes lignes

L’une des forces de Pandas, c’est la capacité à filtrer les données avec précision. Très rapidement, on peut isoler une sous-partie du dataset pour tester une idée.

ventes_maroc = df[df["pays"] == "Maroc"]

Ou, de façon plus complexe :

ventes_hautes = df[(df["quantite"] > 10) & (df["prix_unitaire"] > 100)]

Les conditions peuvent être combinées avec &, | et ~, mais il faut toujours bien entourer les expressions de parenthèses.

df[(df["categorie"] == "Informatique") | (df["categorie"] == "Téléphonie")]

On peut aussi sélectionner des colonnes précises.

df[["date_commande", "produit", "chiffre_affaires"]]

Et lorsqu’on veut quelques lignes de façon aléatoire :

df.sample(5)

Le filtrage est important, non seulement pour lire les données, mais aussi pour construire des scénarios d’analyse. Une bonne question analytique commence souvent par un bon sous-ensemble de données.

Trier et classer pour mieux lire les résultats

Le tri est un autre outil simple, mais très utile. Il permet de voir immédiatement les valeurs les plus élevées, les plus faibles ou les plus récentes.

df.sort_values("chiffre_affaires", ascending=False).head(10)

On peut trier sur plusieurs colonnes :

df.sort_values(["categorie", "chiffre_affaires"], ascending=[True, False])

Le tri devient particulièrement utile lorsqu’on cherche des meilleurs clients, des produits les plus performants, des régions les plus dynamiques ou des anomalies à inspecter. En pratique, beaucoup d’insights apparaissent seulement après un bon tri.

Regrouper avec groupby : l’arme analytique par excellence

Si Pandas avait une fonction emblématique pour l’analyse de données, groupby ferait sans doute partie des premières citées. Elle permet d’agréger les données par catégorie, par période, par segment ou par toute autre dimension utile. C’est une fonction qui transforme une table détaillée en lecture stratégique.

Par exemple, pour calculer le chiffre d’affaires par catégorie :

ca_par_categorie = df.groupby("categorie")["chiffre_affaires"].sum()
print(ca_par_categorie)

Pour obtenir plusieurs statistiques à la fois :

resume = df.groupby("categorie").agg(
    total_ca=("chiffre_affaires", "sum"),
    moyenne_ca=("chiffre_affaires", "mean"),
    nb_commandes=("chiffre_affaires", "count")
)

print(resume)

On peut aussi grouper par région et par mois :

ca_mensuel = df.groupby(["periode_mensuelle", "region"])["chiffre_affaires"].sum().reset_index()

Cette logique est extrêmement puissante, car elle permet de passer d’une vision ligne par ligne à une vision métier. Un analyste ne regarde pas seulement combien de commandes ont été passées ; il veut savoir quelles familles de produits contribuent le plus, quelles régions progressent, quelles périodes sont les plus fortes, et où se situent les points de friction.

Le plus intéressant avec groupby, c’est qu’il encourage l’expérimentation. Une fois qu’on comprend le principe, on commence à regarder les données sous plusieurs angles, presque naturellement. C’est souvent là que les meilleures interprétations apparaissent.

Créer des tableaux croisés avec pivot_table

La table pivot est une autre façon très confortable d’agréger les données, surtout lorsqu’on veut une vue en matrice. Elle est très pratique pour comparer des catégories entre elles.

pivot = pd.pivot_table(
    df,
    values="chiffre_affaires",
    index="categorie",
    columns="region",
    aggfunc="sum",
    fill_value=0
)

print(pivot)

Cette structure est excellente pour voir, d’un coup d’œil, comment le chiffre d’affaires se répartit entre catégories et régions. On peut aussi utiliser d’autres fonctions d’agrégation, comme la moyenne ou le nombre de commandes. Dans la pratique, les tableaux croisés sont souvent utilisés pour préparer des rapports ou alimenter des graphiques comparatifs.

Fusionner plusieurs sources de données

L’analyse de données réelle ne repose presque jamais sur un seul fichier. Très souvent, on dispose d’un tableau de commandes, d’un tableau de clients, d’un tableau de produits, d’un tableau de campagnes marketing ou d’un tableau de stocks. Pandas permet de les combiner de manière très claire avec merge.

Supposons que df contienne les ventes et que clients contienne les informations client.

df = df.merge(clients, on="client_id", how="left")

Le choix du type de jointure est essentiel. left conserve toutes les lignes du tableau principal. inner garde seulement les correspondances. right prend l’inverse. outer conserve tout ce qui existe dans les deux tableaux. Ce choix doit être fait avec attention, car il influence directement le résultat final.

df = ventes.merge(produits, on="produit_id", how="left")

Une bonne fusion permet d’enrichir l’analyse. Par exemple, connaître la ville d’un client, la catégorie d’un produit ou le canal d’acquisition d’une commande aide à aller bien au-delà du simple chiffre d’affaires. On passe alors d’une lecture quantitative à une lecture stratégique.

Gérer les colonnes catégorielles et les variables texte

Les colonnes textuelles sont souvent plus importantes qu’on ne le croit. Elles contiennent des catégories, des libellés, des noms de région, des statuts, des segments ou des canaux. Mais elles sont aussi source de bruit. Deux valeurs qui semblent identiques peuvent en réalité différer par un accent, une casse, un espace ou une faute de frappe.

df["statut"] = df["statut"].str.lower().str.strip()

On peut aussi uniformiser certains libellés manuellement.

df["region"] = df["region"].replace({
    "Casa": "Casablanca",
    "Casablanca ": "Casablanca",
    "Rabat-Salé": "Rabat"
})

Lorsqu’il y a de nombreuses variantes, il faut parfois construire une vraie logique de normalisation. Cela peut prendre du temps, mais cette étape est très rentable. Une catégorie mal orthographiée peut fausser tout un tableau de bord. Une simple correction de texte peut parfois changer radicalement une analyse.

Détecter les valeurs aberrantes

Les valeurs extrêmes ne sont pas toujours des erreurs. Parfois, elles représentent les meilleurs clients, les pics de trafic ou les commandes exceptionnelles. Mais il faut les repérer, car elles peuvent déséquilibrer les moyennes et brouiller l’interprétation.

Une méthode simple consiste à utiliser les quartiles et l’écart interquartile.

Q1 = df["chiffre_affaires"].quantile(0.25)
Q3 = df["chiffre_affaires"].quantile(0.75)
IQR = Q3 - Q1

outliers = df[(df["chiffre_affaires"] < Q1 - 1.5 * IQR) | (df["chiffre_affaires"] > Q3 + 1.5 * IQR)]
print(outliers)

On peut aussi visualiser la distribution avec un boxplot.

import matplotlib.pyplot as plt

plt.figure(figsize=(8, 4))
plt.boxplot(df["chiffre_affaires"].dropna())
plt.title("Distribution du chiffre d'affaires")
plt.show()

Le but n’est pas de supprimer automatiquement les valeurs extrêmes. Le but est de les comprendre. Dans beaucoup de cas, elles racontent une histoire importante.

Visualiser les données pour mieux raconter l’histoire

L’analyse de données ne s’arrête pas aux tableaux. Les graphiques aident à voir les tendances, les ruptures, les répartition et les comparaisons. Même lorsqu’on travaille dans un environnement technique, une bonne visualisation permet de discuter plus clairement avec les équipes métier.

Un graphique en barres pour le chiffre d’affaires par catégorie :

ca_categorie = df.groupby("categorie")["chiffre_affaires"].sum().sort_values(ascending=False)

ca_categorie.plot(kind="bar", figsize=(10, 5))
plt.title("Chiffre d'affaires par catégorie")
plt.xlabel("Catégorie")
plt.ylabel("Chiffre d'affaires")
plt.tight_layout()
plt.show()

Une courbe temporelle pour suivre l’évolution mensuelle :

ca_mois = df.groupby("periode_mensuelle")["chiffre_affaires"].sum()

ca_mois.plot(kind="line", figsize=(10, 5), marker="o")
plt.title("Évolution du chiffre d'affaires mensuel")
plt.xlabel("Période")
plt.ylabel("Chiffre d'affaires")
plt.tight_layout()
plt.show()

Un histogramme pour comprendre la répartition d’une variable :

df["chiffre_affaires"].plot(kind="hist", bins=30, figsize=(8, 4))
plt.title("Répartition du chiffre d'affaires")
plt.xlabel("Chiffre d'affaires")
plt.tight_layout()
plt.show()

La visualisation n’est pas là pour décorer l’analyse, mais pour la rendre lisible. Un bon graphique peut révéler une saisonnalité que les tableaux masquent, ou au contraire mettre en évidence un comportement étrange que personne n’avait remarqué.

Analyser une série temporelle

Les séries temporelles sont souvent au cœur des analyses métier. Elles permettent d’étudier l’évolution d’indicateurs dans le temps. Le plus intéressant n’est pas seulement de voir la hausse ou la baisse, mais de comprendre le rythme, la répétition, les points de rupture et les anomalies.

Imaginons que nous voulons analyser le chiffre d’affaires quotidien.

ca_jour = df.groupby(df["date_commande"].dt.date)["chiffre_affaires"].sum()

On peut ensuite calculer une moyenne mobile pour lisser les variations.

ca_jour = ca_jour.sort_index()
moyenne_mobile = ca_jour.rolling(window=7).mean()

Puis tracer les deux courbes ensemble.

plt.figure(figsize=(12, 5))
plt.plot(ca_jour.index, ca_jour.values, label="Chiffre d'affaires quotidien")
plt.plot(moyenne_mobile.index, moyenne_mobile.values, label="Moyenne mobile 7 jours")
plt.title("Analyse temporelle du chiffre d'affaires")
plt.xlabel("Date")
plt.ylabel("Chiffre d'affaires")
plt.legend()
plt.tight_layout()
plt.show()

Ce type d’analyse est très utile pour identifier les effets de week-end, les saisonnalités hebdomadaires, les creux inhabituels ou les hausses soudaines. Dans beaucoup d’organisations, les séries temporelles constituent la base des décisions opérationnelles.

Construire des indicateurs métier

Les données brutes ne suffisent pas toujours. Pour aider à décider, il faut souvent créer des indicateurs adaptés au métier. Une analyse de vente ne s’arrête pas au total ; elle regarde aussi la fréquence, le panier moyen, le taux de retour, la marge, la croissance, la rétention ou la contribution par segment.

Par exemple, le panier moyen :

panier_moyen = df["chiffre_affaires"].mean()

Le chiffre d’affaires moyen par client :

ca_par_client = df.groupby("client_id")["chiffre_affaires"].sum()
ca_moyen_par_client = ca_par_client.mean()

Le top des clients :

top_clients = df.groupby("client_id")["chiffre_affaires"].sum().sort_values(ascending=False).head(10)

Ce genre d’indicateurs permet de raconter une histoire plus utile. On ne dit pas seulement “les ventes ont augmenté”, on dit “les ventes ont augmenté surtout dans telle catégorie, dans telle région, sur tel canal, et portées par tel segment de clientèle”. C’est là que l’analyse devient réellement stratégique.

Travailler proprement avec les index

Les index sont parfois négligés par les débutants, alors qu’ils jouent un rôle important dans l’organisation des données. Par défaut, Pandas crée un index numérique, mais on peut choisir une colonne logique comme index.

df = df.set_index("date_commande")

Ensuite, certaines opérations deviennent plus simples sur le plan temporel ou analytique. On peut revenir à un index classique :

df = df.reset_index()

L’index peut aussi être hiérarchique dans certains cas. Cela permet de représenter des données sur plusieurs niveaux, mais il faut une bonne discipline pour ne pas perdre la lisibilité. En général, on utilise les index de façon stratégique, seulement lorsqu’ils servent réellement la logique de l’analyse.

Utiliser apply, map et lambda avec prudence

Dans Pandas, les fonctions apply, map et les fonctions lambda sont très pratiques, mais elles doivent être utilisées avec discernement. Elles offrent beaucoup de souplesse, notamment pour transformer des données ligne par ligne ou pour appliquer une logique personnalisée. Cependant, elles peuvent devenir moins performantes que les opérations vectorisées natives.

Créer une catégorie de valeur de commande :

def segmenter_valeur(montant):
    if montant < 100:
        return "Petit"
    elif montant < 500:
        return "Moyen"
    return "Grand"

df["segment_commande"] = df["chiffre_affaires"].apply(segmenter_valeur)

Ou encore avec une expression lambda :

df["segment_commande"] = df["chiffre_affaires"].apply(
    lambda x: "Petit" if x < 100 else "Moyen" if x < 500 else "Grand"
)

Pour remapper des valeurs :

df["statut"].map({
    "en cours": 1,
    "livré": 2,
    "annulé": 0
})

Il faut retenir une idée simple : ces outils sont puissants, mais ils ne doivent pas devenir un réflexe de facilité. Quand une solution vectorisée existe, elle est souvent préférable.

Préparer les données pour un tableau de bord ou un modèle

Une bonne analyse finit rarement dans l’analyse elle-même. Très souvent, elle sert à alimenter un tableau de bord, une présentation ou un modèle prédictif. Cela veut dire qu’il faut parfois structurer les données dans un format propre, stable et exploitable par d’autres outils.

Cela peut impliquer de sélectionner des colonnes utiles :

dataset_final = df[[
    "date_commande",
    "client_id",
    "produit",
    "categorie",
    "region",
    "quantite",
    "prix_unitaire",
    "chiffre_affaires"
]]

Ou de sauvegarder un fichier nettoyé :

dataset_final.to_csv("ventes_nettoyees.csv", index=False)

On peut aussi exporter vers Excel :

dataset_final.to_excel("ventes_nettoyees.xlsx", index=False)

Cette étape est importante, car elle transforme un travail d’exploration en livrable concret. Une analyse réussie n’est pas seulement celle qui comprend les données ; c’est celle qui permet à d’autres de s’en servir facilement.

Mini cas pratique : analyser des ventes de bout en bout

Prenons maintenant un cas pratique plus complet. Imaginons un fichier de ventes avec des colonnes de base. L’objectif est d’en tirer un résumé utile. Voici une séquence simple mais réaliste.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

df = pd.read_csv("ventes.csv")

df.columns = df.columns.str.strip().str.lower()
df["date_commande"] = pd.to_datetime(df["date_commande"], errors="coerce")
df["produit"] = df["produit"].str.strip()
df["categorie"] = df["categorie"].fillna("Inconnue").str.strip()
df["region"] = df["region"].fillna("Inconnue").str.strip()
df["quantite"] = pd.to_numeric(df["quantite"], errors="coerce").fillna(0)
df["prix_unitaire"] = pd.to_numeric(df["prix_unitaire"], errors="coerce").fillna(df["prix_unitaire"].median())
df = df.drop_duplicates()

df["chiffre_affaires"] = df["quantite"] * df["prix_unitaire"]
df["annee"] = df["date_commande"].dt.year
df["mois"] = df["date_commande"].dt.month
df["periode_mensuelle"] = df["date_commande"].dt.to_period("M")

resume_global = {
    "nombre_lignes": len(df),
    "chiffre_affaires_total": df["chiffre_affaires"].sum(),
    "chiffre_affaires_moyen": df["chiffre_affaires"].mean(),
    "nombre_categories": df["categorie"].nunique(),
    "nombre_regions": df["region"].nunique()
}

print(resume_global)

Puis on regarde les performances par catégorie :

ca_par_categorie = (
    df.groupby("categorie")["chiffre_affaires"]
    .sum()
    .sort_values(ascending=False)
)

print(ca_par_categorie)

Ensuite par région :

ca_par_region = (
    df.groupby("region")["chiffre_affaires"]
    .sum()
    .sort_values(ascending=False)
)

print(ca_par_region)

Puis par mois :

ca_par_mois = df.groupby("periode_mensuelle")["chiffre_affaires"].sum()
print(ca_par_mois)

Et enfin on visualise :

ca_par_categorie.plot(kind="bar", figsize=(10, 5))
plt.title("Chiffre d'affaires par catégorie")
plt.tight_layout()
plt.show()

ca_par_mois.plot(kind="line", marker="o", figsize=(10, 5))
plt.title("Évolution mensuelle du chiffre d'affaires")
plt.tight_layout()
plt.show()

À ce stade, on a déjà une vision très utile du fonctionnement du dataset. On sait d’où vient la valeur, quelles zones performent, quelles périodes sont fortes, et où l’on doit creuser davantage. C’est souvent suffisant pour produire un premier rapport solide.

Les erreurs fréquentes à éviter

Même si Pandas est accessible, plusieurs erreurs reviennent très souvent. La première consiste à analyser des données sans les nettoyer correctement. Le résultat peut être séduisant, mais faux. La deuxième consiste à confondre corrélation et causalité. Si les ventes montent en même temps que le trafic, cela ne signifie pas forcément que l’un cause l’autre. La troisième consiste à faire confiance aveuglément à la moyenne. Quand la distribution est asymétrique, la médiane raconte souvent une histoire plus juste.

Une autre erreur fréquente est de multiplier les transformations sans garder de logique reproductible. Quand on teste des idées dans un notebook, il faut prendre le temps de conserver les étapes importantes dans un ordre clair. Sinon, on finit par ne plus savoir comment on est arrivé au résultat final. L’analyse de données doit rester traçable.

Il faut aussi éviter de surinterpréter une petite variation. Une hausse de 2 % n’a pas toujours un sens profond. Parfois, elle relève du bruit naturel. Parfois, elle signale un phénomène réel. Le rôle de l’analyste est justement de distinguer les deux avec méthode.

Bonnes pratiques pour progresser en data analysis avec Pandas

La progression en data analysis n’est pas seulement une affaire de syntaxe. Elle repose aussi sur des habitudes. Il est utile d’apprendre à nommer clairement les colonnes, à garder une copie des données brutes, à documenter ses transformations, à vérifier les types, à contrôler les taux de valeurs manquantes, à comparer avant et après chaque nettoyage. Ces gestes paraissent simples, mais ils font une énorme différence dans la qualité du travail.

Il est aussi très important de pratiquer sur des datasets variés. Un jeu de données de ventes n’a pas la même structure qu’un dataset RH, qu’un fichier log, qu’une base de contenu ou qu’un tableau de production industrielle. Plus vous manipulez de formats différents, plus vous développez une intuition analytique utile. Cette intuition est précieuse, parce qu’elle vous permet de savoir rapidement où regarder, quoi vérifier, et quelles hypothèses tester.

Enfin, ne restez pas bloqué sur la technique pure. Une bonne analyse est celle qui répond à une vraie question. Avant de coder, demandez-vous toujours ce que vous cherchez à comprendre. Est-ce une tendance ? Un écart ? Un comportement ? Une anomalie ? Un risque ? Un potentiel ? Cette question de départ donne de la structure à tout le reste.

Aller plus loin avec l’écosystème Python

Pandas est souvent le cœur du travail, mais il s’inscrit dans un écosystème beaucoup plus large. NumPy apporte des opérations numériques rapides. Matplotlib et Seaborn facilitent la visualisation. Scikit-learn permet d’aller vers la modélisation. Plotly ajoute des graphiques interactifs. SQL reste très utile pour extraire les données depuis les bases relationnelles. Jupyter permet d’explorer les hypothèses de manière fluide. Cette complémentarité fait de Python une boîte à outils particulièrement puissante.

Par exemple, si vous devez lire une requête SQL dans un environnement analytique, vous pouvez utiliser Pandas pour charger directement le résultat d’une base de données, puis poursuivre l’analyse localement.

import sqlite3
import pandas as pd

conn = sqlite3.connect("ma_base.db")
df = pd.read_sql_query("SELECT * FROM ventes", conn)
conn.close()

Cette articulation entre SQL et Pandas est extrêmement courante dans les équipes data. Elle permet d’extraire, transformer, analyser puis présenter les résultats dans une même logique cohérente.

Conclusion : apprendre à voir les données autrement

Apprendre la data analysis avec Python et Pandas, ce n’est pas seulement apprendre une bibliothèque de plus. C’est apprendre à regarder les données avec plus de précision, plus de patience et plus de curiosité. C’est accepter que la donnée brute ne parle pas toujours immédiatement, mais qu’elle finit presque toujours par raconter quelque chose si on lui pose les bonnes questions. C’est aussi découvrir qu’une bonne analyse est autant une affaire de méthode que de technique.

Avec Python et Pandas, vous pouvez commencer petit, sur un fichier CSV modeste, puis monter en complexité au fil des projets. Vous pouvez nettoyer, filtrer, regrouper, fusionner, visualiser, résumer, comparer et mettre en évidence ce qui compte vraiment. Et, peu à peu, vous développez une compétence qui dépasse le code : une capacité à transformer le chaos des chiffres en information utile, compréhensible et actionnable. C’est cette compétence qui fait la différence dans les équipes modernes, car au fond, la data analysis n’est pas là pour produire des tableaux impressionnants. Elle est là pour aider à prendre de meilleures décisions, avec plus de clarté et plus de confiance.

Si vous débutez, commencez par manipuler des petits jeux de données, puis augmentez progressivement la difficulté. Si vous avez déjà un niveau intermédiaire, challengez-vous avec des datasets plus sales, plus volumineux, plus réalistes. Et si vous êtes déjà à l’aise, poussez vos analyses vers des projets complets, documentés et réutilisables. C’est ainsi que l’on progresse vraiment : en pratiquant, en observant, en corrigeant, puis en recommençant avec un regard un peu plus affûté à chaque fois.