Pandas et NumPy : le top tutoriel n°1 pour analyser vos données

Spread the love

De nos jours, les entreprises collectent une quantité phénoménale de données : données clients, trafic web, logs, ventes, capteurs, réseaux sociaux, etc. Mais ces données, à l’état brut, ne disent pas grand-chose. Pour les transformer en informations exploitables, on a besoin d’outils d’analyse de données. Python, grâce à ses bibliothèques puissantes comme Pandas et NumPy, est l’un des langages les plus populaires pour cette tâche. Dans ce tutoriel complet, je vais te guider pas à pas :

Table des matières

Ce guide vise à être suffisamment accessible pour les débutants, tout en apportant assez de valeur pour les développeurs intermédiaires voulant améliorer leur maîtrise.

Pourquoi Python + Pandas et NumPy pour l’analyse de données

Avantages de Python pour la Data

Simplicité et lisibilité : Python a une syntaxe expressive, ce qui le rend facile à apprendre et à lire, même dans des scripts analytiques complexes.
Écosystème riche : bibliothèques pour le traitement de données, visualisation (Matplotlib, Seaborn, Plotly), machine learning (scikit-learn), deep learning (TensorFlow, PyTorch), etc.
Communauté forte : énormément de tutoriels, de forums, de projets open source, ce qui aide énormément quand on bute.
Performance acceptable : même s’il est plus lent que des langages compilés, Python (via les bibliothèques comme NumPy) utilise des optimisations (C, vectorisation) pour manipuler efficacement de grandes quantités de données.

Le rôle de NumPy et Pandas

NumPy (Numerical Python) : il fournit l’objet ndarray (tableau multidimensionnel) qui permet des calculs mathématiques rapides (grâce à la vectorisation).
Pandas : il construit sur NumPy pour offrir des structures de données plus « haut niveau » : les Series (vecteurs) et DataFrame (tableaux étiquetés, à deux dimensions) très utilisées en analyse de données.

En combinant NumPy pour les calculs bas niveau et Pandas pour la manipulation de tables, on a un outil très puissant pour la Data.

Installation et configuration de l’environnement

Avant de commencer à coder, il faut installer les bons outils.

Environnement recommandé : conda / venv

Utiliser un environnement virtuel permet d’isoler les dépendances de ton projet :

# Option 1 : conda (Anaconda / Miniconda)
conda create -n dataenv python=3.10
conda activate dataenv

# Option 2 : venv (venv intégré de Python)
python3 -m venv dataenv
source dataenv/bin/activate  # ou dataenv\Scripts\activate sur Windows

Installer les bibliothèques nécessaires

Tu peux installer Pandas, NumPy, et quelques dépendances utiles :

pip install numpy pandas matplotlib seaborn jupyter

Si tu veux un IDE / notebook :

Jupyter Notebook / Lab : pour faire de l’exploration interactive
VS Code ou PyCharm : pour écrire des scripts plus structurés

NumPy : les bases

NumPy est souvent la fondation de tout traitement numérique en Python.

Création d’un tableau `ndarray`

import numpy as np

# Créer des tableaux à partir de listes Python
arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([[1, 2], [3, 4]])

# Créer des tableaux spéciaux
zeros = np.zeros((3, 4))
ones = np.ones((2, 5))
arange = np.arange(0, 10, 2)  # [0, 2, 4, 6, 8]
lin = np.linspace(0, 1, 5)    # [0. , 0.25, … , 1.0]

print(arr1.shape, arr2.shape)

Opérations vectorisées

L’un des grands avantages est qu’on peut faire des calculs “vectorisés” sans boucles explicites :

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Addition, multiplication
c = a + b          # -> [5, 7, 9]
d = a * b          # -> [4, 10, 18]
e = a * 2          # -> [2, 4, 6]

# Fonctions universelles (ufunc)
f = np.sin(a)
g = np.log(b)

Indexation, slicing, masque

arr = np.array([10, 20, 30, 40, 50])
print(arr[0])        # 10
print(arr[2:5])      # [30, 40, 50]
print(arr[arr > 25]) # [30, 40, 50]

# Sur des tableaux 2D
mat = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(mat[0, :])     # première ligne
print(mat[:, 1])     # deuxième colonne

Quelques fonctions utiles

np.sum, np.mean, np.std, np.min, np.max, etc.
np.concatenate, np.stack, np.vstack, np.hstack
np.where, np.unique, np.sort, etc.

