Pourquoi read_csv reste incontournable

Parce qu’il transforme un simple fichier texte (CSV, TSV, “CSV Excel” au point-virgule, CSV compressé, flux HTTP/S3…) en DataFrame exploitable en 1 ligne. La clé, c’est de spécifier tôt séparateur, encodage, types et dates pour éviter les mauvaises surprises (colonnes “object”, dates non reconnues, virgule décimale, etc.).

---

Démarrage express (3 cas fréquents)

1) CSV “classique” (séparateur ,, UTF-8)

import pandas as pd

df = pd.read_csv("data.csv")  # heuristiques par défaut

2) Export Excel “français” (séparateur ;, décimale ,)

df = pd.read_csv(
    "export_excel.csv",
    sep=";",          # point-virgule
    decimal=",",      # virgule décimale
    thousands="\u00A0"  # NBSP souvent présent comme séparateur de milliers
)

3) Dates et types imposés

dtypes = {"id": "Int64", "categorie": "category", "prix_ht": "float64"}

df = pd.read_csv(
    "ventes.csv",
    sep=";",
    decimal=",",
    parse_dates=["date_vente"],
    dayfirst=True,     # format français DD/MM/YYYY
    dtype=dtypes,
    na_values=["", "NA", "N/A", "-", "null"]
)

---

Les paramètres qui font (vraiment) la différence

Séparateur & entêtes

• sep=";" pour les exports FR/Excel.
• header=0 (défaut) si la première ligne contient les noms de colonnes.
• names=[...] pour imposer les noms (utile si fichier sans en-tête).
• usecols=[...] charge uniquement les colonnes utiles (mémoire + vitesse).

Encodage & robustesse

• encoding="utf-8" (recommandé), ou encoding="latin-1" / "cp1252" si accents cassés.
• encoding_errors="ignore" ou "replace" pour survivre aux caractères illisibles (mieux vaut loguer ces cas pour correction amont).

Nombres & décimales “à la française”

• decimal="," et thousands="\u00A0" (NBSP) ou " " selon vos fichiers.
• Évitez de mélanger , et . pour les décimales dans un même champ : normalisez tôt.

Dates & fuseaux

• parse_dates=[...] + dayfirst=True pour DD/MM/YYYY.
• Si le format est exotique (horodatage, fuseaux, etc.), chargez d’abord en chaîne puis transformez :

df = pd.read_csv("logs.csv", dtype={"ts": "string"})
df["ts"] = pd.to_datetime(df["ts"], utc=True, errors="coerce")  # format explicite si connu

Booléens & valeurs manquantes

• true_values=["OUI","Oui","YES","1"], false_values=["NON","No","0"].
• na_values=[...] pour compléter la liste par défaut (ex. "-", "NULL").
• keep_default_na=True (défaut) : garde la liste standard de NA.

Qualité & lignes “défectueuses”

• on_bad_lines="skip" (ou "warn") pour ignorer/avertir sur les lignes mal formées.
  Astuce : ces options sont souvent plus tolérantes avec engine="python" : df = pd.read_csv("cassé.csv", on_bad_lines="skip", engine="python")

Dtypes & backend

• Imposez les types via dtype={"code":"string", "qte":"Int64", "prix":"float64"} :
  – Int64 (nullable), string (pandas), category (faible cardinalité) = RAM plus basse et erreurs plus tôt.
• Si disponible, dtype_backend="pyarrow" peut réduire l’empreinte mémoire et accélérer certaines opérations (selon votre stack).

Moteur & performance

• engine="c" (rapide, défaut) ; engine="python" (plus tolérant).
• Indicateurs utiles :
  • usecols (colonne subset)
  • dtype (évite mixes dtypes)
  • chunksize=... (streaming)
  • memory_map=True (selon OS/fichiers)
  • low_memory=False si vous voulez éviter les colonnes “mixtes” (au prix de plus de RAM).

---

Gros volumes : lecture en morceaux (streaming)

Agréger un indicateur sans charger tout le fichier

total = 0.0
for chunk in pd.read_csv(
        "big.csv",
        usecols=["montant"],
        dtype={"montant": "float64"},
        chunksize=1_000_000):
    total += chunk["montant"].sum()
print(total)

Chargement partiel + concat

from pathlib import Path
import pandas as pd

