Pandas en Python : 7 opérations magiques pour dompter tes données

—

🚀 Pandas en Python : dompte tes données comme un pro (même si tu débutes)

Un fichier CSV mal formaté à nettoyer ? Un tableau Excel de 10 000 lignes à analyser ? Ou simplement l’envie de comprendre comment les data scientists transforment des données brutes en décisions éclairées ? Pandas est ton couteau suisse.

Pourtant, beaucoup bloquent sur les bases :

« Comment filtrer mes données sans tout casser ? »

« Pourquoi mon code met 10 minutes à s’exécuter ? »

« DataFrame, Series, array… C’est quoi la différence ? »

Ce guide répond à ces questions sans jargon inutile, avec des exemples prêts à l’emploi et des pièges à éviter. Prêt à passer de « Je sais que Pandas existe » à « Je l’utilise au quotidien sans y penser » ? C’est parti.

—

🛠️ 7 opérations Pandas que tu vas utiliser tous les jours (et qui te feront gagner des heures)

1️⃣ Créer un DataFrame : la fondation de tout projet

Un DataFrame, c’est une table intelligente — comme Excel, mais en plus puissant. Tu peux le créer à partir d’un dictionnaire, d’une liste, ou importer directement un fichier CSV/Excel.

import pandas as pd

# À partir d'un dictionnaire (le plus simple)
data = {
    "Nom": ["Alice", "Bob", "Charlie"],
    "Âge": [25, 30, 35],
    "Ville": ["Paris", "Lyon", "Bordeaux"]
}

df = pd.DataFrame(data)
print(df)
**Résultat :**
      Nom  Âge      Ville
0   Alice   25     Paris
1     Bob   30      Lyon
2  Charlie  35  Bordeaux
*Le détail qui change tout* : Pandas gère automatiquement :
- Les **index** (la colonne de gauche, numérotée par défaut).
- Les **types de données** (nombres, texte, dates…).

**Astuce pro** : Pour importer un CSV, utilise `pd.read_csv("fichier.csv")`. Pour Excel : `pd.read_excel("fichier.xlsx")`.

---

### 2️⃣ Sélectionner une colonne : extraire l’information qui compte
Besoin d’isoler une colonne pour calculer une moyenne ou tracer un graphique ? Deux méthodes existent.

python
# Méthode 1 : Accès direct (retourne une Series)
ages = df["Âge"]
print(ages)
**Résultat :**
0    25
1    30
2    35
Name: Âge, dtype: int64

python
# Méthode 2 : Double crochet (retourne un DataFrame)
ages_df = df[["Âge"]]
print(ages_df)
**Résultat :**
   Âge
0   25
1   30
2   35
⚠️ **Pourquoi cette différence ?**
- Une **Series** (1 crochet) = une colonne unique (comme une liste).
- Un **DataFrame** (2 crochets) = une table avec une seule colonne (utile pour les opérations complexes).

---

### 3️⃣ Filtrer des lignes : trouver les données qui matchent tes critères
Tu veux **seulement les personnes de plus de 30 ans** ? Ou les villes dont le nom commence par "P" ? Pandas te permet de filtrer en une ligne, **sans boucle**.

python
# Filtrer les personnes de plus de 30 ans
plus_de_30 = df[df["Âge"] > 30]
print(plus_de_30)
**Résultat :**
      Nom  Âge    Ville
2  Charlie   35  Bordeaux

**Variantes utiles** :
1. **Combiner plusieurs conditions** avec `&` (ET) ou `|` (OU) :

# Personnes de plus de 30 ans ET vivant à Bordeaux

filtre = df[(df[« Âge »] > 30) & (df[« Ville »] == « Bordeaux »)]

2. **Filtrer par texte** (ex : villes commençant par "P") :

villes_p = df[df[« Ville »].str.startswith(« P »)]

3. **Filtrer par liste de valeurs** (ex : âges 25 ou 35) :

ages_specific = df[df[« Âge »].isin([25, 35])]

---

### 4️⃣ Ajouter une colonne : enrichir ton DataFrame en 2 secondes
Besoin d’ajouter une nouvelle information ? Par exemple, un **statut "Majeur/Mineur"** ou un calcul basé sur une autre colonne.

python
# Méthode 1 : Avec une liste (compréhension de liste)
df["Statut"] = ["Majeur" if age >= 18 else "Mineur" for age in df["Âge"]]

# Méthode 2 : Vectorisé (plus rapide et propre)
df["Âge_dans_10_ans"] = df["Âge"] + 10

print(df)
**Résultat :**
      Nom  Âge      Ville   Statut  Âge_dans_10_ans