NumPy est donc excellent pour tout ce qui touche aux calculs numériques.

Pandas : manipuler des données tabulaires

Pandas est là pour structurer et manipuler des données “type table” de manière simple et expressive.

Structures principales : Series & DataFrame

import pandas as pd

# Series : vecteur étiqueté
s = pd.Series([10, 20, 30], index=['a', 'b', 'c'])

# DataFrame : table de données
df = pd.DataFrame({
    'nom': ['Alice', 'Bob', 'Charlie'],
    'âge': [25, 30, 22],
    'ville': ['Paris', 'Lyon', 'Marseille']
})
print(df)

Lecture / écriture de fichiers

Pandas est souvent utilisé pour charger des données depuis des fichiers ou bases de données :

df = pd.read_csv('donnees.csv', sep=',', encoding='utf-8')
df2 = pd.read_excel('donnees.xlsx', sheet_name='Feuille1')

# Écriture
df.to_csv('resulats.csv', index=False)
df.to_excel('résultats.xlsx', index=False)

Exploration / statistiques descriptives

df.head(5)       # premières lignes
df.tail(5)       # dernières lignes
df.info()        # info des colonnes
df.describe()    # statistiques numériques
df['âge'].mean() # moyenne d’une colonne
df['ville'].value_counts()  # fréquence des valeurs

Indexation, filtre, sélection

# sélectionner colonnes
df[['nom', 'ville']]

# sélectionner lignes par condition
df[df['âge'] > 23]

# sélectionner par position / étiquette
df.iloc[0, 1]   # 0ᵉ ligne, 1ᵉ colonne
df.loc[2, 'ville']  # ligne index 2, colonne “ville”

Opérations sur les colonnes

# créer une nouvelle colonne
df['âge_plus_5'] = df['âge'] + 5

# appliquer une fonction
df['annee_naissance'] = df['âge'].apply(lambda x: 2025 - x)

# remplacer les valeurs manquantes
df['âge'] = df['âge'].fillna(df['âge'].median())

# suppression / renommage
df = df.drop(columns=['âge_plus_5'])
df = df.rename(columns={'ville': 'ville_actuelle'})

GroupBy, agrégation, pivot

# Agréger par ville : moyenne d’âge
df.groupby('ville')['âge'].mean()

# Ajouter plusieurs agrégats
df.groupby('ville').agg({'âge': ['mean', 'min', 'max']})

# Tableau croisé (pivot)
df.pivot_table(index='ville', columns='nom', values='âge')

Joindre / fusionner des DataFrames

df1 = pd.DataFrame({'id': [1, 2, 3], 'valeur': [10, 20, 30]})
df2 = pd.DataFrame({'id': [2, 3, 4], 'score': [100, 200, 300]})

df_merged = pd.merge(df1, df2, on='id', how='inner')  # intersection
df_left = pd.merge(df1, df2, on='id', how='left')     # tout de df1 + nulls

Trier, classer, trier par index

df_sorted = df.sort_values(by='âge', ascending=False)
df_sorted.reset_index(drop=True, inplace=True)

Gestion des valeurs manquantes / doublons

df = df.dropna()  # supprime les lignes avec des NaN
df = df.drop_duplicates()  # supprime doublons

Exemple concret : analyse de données dans un cas réel

Pour rendre tout cela concret, prenons un cas que tu pourrais publier sur ton blog CoinDuDev.

Cas d’usage : Analyse des ventes mensuelles d’une boutique e-commerce

Imaginons que tu possèdes une boutique en ligne qui vend des produits (par exemple, gadgets, accessoires, T-shirts). Tu veux analyser les ventes mensuelles pour :

Identifier les mois les plus forts/faibles
Observer la croissance ou décroissance
Repérer les produits les plus vendus
Prédire le chiffre d’affaires pour le mois prochain

Voici comment on pourrait procéder avec Python + Pandas + NumPy.

5.1 Préparation des données (fichier CSV fictif)

Supposons qu’on ait un fichier ventes.csv structuré comme suit :

date_vente	produit	quantite	prix_unitaire	client_id
2024-01-05	T-shirt A	2	20	101
2024-01-06	Case B	1	15	102
2024-01-15	T-shirt A	1	20	103
…	…	…	…	…

(On supposera plusieurs milliers de lignes, pour tout un an.)

Code Python pour l’analyse

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