dtypes = {"id": "Int64", "montant": "float64", "client": "string"}
files = sorted(Path("data").glob("*.csv"))

df = pd.concat(
    (pd.read_csv(f, sep=";", decimal=",", usecols=["id","client","montant"], dtype=dtypes)
     for f in files),
    ignore_index=True
)

---

Sources distantes, archives & cloud

• URL HTTP/HTTPS : df = pd.read_csv("https://exemple.com/datasets/ventes.csv")
• Fichiers compressés (auto-détectés le plus souvent) : df = pd.read_csv("ventes_2024.csv.gz") # gzip df = pd.read_csv("ventes.zip") # si le ZIP contient un seul CSV
• Stockage objet (via fsspec) : df = pd.read_csv("s3://mon-bucket/ventes.csv", storage_options={"anon": False}) (Adaptez vos credentials selon l’environnement.)

---

Nettoyage & transformation dès la lecture

Colonnes à renommer / re-ordonner

df = pd.read_csv("source.csv", usecols=["ID","Nom client","CA (HT)"])
df = df.rename(columns={"ID":"id", "Nom client":"client", "CA (HT)":"ca_ht"})[["id","client","ca_ht"]]

Normaliser du texte & booleans

# Valeurs oui/non hétérogènes -> booléen propre
df = pd.read_csv(
    "clients.csv",
    converters={"actif": lambda x: str(x).strip().lower() in {"oui","yes","true","1"}}
).astype({"actif": "boolean"})

Data quality “à l’entrée”

ATTENDU_COLS = {"id","client","date_vente","montant"}
df = pd.read_csv("ventes.csv", sep=";", decimal=",", parse_dates=["date_vente"])
manquantes = ATTENDU_COLS - set(df.columns)
if manquantes:
    raise ValueError(f"Colonnes manquantes: {sorted(manquantes)}")

# Contrôle types simples
assert pd.api.types.is_datetime64_any_dtype(df["date_vente"])
assert pd.api.types.is_numeric_dtype(df["montant"])

---

Modèles prêts à copier (recettes)

1) Loader “FR-proof” (séparateur ;, virgule décimale, NBSP)

def read_csv_fr(path, *, cols=None, dtypes=None, parse_dates=None):
    import pandas as pd
    return pd.read_csv(
        path,
        sep=";",
        decimal=",",
        thousands="\u00A0",
        usecols=cols,
        dtype=dtypes,
        parse_dates=parse_dates,
        dayfirst=True,
        na_values=["", "NA", "N/A", "-", "null"]
    )

2) Pipeline gros volumes (sum, count, groupby)

from collections import Counter
import pandas as pd

def stats_par_client(path, chunksize=500_000):
    totaux = Counter()
    for chunk in pd.read_csv(
        path,
        usecols=["client","montant"],
        dtype={"client":"string", "montant":"float64"},
        chunksize=chunksize
    ):
        totaux.update(chunk.groupby("client")["montant"].sum().to_dict())
    return pd.Series(totaux, name="ca_ht").sort_values(ascending=False).to_frame()

3) Lecture tolérante (fichiers “un peu cassés”)

df = pd.read_csv(
    "source_irreguliere.csv",
    engine="python",
    on_bad_lines="skip",
    sep=";"
)

---

Checklist express (à coller dans vos projets)

• Déterminer sep / decimal / thousands (FR ≈ sep=";", decimal=",", thousands=NBSP).
• Fixer encoding (utf-8, sinon latin-1/cp1252) + encoding_errors.
• usecols & dtype (types explicites, category si faible cardinalité).
• parse_dates + dayfirst=True (ou conversion après lecture si format complexe).
• na_values, true_values/false_values.
• on_bad_lines et/ou engine="python" si fichiers irréguliers.
• chunksize pour le streaming sur gros volumes.
• tests de schéma (colonnes attendues, types, valeurs interdites).

---

Erreurs courantes & remèdes rapides

• UnicodeDecodeError : essayez encoding="latin-1" ou encoding_errors="replace".
• Colonnes en “object” au lieu de numériques : imposez dtype et/ou decimal/thousands.
• Dates non reconnues : parse_dates + dayfirst, ou conversion après lecture avec pd.to_datetime(..., format=..., errors="coerce").
• Colonnes “mixtes” (warnings sur types) : low_memory=False et/ou types imposés, ou nettoyez amont.
• Fichier volumineux (RAM insuffisante) : chunksize, usecols, dtype serrés, éventuellement dtype_backend="pyarrow" si votre environnement le permet.