0   Alice   25     Paris   Majeur              35
1     Bob   30      Lyon   Majeur              40
2  Charlie  35  Bordeaux   Majeur              45
*Pourquoi la méthode 2 est meilleure ?*
- **Plus rapide** : Pandas optimise les opérations vectorisées.
- **Plus lisible** : Pas besoin de boucle explicite.

---

### 5️⃣ Obtenir des statistiques : `describe()` pour un diagnostic express
Tu veux connaître **la moyenne, l’écart-type, les valeurs min/max** d’une colonne ? `describe()` te donne tout ça en une ligne.

python
stats = df["Âge"].describe()
print(stats)
**Résultat :**
count     3.000000
mean     30.000000
std       5.000000
min      25.000000
25%      27.500000
50%      30.000000
75%      32.500000
max      35.000000
Name: Âge, dtype: float64
*Ce que ça révèle* :
- **count** : Nombre de valeurs non nulles (3 ici).
- **mean** : Moyenne (30 ans).
- **std** : Écart-type (5 ans → les âges sont proches de la moyenne).
- **min/max** : Valeurs extrêmes (25 et 35 ans).

**Cas pratique** : Si `std` est très élevé, méfie-toi des **outliers** (valeurs aberrantes).

---

### 6️⃣ Trier tes données : du plus petit au plus grand (ou l’inverse)
Classer tes données par ordre croissant ou décroissant ? `sort_values()` est ton allié.

python
# Trier par âge (du plus jeune au plus âgé)
df_trié = df.sort_values(by="Âge")
print(df_trié)
**Résultat :**
      Nom  Âge      Ville   Statut  Âge_dans_10_ans
0   Alice   25     Paris   Majeur              35
1     Bob   30      Lyon   Majeur              40
2  Charlie  35  Bordeaux   Majeur              45

**Variantes** :
- **Ordre décroissant** : Ajoute `ascending=False`.

dftriédesc = df.sort_values(by=« Âge », ascending=False)

- **Trier par plusieurs colonnes** :

df.sort_values(by=[« Ville », « Âge »]) # D’abord par ville, puis par âge

---

### 7️⃣ Supprimer une colonne ou une ligne : nettoyer ton DataFrame
Une colonne inutile ? Une ligne erronée ? `drop()` est là pour ça.

python
# Supprimer la colonne "Statut"
df = df.drop(columns=["Statut"])
print(df)
**Résultat :**
      Nom  Âge      Ville  Âge_dans_10_ans
0   Alice   25     Paris              35
1     Bob   30      Lyon              40
2  Charlie  35  Bordeaux              45

**Pour supprimer une ligne** :
python
# Supprimer la ligne d'index 1 (Bob)
df = df.drop(index=1)

**Astuce** : Par défaut, `drop()` ne modifie pas le DataFrame original. Pour le modifier **directement**, utilise `inplace=True` :
python
df.drop(columns=["Statut"], inplace=True)

---

## 🔥 3 astuces pour devenir un ninja de Pandas

### 1️⃣ Évite les boucles `for` (sauf si vraiment nécessaire)
Pandas est conçu pour les **opérations vectorisées** (appliquer une opération à toute une colonne en une fois). Les boucles `for` sont **100x plus lentes** car elles utilisent Python pur, alors que Pandas optimise en C.

python
# ❌ Lent (boucle for)
for i in range(len(df)):
    df.loc[i, "Âge_dans_10_ans"] = df.loc[i, "Âge"] + 10

# ✅ Rapide (vectorisé)
df["Âge_dans_10_ans"] = df["Âge"] + 10
*Quand utiliser une boucle ?*
- Pour des opérations **très complexes** qui ne peuvent pas être vectorisées.
- Pour itérer sur des **groupes** (avec `groupby()`).

---

### 2️⃣ Utilise `df.info()` pour diagnostiquer tes données en 2 secondes
Avant de plonger dans l’analyse, vérifie la structure de ton DataFrame avec `df.info()`. C’est **le premier réflexe** des pros.

python
df.info()
**Exemple de sortie :**
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 3 entries, 0 to 2
Data columns (total 4 columns):
 #   Column           Non-Null Count  Dtype
---  ------           --------------  -----
 0   Nom              3 non-null      object
 1   Âge              3 non-null      int64
 2   Ville            3 non-null      object
 3   Âge_dans_10_ans  3 non-null      int64
dtypes: int64(2), object(2)
memory usage: 200.0+ bytes
*Ce que ça te dit* :
- **Nombre de lignes/colonnes** : 3 lignes, 4 colonnes.
- **Types de données** :
  - `int64` = nombres entiers.
  - `object` = texte (ou mélange de types).
