🐼 Pandas – L'Analyse de Données en Python

Pandas résout le problème des données "tabulaires" (structurées) en Python.

Pandas est le **"prétraitement" (ETL)** de 90% des workflows de Machine Learning (Scikit-learn, TF, PyTorch).

L'installation se fait via pip ou conda. (Un environnement virtuel Python venv est fortement recommandé).

# 1. Installation (via pip)
# (Installe aussi NumPy)
pip install pandas

# (Pour Excel:
# pip install openpyxl
# (Pour SQL:
# pip install sqlalchemy

Import (Convention)

L'alias pd est la convention universelle (tout comme np pour NumPy).

import pandas as pd
import numpy as np

print(pd.__version__)

Une Series est un tableau 1D (similaire à NumPy) mais avec un **Index** (labels).

C'est la structure qui représente **une colonne** d'un DataFrame.

# Création (Index par défaut [0, 1, 2])
s = pd.Series([10, 20, 30])
# 0    10
# 1    20
# 2    30
# dtype: int64

# Création (Index custom)
s_custom = pd.Series(
    [10, 20, 30],
    index=['a', 'b', 'c']
)
# a    10
# b    20
# c    30
# dtype: int64

# Accès (via l'index)
print(s_custom['b']) # 20

Le DataFrame (df) est l'objet principal de Pandas. C'est une structure 2D (Lignes et Colonnes) similaire à une feuille Excel ou une table SQL.

Un DataFrame est une **collection de Series** (les colonnes) qui partagent le même Index (les lignes).

Création (ex: depuis un Dictionnaire)

data = {
    'nom': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'ville': ['Paris', 'Londres', 'Tokyo']
}

df = pd.DataFrame(data)

# (Affiche :)
#        nom  age    ville
# 0    Alice   25    Paris
# 1      Bob   30  Londres
# 2  Charlie   35    Tokyo

# (Les colonnes)
print(df.columns) # ['nom', 'age', 'ville']

# (L'index)
print(df.index) # RangeIndex(start=0, stop=3, step=1)

Une fois le df chargé, la première étape est de l'inspecter.