---

Cas particuliers — pandas.read_csv

1) Encodage incertain, BOM, caractères “bizarres”

# Essai en UTF-8 avec BOM (souvent depuis Excel/Windows)
df = pd.read_csv("data.csv", encoding="utf-8-sig")

# Si accents cassés :
df = pd.read_csv("data.csv", encoding="latin-1")  # ou "cp1252"
# En mode “je préfère charger et corriger après” :
df = pd.read_csv("data.csv", encoding="utf-8", encoding_errors="replace")

2) Séparateur ambigu (, vs ; vs \t) → auto-détection

# Heuristique Sniffer (nécessite engine='python')
df = pd.read_csv("data.csv", sep=None, engine="python")

Si vous connaissez le séparateur, imposez-le (plus fiable).

3) Formats “FR” : ; + virgule décimale + milliers insécables

df = pd.read_csv(
    "export.csv",
    sep=";",
    decimal=",",
    thousands="\u00A0"  # NBSP très fréquent
)

4) Champs multi-lignes entre guillemets

import csv
df = pd.read_csv(
    "notes.csv",
    sep=";",
    engine="python",          # plus tolérant pour sauts de ligne intégrés
    quotechar='"',
    doublequote=True          # "" devient " dans le champ
)

5) Guillemets/échappements atypiques

import csv
df = pd.read_csv(
    "weird.csv",
    sep=";",
    engine="python",
    quotechar="'",            # guillemet simple comme délimiteur
    doublequote=False,
    escapechar="\\",          # séquence d’échappement \'
)

6) En-têtes “pollués”, plusieurs lignes de titres, pied de page

# Sauter des lignes d’en-tête non tabulaires
df = pd.read_csv("rapport.csv", skiprows=3)          # ignore 3 premières

# Multi-index de colonnes (ex. 2 lignes d’en-têtes)
df = pd.read_csv("multiheader.csv", header=[0,1])

# Pied de page (nécessite engine='python')
df = pd.read_csv("rapport.csv", skipfooter=2, engine="python")

7) Colonnes irrégulières (largeur variable, champs manquants)

df = pd.read_csv(
    "messy.csv",
    sep=";",
    engine="python",        # tolère colonnes inégales
    on_bad_lines="skip"     # ou "warn" pour diagnostiquer
)

8) Préserver les zéros en tête (codes, SIRET, CP)

# Lire en chaîne (string) pour ne pas perdre les zéros
df = pd.read_csv("codes.csv", dtype={"code_postal": "string", "siret": "string"})

9) Très grands entiers (IDs) → éviter la notation scientifique

df = pd.read_csv("ids.csv", dtype={"id": "string"})  # pas en float !

10) Dates ambiguës / multi-formats

# Si le format est stable (FR) :
df = pd.read_csv("ventes.csv", sep=";", parse_dates=["date"], dayfirst=True)

# Si les formats varient → lire en string puis convertir :
df = pd.read_csv("ventes.csv", dtype={"date": "string"})
df["date"] = pd.to_datetime(
    df["date"],
    errors="coerce",    # valeurs inconvertibles → NaT
    dayfirst=True       # aide pour 01/02/2025 (1er février)
)

11) Horodatages ISO/Z, fuseaux, ou “epoch”

# ISO 8601 avec 'Z' (UTC)
df = pd.read_csv("log.csv", dtype={"ts": "string"})
df["ts"] = pd.to_datetime(df["ts"], utc=True, errors="coerce")

# Epoch (secondes)
df = pd.read_csv("events.csv", dtype={"ts": "Int64"})
df["ts"] = pd.to_datetime(df["ts"], unit="s", utc=True, errors="coerce")

12) Colonnes numériques “mixtes” (texte + nombres)

# Lire en string, nettoyer, puis convertir
df = pd.read_csv("mix.csv", dtype={"montant": "string"})
df["montant"] = (df["montant"]
                 .str.replace("\u00A0", "", regex=False)  # suppr. NBSP
                 .str.replace(",", ".", regex=False))     # virgule → point
