Python

Lire des fichiers CSV avec pandas

Chargez un vrai CSV dans pandas de façon délibérée, validez sa forme et ses types, et évitez les hypothèses d’ingestion qui provoquent des problèmes de données en aval.

Par JaviPublié 11 min de lectureDébutant

Un document CSV qui alimente une grille de DataFrame structurée

Lire un CSV est facile ; savoir qu’il a été lu correctement est le véritable travail d’ingénierie. Un appel à read_csv qui réussit peut tout de même produire des dates sous forme de texte, des identifiants hétérogènes, des valeurs nulles inattendues, des enregistrements en double ou des types déduits en silence qui changeront à l’arrivée du fichier de demain.

Problème

Vous avez reçu une extraction de clients qui sera ensuite jointe aux commandes et aux événements du site Web. Avant de construire des transformations, vous avez besoin d’une étape de chargement reproductible et d’un petit ensemble de contrôles qui établissent ce qui est entré en mémoire. C’est important, car chaque filtre, jointure et agrégation hérite des décisions prises pendant l’ingestion.

Jeu de données utilisé

Ce tutoriel utilise le Customer Dataset : 100 lignes synthétiques contenant des identifiants, des pays, des dates d’inscription, des segments de clientèle et des adresses e-mail. Il comporte volontairement trois e-mails vides, une casse incohérente pour les pays et une ligne en double.

Téléchargez customers.csv et placez-le dans un répertoire data à côté de votre notebook ou de votre script. L’URL convient aussi à un court exercice, mais les pipelines de production doivent normalement télécharger ou déposer explicitement les fichiers sources pour maîtriser les nouvelles tentatives, les sommes de contrôle et la rétention.

Code : le chargement minimal utile

Python
from pathlib import Path

import pandas as pd

data_path = Path("data") / "customers.csv"
customers = pd.read_csv(data_path)

print(customers.shape)
print(customers.head(3))
Python9 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Path rend l’exemple portable entre Windows, macOS et Linux. Il évite les lettres de lecteur codées en dur et rend visible le répertoire attendu. Le chargement produit un DataFrame, une table étiquetée à deux dimensions dont les colonnes peuvent avoir des types de données différents.

Résultat

(100, 6)
   customer_id  customer_name        country signup_date         segment                       email
0            1    Avery Atlas  United States  2023-01-01      Enterprise  customer001@example.test
1            2    Blake Atlas         Canada  2023-02-08  Small Business  customer002@example.test
2            3    Casey Atlas United Kingdom  2023-03-15        Consumer  customer003@example.test

La forme (shape) est un contrôle du contrat d’ingestion, pas une preuve d’exactitude. Elle confirme 100 lignes et six colonnes, y compris le doublon volontaire. Si la source produit de façon inattendue zéro ligne, sept colonnes ou une seule colonne géante parce que le séparateur a changé, arrêtez-vous avant de la transformer.

Code : rendre explicites les types importants

pandas peut interpréter la date et conserver l’identifiant sous forme d’entier nullable. Des choix explicites limitent les surprises lorsqu’une valeur vide apparaît dans une livraison ultérieure.

Python
customers = pd.read_csv(
    data_path,
    dtype={"customer_id": "Int64", "segment": "category"},
    parse_dates=["signup_date"],
    usecols=[
        "customer_id",
        "customer_name",
        "country",
        "signup_date",
        "segment",
        "email",
    ],
)

required = {"customer_id", "customer_name", "country", "signup_date", "segment", "email"}
missing_columns = required.difference(customers.columns)
if missing_columns:
    raise ValueError(f"Missing required columns: {sorted(missing_columns)}")
Python18 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Int64 est le type entier nullable de pandas ; contrairement au type int64 de NumPy, il peut représenter des valeurs manquantes sans convertir toute la colonne en nombres à virgule flottante. category peut être efficace pour des libellés répétés et rend visible le domaine attendu. parse_dates transforme le texte ISO en colonne de type date et heure, ce qui permet des comparaisons fiables et des attributs dérivés de la date.

