MENU
  1. Accueil
  2. Python
  3. Comment itérer chaque ligne d’un fichier CSV avec une boucle for en Python

Comment itérer chaque ligne d’un fichier CSV avec une boucle for en Python

Python

Apprendre à manipuler efficacement les fichiers CSV en Python est essentiel pour de nombreuses tâches telles que l’analyse de données ou la création de rapports. En particulier, l’utilisation d’une boucle for pour itérer sur chaque ligne permet de manipuler facilement les données CSV de manière intuitive. Cet article vous explique en détail comment utiliser la bibliothèque standard csv de Python, de la prise en main de base aux méthodes de traitement plus efficaces. Vous pourrez ainsi comprendre la meilleure façon de traiter de grandes quantités de données.

Sommaire

Comment ouvrir un fichier CSV en Python


La première étape pour manipuler un fichier CSV est de l’ouvrir et de charger les données correctement. En Python, on utilise la fonction open de la bibliothèque standard pour ouvrir un fichier CSV.

Méthode de base pour ouvrir un fichier


Avec la fonction open de Python, vous pouvez ouvrir un fichier CSV en mode lecture seule. Voici un exemple de code pour ouvrir le fichier example.csv :

with open('example.csv', mode='r', encoding='utf-8') as file:
    print(file.read())

Pourquoi utiliser la déclaration with


L’utilisation de la déclaration with vous permet d’ouvrir et de fermer le fichier en toute sécurité sans avoir besoin d’appeler explicitement file.close(). Cela garantit que le fichier sera correctement fermé même en cas d’erreur, ce qui permet d’éviter les fuites de ressources.

Préparation à l’utilisation du module CSV


Une fois le fichier ouvert, vous pouvez utiliser le module csv pour traiter son contenu. Ce module fournit des outils pour lire des données séparées par des virgules sous un format facile à manipuler. Nous examinerons un exemple spécifique dans les sections suivantes.

Itération basique avec csv.reader


En utilisant l’objet reader du module csv, vous pouvez itérer sur les lignes d’un fichier CSV. Cette méthode est simple et permet de récupérer chaque ligne sous forme de liste, facilitant ainsi le traitement des données.

Utilisation de base de csv.reader


Voici un exemple de code qui montre comment lire un fichier CSV en utilisant csv.reader :

import csv

# Ouvrir le fichier CSV
with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)  # Créer le lecteur CSV
    for row in reader:  # Itérer sur chaque ligne
        print(row)  # Afficher la liste de chaque ligne

Format des données récupérées


Les éléments row renvoyés par csv.reader sont des listes où chaque cellule de la ligne est un élément sous forme de chaîne de caractères. Par exemple, si vous traitez le fichier CSV suivant :

Name,Age,City
Alice,30,New York
Bob,25,Los Angeles

L’affichage sera le suivant :

['Name', 'Age', 'City']
['Alice', '30', 'New York']
['Bob', '25', 'Los Angeles']

Comment ignorer la première ligne (en-tête)


Si vous souhaitez ignorer la ligne d’en-tête, vous pouvez utiliser la fonction next() :

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Ignorer la ligne d'en-tête
    for row in reader:
        print(row)

Points importants

  • Par défaut, csv.reader reconnaît la virgule (,) comme séparateur. Si un autre séparateur est utilisé, vous devez spécifier l’argument delimiter.
  • Si vous travaillez avec beaucoup de données, veillez à gérer l’utilisation de la mémoire pour éviter des problèmes de performance.

Dans la section suivante, nous allons examiner comment extraire les valeurs de certaines colonnes et les traiter spécifiquement.

Comment extraire et traiter les valeurs des colonnes


En utilisant csv.reader, vous pouvez récupérer chaque ligne sous forme de liste, ce qui permet d’extraire facilement les valeurs de colonnes spécifiques et de les traiter. Cette approche permet de se concentrer efficacement sur les données nécessaires.

Exemple simple d’extraction d’une colonne spécifique


Voici un exemple de code pour extraire et traiter la deuxième colonne (par exemple : l’âge) :

import csv

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Ignorer l'en-tête
    for row in reader:
        # Extraire la valeur de la deuxième colonne (index 1)
        age = row[1]
        print(f"Age: {age}")

Si le fichier CSV ressemble à ceci :