# Chargement
df = pd.read_csv('ventes.csv', parse_dates=['date_vente'])

# Ajouter des colonnes utiles
df['année'] = df['date_vente'].dt.year
df['mois'] = df['date_vente'].dt.month
df['montant'] = df['quantite'] * df['prix_unitaire']

# 1. Chiffre d’affaires par mois
ca_mensuel = df.groupby(['année', 'mois'])['montant'].sum().reset_index()
ca_mensuel['date'] = pd.to_datetime(ca_mensuel[['année', 'mois']].assign(day=1))

# 2. Produit le plus vendu (en quantité) chaque mois
top_produits = (
    df.groupby(['année', 'mois', 'produit'])['quantite']
    .sum()
    .reset_index()
)
# Pour chaque (année, mois), prendre le produit max
top_produits = top_produits.sort_values(['année', 'mois', 'quantite'], ascending=[True, True, False])
top_produits_month = top_produits.groupby(['année', 'mois']).first().reset_index()

# 3. Croissance mois à mois du CA
ca_mensuel = ca_mensuel.sort_values('date')
ca_mensuel['ca_précédent'] = ca_mensuel['montant'].shift(1)
ca_mensuel['croissance_pct'] = (ca_mensuel['montant'] - ca_mensuel['ca_précédent']) / ca_mensuel['ca_précédent'] * 100

# 4. Visualisation
plt.figure(figsize=(12, 6))
sns.lineplot(data=ca_mensuel, x='date', y='montant', marker='o')
plt.title("Chiffre d’affaires mensuel")
plt.xlabel("Mois")
plt.ylabel("CA (€)")
plt.grid(True)
plt.show()

# 5. Tableau résumé
print(ca_mensuel)
print(top_produits_month)

Interprétation des résultats

CA mensuel : tu vois en un coup d’œil les mois où la boutique fait le plus de ventes, les creux et pics.
Croissance mensuelle : tu peux voir les variations en pourcentage d’un mois à l’autre (ex. +15 %, –10 %, etc.).
Produit le plus vendu : pour chaque mois, tu identifies la star du mois.
À partir de ces informations, tu pourrais décider des actions marketing (promotions, stocks, focus sur les best-sellers).

Extension : modélisation simple pour prédiction

En complément, tu pourrais appliquer une modélisation simple comme un modèle ARIMA ou une régression linéaire sur les données mensuelles pour prédire le chiffre d’affaires du mois suivant. Cela irait au-delà de Pandas/NumPy, mais te permettrait d’offrir une valeur ajoutée forte sur ton blog.

Bonnes pratiques & pièges à éviter

Quand on travaille avec de vraies données, il y a des pièges classiques.

Nettoyage de données : valeurs manquantes, duplications

Vérifie les colonnes avec df.isna().sum()
Remplace les valeurs manquantes par la moyenne, la médiane, ou supprime-les si justifié
Supprime les doublons (df.drop_duplicates())
Vérifie les types de données (dates, numériques) : utilise df.dtypes

Types corrects : convertir les colonnes

Parfois les colonnes numériques sont lues comme chaînes. Il faut les convertir :

df['prix_unitaire'] = pd.to_numeric(df['prix_unitaire'], errors='coerce')
df['date_vente'] = pd.to_datetime(df['date_vente'], errors='coerce')

Ne pas itérer ligne par ligne (éviter les boucles explicites)

La force de Pandas/NumPy, c’est la vectorisation. Une boucle for ligne par ligne est beaucoup plus lente. Privilégie les fonctions vectorisées (.apply, .map, etc.).

Attention aux “SettingWithCopyWarning”

Quand tu fais des opérations de filtrage, veille à ne pas travailler sur une vue simplement. Parfois tu veux faire :

df2 = df[df['âge'] > 20]
df2['score'] = df2['score'] * 1.1  # peut provoquer un warning

Dans ce cas, il vaut mieux faire .loc explicitement :

df.loc[df['âge'] > 20, 'score'] = df.loc[df['âge'] > 20, 'score'] * 1.1

Performance & mémoire

Si tu charges des datasets très gros (millions de lignes), Pandas peut devenir lent ou gourmand en mémoire :

Charger seulement les colonnes utiles (paramètre usecols)
Utiliser dtype pour forcer des types plus petits (ex. int32 au lieu de object)
Travailler en “chunks” (traiter les données par morceaux) via pd.read_csv(..., chunksize=100000)
Utiliser des bibliothèques comme Dask ou Vaex pour des datasets volumineux