usecols sert aussi de frontière : la transformation ne lit que les champs qu’elle attend. Cela peut réduire la mémoire pour les fichiers très larges, mais ne doit pas remplacer la surveillance des dérives de schéma. Si une équipe en amont ajoute une colonne utile, un contrat explicite vous signale le changement au lieu de modifier par accident le comportement en aval.

Explication : chemins, URL et reproductibilité

Un chemin relatif est résolu à partir du répertoire de travail du processus, pas nécessairement du fichier de script. Dans un notebook, affichez Path.cwd() lorsqu’un fichier est introuvable. Pour les pipelines packagés, passez l’emplacement d’entrée en configuration et journalisez le chemin résolu.

Pour un exercice rapide, pandas peut lire directement l’URL publiée :

customers_url = "https://javibuilds.com/resources/datasets/customers.csv"
customers = pd.read_csv(customers_url, parse_dates=["signup_date"])

Pour la lecture en ligne, utilisez le domaine réellement déployé. Un téléchargement local est préférable pour s’exercer de façon reproductible et fonctionne hors connexion. En production, l’ingestion HTTP directe exige aussi des délais d’expiration, une authentification, des nouvelles tentatives, une zone de dépôt immuable et de l’observabilité : autant de sujets que read_csv ne règle pas à lui seul.

Erreurs fréquentes

  • Faire confiance aux types déduits sans les inspecter.
  • Coder en dur des chemins C:\... qui ne fonctionnent que sur une machine.
  • Traiter comme équivalents les chaînes vides, NA, NULL et les valeurs sentinelles propres au domaine sans règle explicite.
  • N’interpréter les dates qu’au moment où elles servent pour la première fois, ce qui disperse les erreurs de conversion en aval.
  • Supposer qu’un chargement réussi signifie que le fichier ou le séparateur attendu a été utilisé.
  • Lire toutes les colonnes d’une extraction très large alors qu’un sous-ensemble stable suffit.
  • Utiliser low_memory=False comme correctif générique au lieu de définir les types ambigus.

À vous de jouer

Chargez le fichier depuis un répertoire local data. Vérifiez le nombre de lignes et de colonnes, affichez customers.dtypes et comptez les valeurs manquantes avec customers.isna().sum(). Interprétez ensuite signup_date, trouvez la première et la dernière inscription, et vérifiez qu’il manque trois e-mails.

Enfin, comparez len(customers) et len(customers.drop_duplicates()). Ne supprimez pas encore le doublon. Notez ce que vous avez trouvé afin que la transformation suivante puisse prendre une décision de nettoyage délibérée, au lieu de modifier les données d’entrée de façon invisible. Pour poursuivre, consultez Inspecter un DataFrame pandas.

Notes de production

Traitez les métadonnées d’ingestion comme une partie du jeu de données. Enregistrez le nom de la source, l’heure d’arrivée, la taille en octets, le nombre de lignes et une somme de contrôle lorsque les fichiers doivent être auditables. Conservez les octets d’origine avant toute correction afin de pouvoir rejouer une transformation en échec sans redemander la source. Si les fichiers arrivent de manière récurrente, déterminez si un nom de fichier représente une livraison immuable ou un emplacement dont le contenu peut changer.

Les hypothèses d’encodage et de séparateur font aussi partie du contrat. UTF-8 est un bon choix par défaut, mais les systèmes sources peuvent produire des marques d’ordre d’octets (BOM) ou des encodages hérités. Échouez avec un message utile plutôt que de remplacer silencieusement les caractères inconnus. Pour les flux récurrents, testez l’en-tête avant de charger le fichier complet et isolez les lignes rejetées lorsque la politique autorise une acceptation partielle.

Enfin, n’oubliez pas que pandas s’exécute dans un seul processus Python. Estimez la mémoire occupée par les données une fois chargées, pas seulement la taille du fichier compressé, et surveillez le processus lors de chargements représentatifs. Une lecture réussie à l’échelle d’un tutoriel ne prouve pas qu’une livraison de plusieurs gigaoctets est sûre en production.

Étiquettes

  • Python
  • pandas
  • DataFrames
  • CSV
  • Jeu de données