.loc sélectionne les données par LABEL (le nom de l'index ou le nom de la colonne).

Syntaxe : df.loc[,]

# (Supposons un df avec index 'a', 'b', 'c'
# et colonnes 'age', 'ville')

# 1. Sélectionner une colonne (Series)
# (Ceci est le raccourci le plus courant)
col_age = df['age']
# (Équivalent à df.loc[:, 'age'])

# 2. Sélectionner plusieurs colonnes (DataFrame)
df_subset = df[['age', 'ville']]
# (Équivalent à df.loc[:, ['age', 'ville']])

# 3. Sélectionner une ligne (par label d'index)
ligne_b = df.loc['b'] # (Retourne une Series)

# 4. Sélectionner plusieurs lignes
lignes_ac = df.loc[['a', 'c']]

# 5. Sélection Ligne ET Colonne
cellule = df.loc['b', 'age'] // (Valeur unique)
subset = df.loc[['a', 'c'], ['age', 'ville']]

.iloc sélectionne les données par POSITION ENTIÈRE (0, 1, 2... style Python).

Syntaxe : df.iloc[,]

# 1. Sélectionner la 1ère ligne
ligne_0 = df.iloc[0]

# 2. Sélectionner la 1ère colonne
col_0 = df.iloc[:, 0]

# 3. Sélectionner les 5 premières lignes
lignes_0_4 = df.iloc[0:5] // (Slice Python, 5 est exclusif)

# 4. Sélectionner la dernière ligne
ligne_last = df.iloc[-1]

# 5. Sélection Ligne ET Colonne
cellule = df.iloc[0, 0] // (1ère ligne, 1ère colonne)
subset = df.iloc[0:5, [0, 2]] // (5 1ères lignes, cols 0 et 2)

C'est la méthode de filtrage la plus puissante. On passe une Series de Booléens (le "masque") au df[].

1. Condition Simple

// 1. Créer le masque (une Series de True/False)
masque = df['age'] > 30

// 2. Appliquer le masque au DataFrame
df_filtre = df[masque]
// (Retourne que les lignes où le masque est True)

2. Conditions Multiples (&, |)

(Utiliser & (ET) et | (OU). Ne pas utiliser and/or. Parenthèses obligatoires).

masque_multi = (df['age'] > 30) & (df['ville'] == 'Paris')

df_filtre_multi = df[masque_multi]

Les données manquantes (NaN - Not a Number) sont le fléau de la Data Science. sklearn les rejette.

1. Détection

// (Compte les NaN par colonne)
print(df.isnull().sum())
// nom      0
// age      12 (12 NaN dans 'age')
// ville    2

2. Suppression (.dropna())

// (Supprime TOUTES les lignes
// ayant AU MOINS un NaN)
df_clean = df.dropna()

// (Supprime les colonnes ayant des NaN)
df_clean_cols = df.dropna(axis=1)

3. Remplacement (.fillna()) (Souvent préféré)

// (Remplacer les NaN 'age' par la moyenne)
mean_age = df['age'].mean()
df['age'] = df['age'].fillna(mean_age)

// (Remplacer les NaN 'ville' par "Inconnu")
df['ville'] = df['ville'].fillna("Inconnu")

.apply() est le "couteau-suisse" pour appliquer une fonction complexe à chaque élément d'une Series (colonne) ou à chaque ligne (axis=1).

1. .apply() sur une Colonne (Series)

// (Fonction Python)
def classer_age(age):
    if age < 30:
        return "Jeune"
    else:
        return "Senior"

// (Appliquer la fonction à chaque 'age')
df['categorie_age'] = df['age'].apply(classer_age)

// (Version 'lambda' (anonyme), identique)
df['categorie_age'] = df['age'].apply(
    lambda x: "Jeune" if x < 30 else "Senior"
)

2. .apply() sur des Lignes (axis=1)

(Plus lent, mais utile si la logique dépend de plusieurs colonnes).

// (La lambda reçoit la 'ligne' (row) entière)
df['ratio'] = df.apply(
    lambda row: row['col_A'] / row['col_B'],
    axis=1 // (Spécifie "par ligne")
)

C'est la fonctionnalité la plus puissante de Pandas (similaire au GROUP BY de SQL). Elle suit un processus en 3 étapes : **Split-Apply-Combine**.

Diagramme : Split-Apply-Combine

(DF Original)
+-------+-----+
| Ville | Prix|
+-------+-----+
| Paris | 100 |
| Tokyo | 150 |
| Paris | 200 |
| Tokyo | 250 |
+-------+-----+
      |
      | 1. SPLIT (par 'Ville')
      ▼
+-------+-----+     +-------+-----+
| Paris | 100 |     | Tokyo | 150 |
| Paris | 200 |     | Tokyo | 250 |
+-------+-----+     +-------+-----+
      |                   |
      | 2. APPLY (.mean())|
      ▼                   ▼
    [ 150 ]             [ 200 ]
      |                   |
      | 3. COMBINE        |
      ▼                   ▼
+-------+-----+
| Ville | Prix|
+-------+-----+
| Paris | 150 |
| Tokyo | 200 |
+-------+-----+

Syntaxe (.agg())

// 1. Grouper (ne calcule rien, crée un objet GroupBy)
grouped = df.groupby('ville')

// 2. Apply/Combine (calcul)
// (Moyenne des colonnes numériques)
moyennes = grouped.mean()

// (Syntaxe complète avec .agg() pour multi-calculs)
stats = df.groupby('ville').agg(
    salaire_moyen=('salaire', 'mean'),
    age_max=('age', 'max'),
    nb_clients=('nom', 'count')
)

pd.merge() est la fonction (similaire au JOIN SQL) pour combiner des DataFrames sur une (ou plusieurs) colonne(s) "clé".

df_clients = pd.DataFrame({
    'user_id': [1, 2, 3], 'nom': ['A', 'B', 'C']
})
df_achats = pd.DataFrame({
    'user_id': [2, 3, 4], 'achat': ['Pomme', 'Poire', 'Fraise']
})

// (Jointure sur 'user_id', how='inner')
df_inner = pd.merge(
    df_clients, 
    df_achats, 
    on='user_id',
    how='inner' // (Défaut)
)
// (Retourne user_id 2 et 3)

df_left = pd.merge(
    df_clients, 
    df_achats, 
    on='user_id',
    how='left'
)
// (Retourne user_id 1, 2, 3.
// 'achat' pour user_id 1 sera NaN)

// how='right' (Garde tout de 'df_achats')
// how='outer' (Garde tout de 1, 2, 3, 4)

pd.concat() "empile" (stack) ou "colle" (join) des DataFrames.

df_jan = pd.read_csv("jan.csv")
df_fev = pd.read_csv("fev.csv")

// (Empile les lignes)
df_total = pd.concat(
    [df_jan, df_fev],
    axis=0,
    ignore_index=True // (Re-génère l'index 0,1,2...)
)

df_data = ...
df_labels = ... (indexés pareil)

// (Colle les colonnes)
df_total = pd.concat(
    [df_data, df_labels],
    axis=1
)

Pandas est l'outil **standard** de tout Data Scientist, Data Analyst, ou Ingénieur ML travaillant en Python. Il est la **fondation** du preprocessing pour le ML.

La documentation de Pandas est excellente, notamment le "User Guide".