Name,Age,City
Alice,30,New York
Bob,25,Los Angeles

Le résultat de l’exécution sera :

Age: 30  
Age: 25

Traitement combiné de plusieurs colonnes


Si vous souhaitez utiliser plusieurs colonnes simultanément, vous pouvez spécifier les colonnes nécessaires à l’aide d’indices de liste.

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Ignorer l'en-tête
    for row in reader:
        name = row[0]  # Première colonne
        city = row[2]  # Troisième colonne
        print(f"{name} lives in {city}.")

Le résultat de l’exécution sera :

Alice lives in New York.  
Bob lives in Los Angeles.

Ajouter un traitement d’erreurs


Pour anticiper les erreurs dues à des fichiers corrompus ou à des cellules vides, vous pouvez ajouter un traitement des erreurs pour rendre votre code plus robuste.

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Ignorer l'en-tête
    for row in reader:
        try:
            name = row[0]
            age = int(row[1])  # Convertir l'âge en entier
            print(f"{name} is {age} years old.")
        except (IndexError, ValueError) as e:
            print(f"Error processing row: {row}, Error: {e}")

Exemples avancés

  • Extraire des données qui répondent à des critères spécifiques (par exemple, âge supérieur à 30 ans).
  • Calculer des valeurs à partir des colonnes pour générer de nouvelles informations.
  • Calculer des statistiques pour chaque colonne (total, moyenne, etc.).

Dans la section suivante, nous expliquerons comment manipuler les données sous forme de dictionnaire avec csv.DictReader pour une approche plus intuitive.

Traitement des données ligne par ligne sous forme de dictionnaire avec csv.DictReader


En utilisant csv.DictReader, chaque ligne du fichier CSV est traitée sous forme de dictionnaire. Cela vous permet de référencer les données par les noms des colonnes, évitant ainsi de devoir mémoriser les indices des colonnes et rendant le code plus lisible.

Utilisation de base de csv.DictReader


Voici un exemple de code qui montre comment traiter les données avec csv.DictReader :

import csv

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.DictReader(file)
    for row in reader:
        # Obtenir les valeurs par les noms des colonnes
        name = row['Name']
        age = row['Age']
        city = row['City']
        print(f"{name} is {age} years old and lives in {city}.")

Si le fichier CSV est structuré ainsi :

Name,Age,City
Alice,30,New York
Bob,25,Los Angeles

Le résultat de l’exécution sera :

Alice is 30 years old and lives in New York.  
Bob is 25 years old and lives in Los Angeles.

Avantages de l’utilisation des noms de colonnes

  1. Amélioration de la lisibilité du code : Il n’est plus nécessaire de mémoriser les indices des colonnes, vous pouvez directement utiliser les noms des colonnes, ce qui rend le code plus intuitif.
  2. Flexibilité : Même si l’ordre des colonnes change, tant que les noms des colonnes sont cohérents, il n’est pas nécessaire de modifier le code.

Détection automatique des noms de colonnes


Le csv.DictReader utilise automatiquement la première ligne comme en-tête. Il est également possible de spécifier des noms de colonnes personnalisés :

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.DictReader(file, fieldnames=['Name', 'Age', 'City'])  # Définir des noms de colonnes personnalisés
    next(reader)  # Passer la première ligne si nécessaire
    for row in reader:
        print(row)

Traitement des données manquantes


Lorsque des données sont manquantes dans un fichier CSV, la valeur correspondante pour la clé sera None. Il est important de vérifier et de gérer ces valeurs pour éviter les erreurs.

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.DictReader(file)
    for row in reader:
        name = row.get('Name', 'Unknown')  # Valeur par défaut
        age = row.get('Age', 'N/A')
        print(f"Name: {name}, Age: {age}")

Exemples d’application

  • Filtrage des données : Sélectionner les lignes qui correspondent à un critère spécifique.
  • Conversion en JSON : Convertir les données du dictionnaire directement en JSON.
  • Traitement statistique : Réaliser des agrégations basées sur les noms des colonnes.

La section suivante traite des considérations importantes concernant l’encodage des fichiers CSV.

Considérations sur l’encodage des fichiers CSV