df["montant"] = pd.to_numeric(df["montant"], errors="coerce")

13) Sous-ensemble de colonnes + dtypes imposés (RAM ↓, erreurs ↑ tôt)

dtypes = {"id":"Int64", "client":"string", "ca":"float64"}
df = pd.read_csv("ventes.csv", usecols=["id","client","ca"], dtype=dtypes)

14) Gros volumes (fichier > RAM) : streaming & agrégats

total = 0.0
for chunk in pd.read_csv("big.csv", usecols=["montant"], dtype={"montant":"float64"}, chunksize=1_000_000):
    total += chunk["montant"].sum()

15) Plusieurs CSV à fusionner

from pathlib import Path
import pandas as pd

files = sorted(Path("data").glob("*.csv"))
frames = (pd.read_csv(f, sep=";", decimal=",", usecols=["id","montant"]) for f in files)
df = pd.concat(frames, ignore_index=True)

16) ZIP contenant plusieurs CSV

import zipfile, io, pandas as pd

rows = []
with zipfile.ZipFile("bundle.zip") as z:
    for name in z.namelist():
        if name.lower().endswith(".csv"):
            with z.open(name) as f:
                rows.append(pd.read_csv(io.TextIOWrapper(f, encoding="utf-8")))
df = pd.concat(rows, ignore_index=True)

17) TSV comportant des tabulations dans les champs

import csv
df = pd.read_csv(
    "data.tsv",
    sep="\t",
    quotechar='"',
    engine="python",     # gère mieux les cas tordus
    quoting=csv.QUOTE_MINIMAL
)

18) Lignes de commentaires / méta-données (#)

df = pd.read_csv("mesures.csv", comment="#")  # ignore les lignes commençant par #

19) Espaces parasites après le séparateur

df = pd.read_csv("data.csv", sep=";", skipinitialspace=True)

20) Normaliser “oui/non”, “true/false” hétérogènes

df = pd.read_csv(
    "clients.csv",
    true_values=["OUI","Oui","YES","True","1"],
    false_values=["NON","No","False","0"]
).astype({"actif":"boolean"})

21) Détection/validation de schéma minimale à l’entrée

ATTENDU = {"id":"Int64","date":"datetime64[ns]","montant":"float64"}
df = pd.read_csv("ventes.csv", sep=";", parse_dates=["date"], dtype={"id":"Int64","montant":"float64"})

manquantes = set(ATTENDU) - set(df.columns)
if manquantes:
    raise ValueError(f"Colonnes manquantes : {sorted(manquantes)}")

assert pd.api.types.is_datetime64_any_dtype(df["date"])
assert pd.api.types.is_numeric_dtype(df["montant"])

22) Fichiers irréguliers mais exploitables (stratégie “tolérante”)

df = pd.read_csv(
    "irreg.csv",
    engine="python",
    on_bad_lines="skip",
    sep=None,           # tentative d’auto-détection
    dtype="string"      # tout en string → nettoyage en aval
)

23) Pré-lecture “FR-proof” factorisée (fonction utilitaire)

def read_csv_fr(path, *, cols=None, dtypes=None, parse_dates=None):
    import pandas as pd
    return pd.read_csv(
        path,
        sep=";",
        decimal=",",
        thousands="\u00A0",
        usecols=cols,
        dtype=dtypes,
        parse_dates=parse_dates,
        dayfirst=True,
        na_values=["", "NA", "N/A", "-", "null"]
    )

---

Rappels utiles

• skipfooter → exige engine="python".
• sep=None (auto-détection) → exige engine="python".
• Pour éviter les “colonnes mixtes” : low_memory=False ou imposez dtype.
• Codes/identifiants → lisez en string (pas en float64).
• Gros volumes → usecols, dtype, chunksize, agrégations par morceaux.

Mini-FAQ

Différence engine="c" vs "python" ?
"c" est très rapide mais strict ; "python" est plus tolérant (utile avec on_bad_lines) mais plus lent.

Int64 vs int64 ?
Int64 est nullable (accepte NA), int64 ne l’est pas. Préférez Int64 quand des manquants sont possibles.

Quand utiliser category ?
Quand la cardinalité de la colonne est faible (codes, états, pays). Gain de RAM et groupby/joins plus efficaces.

---