- **Valeurs manquantes** : `Non-Null Count` (ici, aucune valeur manquante).
- **Mémoire utilisée** : Utile pour les gros datasets.

**Problème courant** : Si une colonne numérique est de type `object`, c’est souvent dû à des valeurs non numériques (ex : "N/A"). Utilise `pd.to_numeric()` pour la convertir.

---

### 3️⃣ Sauvegarde tes DataFrames avec `to_pickle()` (et gagne du temps)
Tu as passé 1h à nettoyer et transformer tes données ? **Ne perds pas ton travail.** Sauvegarde ton DataFrame dans un fichier `.pkl` pour le recharger en 1 seconde.

python
# Sauvegarder
df.to_pickle("mon_dataframe.pkl")

# Charger
df = pd.read_pickle("mon_dataframe.pkl")
*Pourquoi `.pkl` est mieux qu’un CSV ?*
| Format  | Avantages                          | Inconvénients                     |
|---------|------------------------------------|-----------------------------------|
| **Pickle** | Rapide, conserve les types de données, gère les index | Moins lisible par l’homme |
| **CSV**   | Lisible, compatible partout        | Lent, perd les types de données   |

**Cas d’usage** :
- `.pkl` : Pour sauvegarder un DataFrame **intermédiaire** dans un projet.
- `.csv` : Pour partager des données avec des non-développeurs.

---

## 🆚 Pandas vs les alternatives : lequel choisir en 2024 ?

| Outil       | Avantages                          | Inconvénients                     | Quand l’utiliser ?               |
|-------------|------------------------------------|-----------------------------------|----------------------------------|
| **Pandas**  | Standard, riche en fonctionnalités, excellente documentation | Lent sur les très gros datasets (>1M de lignes) | 90% des cas (débutants et pros) |
| **Polars**  | Ultra-rapide (écrit en Rust), moderne, gère les gros datasets | Moins de documentation, syntaxe différente | Datasets >10M de lignes ou performances critiques |
| **Dask**    | Parallélisation, scalable, compatible Pandas | Complexe à configurer, surcoût mémoire | Calculs distribués (Big Data) |
| **Liste Python** | Simple, léger               | Pas optimisé pour l’analyse de données | Petits projets sans besoin d’analyse |

*Notre recommandation* :
1. **Commence par Pandas** : C’est l’outil le plus polyvalent et le mieux documenté.
2. **Passe à Polars** si tu travailles sur des datasets de plusieurs Go et que la vitesse est critique.
3. **Utilise Dask** si tu fais du Big Data (ex : traitement de logs en temps réel).

---

## 📚 Ressources pour aller plus loin (et devenir un expert)
- **Documentation officielle** : [pandas.pydata.org/docs](https://pandas.pydata.org/docs/) (la référence absolue, mais dense).
- **Cours interactif** : [Pandas sur Kaggle](https://www.kaggle.com/learn/pandas) (gratuit, pratique, avec des datasets réels).
- **Livre** : *"Python for Data Analysis"* de Wes McKinney (le créateur de Pandas).
- **Dataset d’exemple** : [Titanic sur Kaggle](https://www.kaggle.com/c/titanic) (parfait pour s’entraîner aux bases).
- **Cheat Sheet** : [Pandas Cheat Sheet PDF](https://pandas.pydata.org/Pandas_Cheat_Sheet.pdf) (à imprimer et garder sous la main).

---

## 🎯 Pandas : la compétence qui ouvre toutes les portes de la Data
Avec ces 7 opérations de base, tu es déjà **plus efficace qu’avec Excel ou des listes Python**. Mais Pandas ne s’arrête pas là :
- **Nettoyage de données** : `dropna()`, `fillna()`, `replace()`.
- **Fusion de DataFrames** : `merge()`, `concat()`, `join()`.
- **Analyses avancées** : `groupby()`, `pivot_table()`, `crosstab()`.

*Le secret pour maîtriser Pandas ?* **Pratique, pratique, pratique.**
1. Télécharge un dataset qui t’intéresse (sport, finance, jeux vidéo…).
2. Pose-toi une question (ex : *"Quelle est la ville avec la moyenne d’âge la plus élevée ?"*).
3. Utilise Pandas pour y répondre.

**Exemple concret** :
python
# Moyenne d'âge par ville
moyennes_par_ville = df.groupby("Ville")["Âge"].mean()
print(moyennes_par_ville)
**Résultat :**
Ville
Bordeaux    35.0
Lyon        30.0
Paris       25.0
Name: Âge, dtype: float64

**Et toi, quel dataset vas-tu explorer en premier ?** Un fichier de ventes, des données météo, ou peut-être les résultats de ton sport préféré ? 🚀