Lors du traitement des fichiers CSV en Python, l’encodage est un élément crucial. Si l’encodage n’est pas correctement spécifié, il peut y avoir des problèmes de corruption de texte ou d’échec de lecture du fichier. Dans cette section, nous discuterons des types d’encodage courants et de la façon de les gérer correctement.

Types d’encodage fréquemment utilisés


Voici les formats d’encodage couramment utilisés pour les fichiers CSV :

  • UTF-8 : Utilisé internationalement et compatible avec plusieurs langues. C’est l’encodage standard en Python.
  • Shift_JIS : Utilisé couramment au Japon, mais peut poser des problèmes avec certains caractères spéciaux.
  • ISO-8859-1 : Utilisé pour les langues d’Europe occidentale.

Comment spécifier l’encodage


Lors de l’utilisation de la fonction open en Python, vous pouvez spécifier l’encodage avec l’argument encoding.

with open('example.csv', mode='r', encoding='utf-8') as file:
    print(file.read())

Si le fichier est encodé en Shift_JIS, vous pouvez spécifier l’encodage comme suit :

with open('example.csv', mode='r', encoding='shift_jis') as file:
    print(file.read())

Gestion des erreurs d’encodage


Si une erreur d’encodage se produit, vous pouvez utiliser l’argument errors pour contrôler le comportement du programme en cas d’erreur.

Ignorer ou remplacer les erreurs


En spécifiant errors dans la fonction open, vous pouvez ignorer ou remplacer les caractères incorrects lors de la lecture du fichier.

with open('example.csv', mode='r', encoding='utf-8', errors='ignore') as file:
    print(file.read())  # Ignorer les erreurs

with open('example.csv', mode='r', encoding='utf-8', errors='replace') as file:
    print(file.read())  # Remplacer les caractères invalides

Détection automatique de l’encodage


Si l’encodage du fichier est inconnu, des bibliothèques comme chardet ou charset-normalizer peuvent être utilisées pour détecter l’encodage.

import chardet

# Détecter l'encodage
with open('example.csv', mode='rb') as file:
    result = chardet.detect(file.read())
    print(result['encoding'])

Conseils pour une gestion efficace de l’encodage

  1. Vérification préalable : Vérifiez l’encodage du fichier CSV et spécifiez le format approprié.
  2. Standardisation : Utilisez UTF-8 autant que possible pour garantir une compatibilité optimale.
  3. Gestion des erreurs : Utilisez les arguments errors ou des bibliothèques pour anticiper les erreurs imprévues.

Dans la section suivante, nous discuterons des méthodes efficaces pour traiter de grands fichiers CSV.

Comment traiter efficacement de grands fichiers CSV


Lorsque vous travaillez avec de très gros fichiers CSV, il est important d’adopter des méthodes efficaces pour éviter des problèmes de mémoire ou une lenteur excessive. Python propose plusieurs techniques pour traiter ces fichiers volumineux.

Économie de mémoire en lisant ligne par ligne


Avec csv.reader ou csv.DictReader, vous pouvez lire les fichiers CSV ligne par ligne. Cela permet de traiter le fichier sans charger l’ensemble du contenu en mémoire, minimisant ainsi l’empreinte mémoire.

import csv