Documentation et code propre

Ajoute des commentaires
Fractionne le code en fonctions
Vérifie les résultats à chaque étape
Versionne le code dans Git

Opportunités professionnelles : salaires, freelancing, SaaS

Salaires en France / Europe

En France, un Data Analyst gagne en moyenne 3 791 € brut par mois, soit ~ 45 500 €/an (2025)
D’autres sources indiquent un salaire annuel moyen de ~ 40 393 € pour un data analyst en France (Indeed)
Un data analyst / ingénieur data confirmé a un salaire brut annuel moyen de ~ 51 728 € en France
Pour un Développeur Python en France, le salaire médian brut est de ~ 51 000 €/an (≈ 4 250 €/mois) en Île-de-France
Sur des postes plus avancés, un Data Scientist junior peut débuter autour de 42 000-58 000 € en France, avec des augmentations selon l’expérience (DataScientest)
Selon la Société Générale, les salaires typiques pour Data Scientist sont : junior ~ 45 K€, expérimenté ~ 60 K€, senior ~ 80 K€

Ces chiffres montrent qu’il y a un marché rémunérateur pour ceux qui maîtrisent l’analyse de données.

Marché freelance / télétravail

Sur Upwork, il y a de nombreuses missions de Data Analyst (Python), avec des taux horaires typiques allant de 25 à 50 $/h pour des profils intermédiaires (Upwork)
Sur Malt (plateforme française), on trouve plusieurs milliers de profils freelances Python, avec des tarifs journaliers (TJM) élevés selon l’expertise (malt.fr)
La plateforme Fiverr propose des services d’analyse de données en Python, typiquement à partir de £4 à plus selon la complexité (Fiverr.com)
Le rôle de Data Analyst freelance implique traitement, nettoyage, modélisation, reporting, visualisation, souvent en remote selon les clients
Le marché freelance IT en général reste dynamique : développement, data, cloud et SaaS sont parmi les missions les plus externalisées en 2025

Conclusion : il est tout à fait possible de vivre confortablement en tant que freelance spécialisé en analyse de données, à condition d’avoir un bon portfolio, des compétences solides, et un réseau.

Opportunités SaaS / produits de données

Au-delà des missions freelance, maîtriser l’analyse de données ouvre la porte à développer des produits SaaS (Software as a Service) basés sur la donnée :

Outils d’automatisation de reporting (par exemple : dashboard préconfigurés pour PME)
Services de recommandation ou scoring (ex. pour e-commerce, CRM)
APIs analytiques : exposer des modèles statistiques via une API
Plateformes de monitoring, d’alertes, de visualisation de KPI
SaaS de nettoyage / enrichissement de données (ex. correction d’adresses, géocodage, normalisation)

Ces produits, une fois développés, peuvent générer des revenus récurrents et te libérer du modèle “consommation à la tâche” (freelance).

Conclusion

Maîtriser Python pour l’analyse de données avec Pandas et NumPy n’est plus seulement un atout technique, c’est devenu une véritable compétence stratégique sur le marché actuel. En suivant ce tutoriel, tu as posé des bases solides : compréhension des tableaux et de la vectorisation avec NumPy, manipulation avancée de DataFrame grâce à Pandas, étude de cas pratique, et découverte des bonnes pratiques à adopter pour éviter les pièges classiques.

Mais l’apprentissage ne s’arrête pas là. Plus tu progresseras avec Pandas et NumPy, plus tu pourras aborder des projets complexes : visualisation de données, préparation de modèles de machine learning, ou encore automatisation de reporting pour des entreprises. Ces compétences t’ouvrent les portes de métiers en forte croissance comme Data Analyst, Data Scientist ou Développeur Python spécialisé dans la data.

Les opportunités sont nombreuses, que ce soit dans des postes salariés bien rémunérés, en freelance avec une grande flexibilité, ou même dans la création de solutions SaaS autour de l’analyse de données. Grâce à Pandas et NumPy, tu disposes déjà des fondations nécessaires pour explorer toutes ces voies et construire une carrière solide.

👉 Pour aller plus loin, découvre nos autres ressources sur CoinDuDev :

En résumé, l’avenir appartient à ceux qui savent transformer les données brutes en informations utiles. Et avec Pandas et NumPy, tu tiens déjà les bons outils entre tes mains.