with open('large_file.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    for row in reader:
        # Traiter chaque ligne
        print(row)

Cette méthode fonctionne indépendamment de la taille du fichier, car elle lit les lignes une à une.

Utilisation du traitement par lots


Pour améliorer l’efficacité, vous pouvez diviser un grand fichier CSV et traiter un certain nombre de lignes à la fois. Voici un exemple en utilisant itertools.islice :

import csv
from itertools import islice

with open('large_file.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    while True:
        batch = list(islice(reader, 100))  # Lire 100 lignes à la fois
        if not batch:
            break
        # Effectuer le traitement par lots
        for row in batch:
            print(row)

Traitement par morceaux avec Pandas


La bibliothèque Python pandas est idéale pour traiter de grands ensembles de données. Vous pouvez utiliser l’argument chunk_size pour effectuer un traitement par morceaux.

import pandas as pd

for chunk in pd.read_csv('large_file.csv', chunksize=1000, encoding='utf-8'):
    # Traiter chaque morceau
    print(chunk)

Cette méthode est utile lorsque vous souhaitez analyser de grandes quantités de données de manière plus efficace.

Exploitation du traitement parallèle


En divisant le fichier et en traitant les morceaux en parallèle, vous pouvez améliorer considérablement la vitesse de traitement. Voici un exemple en utilisant le module multiprocessing :

import csv
from multiprocessing import Pool

def process_chunk(chunk):
    for row in chunk:
        print(row)

def split_file(filename, chunk_size=1000):
    with open(filename, mode='r', encoding='utf-8') as file:
        reader = csv.reader(file)
        batch = []
        for i, row in enumerate(reader):
            batch.append(row)
            if (i + 1) % chunk_size == 0:
                yield batch
                batch = []
        if batch:
            yield batch

if __name__ == "__main__":
    filename = 'large_file.csv'
    with Pool(4) as pool:  # Traitement parallèle avec 4 processus
        pool.map(process_chunk, split_file(filename))

Choisir un format de données efficace


Bien que le format CSV soit simple et pratique, si les données sont très volumineuses, il peut être judicieux d’explorer d’autres formats (comme Parquet ou Feather), qui peuvent offrir de meilleures performances en termes de vitesse de lecture et de compression.

Exemple pratique : Filtrer et sauvegarder les données


Voici un exemple de filtrage des données d’un grand fichier CSV en fonction de critères spécifiques, puis de sauvegarde dans un fichier séparé :

import csv

with open('large_file.csv', mode='r', encoding='utf-8') as infile, \
     open('filtered_file.csv', mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        if int(row[1]) > 50:  # Condition : Valeur de la 2e colonne supérieure à 50
            writer.writerow(row)

Nous allons maintenant explorer l’utilisation sécurisée des fichiers avec la déclaration with.

Manipulation sécurisée des fichiers avec la déclaration with


En utilisant la déclaration with, vous pouvez facilement gérer l’ouverture et la fermeture des fichiers sans avoir à vous soucier des erreurs ou des fuites de ressources. Cela simplifie la gestion des fichiers, notamment pour les fichiers CSV.

Exemple de base avec la déclaration with


Voici un exemple de code de base utilisant la déclaration with pour lire un fichier CSV :

import csv

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

Lorsque vous quittez le bloc de la déclaration with, l’objet file est automatiquement fermé. Il n’est pas nécessaire d’appeler explicitement la méthode close(), ce qui simplifie le code.

Exemple de manipulation sécurisée de fichiers lors de l’écriture


Voici un exemple de sécurité lors de l’écriture dans un fichier CSV en utilisant with :

import csv

data = [
    ['Name', 'Age', 'City'],
    ['Alice', '30', 'New York'],
    ['Bob', '25', 'Los Angeles']
]

with open('output.csv', mode='w', encoding='utf-8', newline='') as file:
    writer = csv.writer(file)
    writer.writerows(data)

Avantages de la déclaration with

  1. Simplification de la gestion des ressources
    La déclaration with garantit que les fichiers sont automatiquement fermés, même en cas d’erreur.
  2. Amélioration de la lisibilité du code
    Il n’est pas nécessaire d’inclure des appels explicites à close(), ce qui rend le code plus simple et plus facile à comprendre.
  3. Prévention des erreurs
    L’utilisation de with empêche les fuites de ressources, comme l’oubli de fermer un fichier.

Manipulation sécurisée de plusieurs fichiers simultanément


Il est également possible d’ouvrir et de manipuler plusieurs fichiers simultanément en utilisant la déclaration with :

import csv

with open('input.csv', mode='r', encoding='utf-8') as infile, \
     open('output.csv', mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        writer.writerow(row)

Risque en l’absence de la déclaration with


Voici un exemple où la déclaration with est omise :

file = open('example.csv', mode='r', encoding='utf-8')
reader = csv.reader(file)
for row in reader:
    print(row)
file.close()

Dans cet exemple, si l’appel à close() est oublié ou si une erreur se produit, le fichier ne sera pas correctement fermé, ce qui pourrait entraîner des fuites de ressources. Ce problème peut être critique dans des environnements de production ou pour des applications à grande échelle.

Exemple pratique : Filtrage et sauvegarde des données


Dans l’exemple suivant, nous filtrons les données d’un fichier CSV pour ne conserver que celles qui correspondent à un critère particulier, puis nous les enregistrons dans un nouveau fichier :

import csv

with open('input.csv', mode='r', encoding='utf-8') as infile, \
     open('filtered_output.csv', mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        if row[1] == '30':  # Condition : La 2e colonne doit être égale à '30'
            writer.writerow(row)

Dans cette section, nous allons explorer comment extraire des colonnes spécifiques d’un fichier CSV et les enregistrer dans un nouveau fichier.

Exemple pratique : Extraction et sauvegarde de colonnes spécifiques d’un fichier CSV


Il est fréquent de devoir extraire certaines colonnes d’un fichier CSV et les enregistrer dans un nouveau fichier. Voici comment procéder de manière simple et efficace avec le module csv de Python.

Exemple de base pour extraire et sauvegarder des colonnes spécifiques


Voici un exemple de code qui extrait les colonnes spécifiques (par exemple, nom et âge) et les sauvegarde dans un nouveau fichier :

import csv

# Chemins des fichiers d'entrée et de sortie
input_file = 'input.csv'
output_file = 'output.csv'

with open(input_file, mode='r', encoding='utf-8') as infile, \
     open(output_file, mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)

    # Traitement de l'en-tête (extraction de colonnes spécifiques)
    header = next(reader)
    selected_columns = [0, 1]  # Colonnes à extraire (ex: 1ère et 2e colonnes)
    writer.writerow([header[i] for i in selected_columns])

    # Extraire et écrire les colonnes spécifiques pour chaque ligne
    for row in reader:
        writer.writerow([row[i] for i in selected_columns])

Exemple : Contenu du fichier d’entrée


Voici un exemple du fichier d’entrée input.csv :

Name,Age,City,Country
Alice,30,New York,USA
Bob,25,Los Angeles,USA
Charlie,35,London,UK

Après exécution du code, le fichier de sortie output.csv contiendra :

Name,Age
Alice,30
Bob,25
Charlie,35

Extraction dynamique des colonnes


Vous pouvez également spécifier dynamiquement les colonnes à extraire en utilisant les noms des colonnes. Cela permet d’éviter de dépendre des indices.

with open(input_file, mode='r', encoding='utf-8') as infile, \
     open(output_file, mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.DictReader(infile)
    writer = csv.writer(outfile)

    # Colonnes à extraire
    columns_to_extract = ['Name', 'City']
    writer.writerow(columns_to_extract)

    # Extraire et écrire les colonnes spécifiées
    for row in reader:
        writer.writerow([row[col] for col in columns_to_extract])

Extraction conditionnelle des colonnes


Vous pouvez également extraire uniquement les données qui satisfont à des conditions spécifiques :

with open(input_file, mode='r', encoding='utf-8') as infile, \
     open(output_file, mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.DictReader(infile)
    writer = csv.DictWriter(outfile, fieldnames=['Name', 'City'])
    writer.writeheader()

    for row in reader:
        if int(row['Age']) > 30:  # Extraction de données où l'âge est supérieur à 30
            writer.writerow({'Name': row['Name'], 'City': row['City']})

Le fichier de sortie contiendra :

Name,City
Charlie,London

Exemples d’application

  • Analyse de données : Extraire des données spécifiques pour les préparer à des calculs ou analyses.
  • Transformation des données : Extraire des données nécessaires et les convertir dans un autre format.
  • Création de rapports efficaces : Extraire des informations importantes de grands ensembles de données pour créer des rapports simples.

La section suivante résume les points clés abordés dans cet article.

Résumé


Dans cet article, nous avons exploré comment traiter efficacement les fichiers CSV avec Python. Nous avons couvert l’itération de base avec csv.reader, l’utilisation de csv.DictReader pour manipuler les données sous forme de dictionnaire, l’extraction de colonnes spécifiques, et les méthodes de traitement de gros fichiers. Nous avons également discuté de la gestion de l’encodage et de l’utilisation de la déclaration with pour une gestion sécurisée des fichiers.

Avec ces compétences, vous pourrez améliorer vos processus d’analyse de données, d’ETL (Extraction, Transformation, Load), et bien plus encore. Profitez de la flexibilité de Python pour traiter vos données CSV de manière efficace.

Python
Gestion des fichiers Optimisation de Mémoire Analyse de données Traitement Efficace Python Encodage Fichiers CSV Extraction de Données manipulation de données Grandes Données Module csv Format dictionnaire Bibliothèque Standard
Sommaire