- À propos de la lecture et de l'écriture d'un fichier CSV avec des dictionnaires
- Comprendre csv.DictReader() et csv.DictWriter()
- Préparer un fichier CSV avec une ligne d'en-tête
- Lire un fichier CSV avec csv.DictReader()
- Accéder aux colonnes CSV par leur nom
- Filtrer et traiter les données lues avec DictReader()
- Écrire un fichier CSV avec csv.DictWriter()
- Écrire plusieurs dictionnaires avec writerows()
- Lire, modifier puis réécrire un fichier CSV
- Ajouter une nouvelle ligne à un fichier CSV
- Utiliser un séparateur personnalisé avec DictReader() et DictWriter()
- Gérer les types numériques et les données manquantes
- Créer un programme complet de lecture et d'écriture CSV
- À retenir !
1. À propos de la lecture et de l'écriture d'un fichier CSV avec des dictionnaires
Le module csv de Python permet de manipuler facilement des fichiers CSV. Lorsque le fichier possède une ligne d'en-tête, les classes csv.DictReader() et csv.DictWriter() sont particulièrement pratiques, car elles permettent de travailler avec des dictionnaires Python plutôt qu'avec de simples listes.
csv.DictReader() est utilisé pour la lecture : chaque ligne du fichier est transformée en dictionnaire dont les clés correspondent aux noms des colonnes. csv.DictWriter() réalise l'opération complémentaire : il permet d'écrire des dictionnaires dans un fichier CSV.
Le programme suivant vérifie que ces deux classes sont disponibles dans le module csv.
1 2 3 4 | import csv print(csv.DictReader) print(csv.DictWriter) |
Sortie possible :
1 2 | <class 'csv.DictReader'> <class 'csv.DictWriter'> |
L'association de ces deux classes permet donc de mettre en place un cycle complet : lire des données CSV, les traiter avec Python puis les réécrire dans un fichier CSV.
2. Comprendre csv.DictReader() et csv.DictWriter()
csv.DictReader() lit chaque ligne et l'associe aux noms des colonnes. Si le fichier contient les colonnes nom, age, ville et note, une ligne peut être représentée en Python par le dictionnaire suivant.
1 2 3 4 5 6 7 8 9 | etudiant = { "nom": "Amine", "age": "21", "ville": "Oujda", "note": "15.5" } print(etudiant["nom"]) print(etudiant["ville"]) |
Sortie :
1 2 | Amine Oujda |
À l'inverse, csv.DictWriter() reçoit des dictionnaires et utilise leurs clés pour placer les valeurs dans les colonnes correspondantes.
Nous pouvons représenter plusieurs lignes CSV par une liste de dictionnaires.
1 2 3 4 5 6 7 8 | etudiants = [ {"nom": "Amine", "age": 21, "ville": "Oujda", "note": 15.5}, {"nom": "Sara", "age": 20, "ville": "Rabat", "note": 17}, {"nom": "Yassine", "age": 22, "ville": "Fès", "note": 13.5} ] print(etudiants[1]["nom"]) print(etudiants[1]["note"]) |
Sortie :
1 2 | Sara 17 |
Cette représentation est très pratique, car les noms des champs restent explicites dans le programme.
3. Préparer un fichier CSV avec une ligne d'en-tête
Considérons un fichier nommé etudiants.csv. Sa première ligne contient les noms des colonnes et les lignes suivantes contiennent les données.
1 2 3 4 5 | nom,age,ville,note Amine,21,Oujda,15.5 Sara,20,Rabat,17 Yassine,22,Fès,13.5 Lina,19,Casablanca,18 |
Sortie :
1 | Le fichier contient quatre colonnes et quatre lignes de données. |
Nous pouvons afficher son contenu avec Python avant de commencer son traitement.
1 2 | with open("etudiants.csv", "r", encoding="utf-8") as fichier: print(fichier.read()) |
Sortie :
1 2 3 4 5 | nom,age,ville,note Amine,21,Oujda,15.5 Sara,20,Rabat,17 Yassine,22,Fès,13.5 Lina,19,Casablanca,18 |
La première ligne est particulièrement importante pour DictReader(), car elle sera utilisée pour déterminer automatiquement les clés des dictionnaires.
4. Lire un fichier CSV avec csv.DictReader()
Pour lire le fichier, nous l'ouvrons avec open() puis nous transmettons l'objet fichier à csv.DictReader(). Chaque itération retourne alors un dictionnaire.
1 2 3 4 5 6 7 | import csv with open("etudiants.csv", "r", encoding="utf-8", newline="") as fichier: lecteur = csv.DictReader(fichier) for etudiant in lecteur: print(etudiant) |
Sortie :
1 2 3 4 | {'nom': 'Amine', 'age': '21', 'ville': 'Oujda', 'note': '15.5'} {'nom': 'Sara', 'age': '20', 'ville': 'Rabat', 'note': '17'} {'nom': 'Yassine', 'age': '22', 'ville': 'Fès', 'note': '13.5'} {'nom': 'Lina', 'age': '19', 'ville': 'Casablanca', 'note': '18'} |
La ligne d'en-tête n'est pas retournée comme une ligne ordinaire. Elle sert à construire les clés nom, age, ville et note.
L'attribut fieldnames permet de récupérer ces noms de colonnes.
1 2 3 4 5 | import csv with open("etudiants.csv", "r", encoding="utf-8", newline="") as fichier: lecteur = csv.DictReader(fichier) print(lecteur.fieldnames) |
Sortie :
1 | ['nom', 'age', 'ville', 'note'] |
5. Accéder aux colonnes CSV par leur nom
L'un des principaux avantages de DictReader() est de pouvoir utiliser directement le nom d'une colonne. Nous écrivons par exemple etudiant["nom"] plutôt qu'un indice comme ligne[0].
1 2 3 4 5 6 7 8 9 10 11 12 13 | import csv with open("etudiants.csv", "r", encoding="utf-8", newline="") as fichier: lecteur = csv.DictReader(fichier) for etudiant in lecteur: print( etudiant["nom"], "-", etudiant["ville"], "-", etudiant["note"] ) |
Sortie :
1 2 3 4 | Amine - Oujda - 15.5 Sara - Rabat - 17 Yassine - Fès - 13.5 Lina - Casablanca - 18 |
Chaque ligne étant un dictionnaire, nous pouvons également parcourir les clés et les valeurs avec items().
1 2 3 4 5 6 7 8 | import csv with open("etudiants.csv", "r", encoding="utf-8", newline="") as fichier: lecteur = csv.DictReader(fichier) etudiant = next(lecteur) for cle, valeur in etudiant.items(): print(cle, ":", valeur) |
Sortie :
1 2 3 4 | nom : Amine age : 21 ville : Oujda note : 15.5 |
6. Filtrer et traiter les données lues avec DictReader()
Une fois les lignes transformées en dictionnaires, nous pouvons facilement appliquer des conditions. Dans l'exemple suivant, nous sélectionnons uniquement les étudiants ayant une note supérieure ou égale à 15.
1 2 3 4 5 6 7 8 | import csv with open("etudiants.csv", "r", encoding="utf-8", newline="") as fichier: lecteur = csv.DictReader(fichier) for etudiant in lecteur: if float(etudiant["note"]) >= 15: print(etudiant["nom"], ":", etudiant["note"]) |
Sortie :
1 2 3 | Amine : 15.5 Sara : 17 Lina : 18 |
Nous pouvons également conserver les lignes sélectionnées dans une nouvelle liste de dictionnaires. Cette liste pourra ensuite être écrite dans un autre fichier CSV avec DictWriter().
1 2 3 4 5 6 7 8 9 10 11 12 | import csv admis = [] with open("etudiants.csv", "r", encoding="utf-8", newline="") as fichier: lecteur = csv.DictReader(fichier) for etudiant in lecteur: if float(etudiant["note"]) >= 15: admis.append(etudiant) print("Nombre d'étudiants sélectionnés :", len(admis)) |
Sortie :
1 | Nombre d'étudiants sélectionnés : 3 |
7. Écrire un fichier CSV avec csv.DictWriter()
Pour écrire des dictionnaires dans un fichier CSV, nous utilisons csv.DictWriter(). Il faut notamment lui indiquer les noms et l'ordre des colonnes avec le paramètre fieldnames.
La méthode writeheader() écrit la ligne d'en-tête et writerow() écrit un dictionnaire sous forme d'une ligne CSV.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | import csv colonnes = ["nom", "age", "ville", "note"] etudiant = { "nom": "Nadia", "age": 23, "ville": "Marrakech", "note": 16 } with open("nouveau.csv", "w", encoding="utf-8", newline="") as fichier: writer = csv.DictWriter(fichier, fieldnames=colonnes) writer.writeheader() writer.writerow(etudiant) print("Fichier créé.") |
Sortie :
1 | Fichier créé. |
Le fichier nouveau.csv contient alors les données suivantes.
1 2 | nom,age,ville,note Nadia,23,Marrakech,16 |
Sortie :
1 | Une ligne d'en-tête et une ligne de données ont été écrites. |
8. Écrire plusieurs dictionnaires avec writerows()
Lorsque les données sont stockées dans une liste de dictionnaires, la méthode writerows() permet d'écrire toutes les lignes en une seule opération.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | import csv colonnes = ["nom", "age", "ville", "note"] etudiants = [ {"nom": "Amine", "age": 21, "ville": "Oujda", "note": 15.5}, {"nom": "Sara", "age": 20, "ville": "Rabat", "note": 17}, {"nom": "Yassine", "age": 22, "ville": "Fès", "note": 13.5}, {"nom": "Lina", "age": 19, "ville": "Casablanca", "note": 18} ] with open("etudiants2.csv", "w", encoding="utf-8", newline="") as fichier: writer = csv.DictWriter(fichier, fieldnames=colonnes) writer.writeheader() writer.writerows(etudiants) print("Nombre de lignes écrites :", len(etudiants)) |
Sortie :
1 | Nombre de lignes écrites : 4 |
Le fichier produit possède la structure suivante.
1 2 3 4 5 | nom,age,ville,note Amine,21,Oujda,15.5 Sara,20,Rabat,17 Yassine,22,Fès,13.5 Lina,19,Casablanca,18 |
Sortie :
1 | Quatre dictionnaires ont été convertis en quatre lignes CSV. |
9. Lire, modifier puis réécrire un fichier CSV
L'intérêt de combiner DictReader() et DictWriter() apparaît particulièrement lorsque nous souhaitons lire un fichier, modifier certaines valeurs puis produire un nouveau fichier.
Le programme suivant lit etudiants.csv, ajoute un point à chaque note sans dépasser 20, puis conserve les données modifiées dans une liste.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import csv etudiants = [] with open("etudiants.csv", "r", encoding="utf-8", newline="") as fichier: lecteur = csv.DictReader(fichier) for etudiant in lecteur: note = float(etudiant["note"]) etudiant["note"] = min(note + 1, 20) etudiants.append(etudiant) for etudiant in etudiants: print(etudiant) |
Sortie :
1 2 3 4 | {'nom': 'Amine', 'age': '21', 'ville': 'Oujda', 'note': 16.5} {'nom': 'Sara', 'age': '20', 'ville': 'Rabat', 'note': 18.0} {'nom': 'Yassine', 'age': '22', 'ville': 'Fès', 'note': 14.5} {'nom': 'Lina', 'age': '19', 'ville': 'Casablanca', 'note': 19.0} |
Nous pouvons maintenant utiliser DictWriter() pour enregistrer ces dictionnaires dans un nouveau fichier.
1 2 3 4 5 6 7 8 9 10 | import csv colonnes = ["nom", "age", "ville", "note"] with open("etudiants_modifies.csv", "w", encoding="utf-8", newline="") as fichier: writer = csv.DictWriter(fichier, fieldnames=colonnes) writer.writeheader() writer.writerows(etudiants) print("Fichier modifié enregistré.") |
Sortie :
1 | Fichier modifié enregistré. |
Le nouveau fichier contient les notes modifiées.
1 2 3 4 5 | nom,age,ville,note Amine,21,Oujda,16.5 Sara,20,Rabat,18.0 Yassine,22,Fès,14.5 Lina,19,Casablanca,19.0 |
Sortie :
1 | Les données ont été lues, transformées puis réécrites dans un nouveau fichier CSV. |
10. Ajouter une nouvelle ligne à un fichier CSV
Pour ajouter une ligne sans supprimer les données existantes, nous ouvrons le fichier avec le mode "a". Il ne faut généralement pas appeler writeheader() dans ce cas, puisque l'en-tête existe déjà.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | import csv colonnes = ["nom", "age", "ville", "note"] nouvel_etudiant = { "nom": "Omar", "age": 20, "ville": "Agadir", "note": 14 } with open("etudiants.csv", "a", encoding="utf-8", newline="") as fichier: writer = csv.DictWriter(fichier, fieldnames=colonnes) writer.writerow(nouvel_etudiant) print("Nouvelle ligne ajoutée.") |
Sortie :
1 | Nouvelle ligne ajoutée. |
Le nouvel étudiant est placé à la fin du fichier existant.
1 2 3 4 5 6 | nom,age,ville,note Amine,21,Oujda,15.5 Sara,20,Rabat,17 Yassine,22,Fès,13.5 Lina,19,Casablanca,18 Omar,20,Agadir,14 |
Sortie :
1 | La ligne d'Omar a été ajoutée sans supprimer les données précédentes. |
11. Utiliser un séparateur personnalisé avec DictReader() et DictWriter()
Les fichiers CSV peuvent utiliser un autre séparateur que la virgule. Le paramètre delimiter doit être utilisé de manière cohérente lors de la lecture et de l'écriture.
Le programme suivant écrit un fichier utilisant le point-virgule comme séparateur.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | import csv colonnes = ["produit", "prix", "stock"] produits = [ {"produit": "Clavier", "prix": 25.90, "stock": 12}, {"produit": "Souris", "prix": 15.50, "stock": 30}, {"produit": "Écran", "prix": 189.00, "stock": 8} ] with open("produits.csv", "w", encoding="utf-8", newline="") as fichier: writer = csv.DictWriter( fichier, fieldnames=colonnes, delimiter=";" ) writer.writeheader() writer.writerows(produits) print("Fichier créé avec le séparateur ;") |
Sortie :
1 | Fichier créé avec le séparateur ; |
Le fichier obtenu utilise des points-virgules.
1 2 3 4 | produit;prix;stock Clavier;25.9;12 Souris;15.5;30 Écran;189.0;8 |
Sortie :
1 | Les colonnes sont séparées par des points-virgules. |
Pour relire ce fichier, nous indiquons le même séparateur à DictReader().
1 2 3 4 5 6 7 | import csv with open("produits.csv", "r", encoding="utf-8", newline="") as fichier: lecteur = csv.DictReader(fichier, delimiter=";") for produit in lecteur: print(produit["produit"], "-", produit["prix"]) |
Sortie :
1 2 3 | Clavier - 25.9 Souris - 15.5 Écran - 189.0 |
12. Gérer les types numériques et les données manquantes
Les valeurs obtenues avec DictReader() sont généralement des chaînes de caractères. Avant d'effectuer un calcul, il faut donc convertir explicitement les nombres avec int() ou float().
1 2 3 4 5 6 7 8 9 10 11 | import csv with open("etudiants.csv", "r", encoding="utf-8", newline="") as fichier: lecteur = csv.DictReader(fichier) etudiant = next(lecteur) age = int(etudiant["age"]) note = float(etudiant["note"]) print(type(age)) print(type(note)) |
Sortie :
1 2 | <class 'int'> <class 'float'> |
Lorsqu'une valeur est absente à la fin d'une ligne, DictReader() peut lui associer None. Il est donc prudent de vérifier une donnée avant de la convertir.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | import csv from io import StringIO texte = """nom,age,ville,note Amine,21,Oujda,15.5 Sara,20,Rabat """ lecteur = csv.DictReader(StringIO(texte)) for etudiant in lecteur: if etudiant["note"] is None: print(etudiant["nom"], ": note manquante") else: print(etudiant["nom"], ":", float(etudiant["note"])) |
Sortie :
1 2 | Amine : 15.5 Sara : note manquante |
Lors de l'écriture, DictWriter() peut également recevoir une valeur vide afin de produire un champ CSV vide.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | import csv colonnes = ["nom", "age", "ville", "note"] etudiants = [ {"nom": "Amine", "age": 21, "ville": "Oujda", "note": 15.5}, {"nom": "Sara", "age": 20, "ville": "Rabat", "note": ""} ] with open("notes.csv", "w", encoding="utf-8", newline="") as fichier: writer = csv.DictWriter(fichier, fieldnames=colonnes) writer.writeheader() writer.writerows(etudiants) print("Fichier enregistré.") |
Sortie :
1 | Fichier enregistré. |
Le fichier contient alors un champ vide pour la note de Sara.
1 2 3 | nom,age,ville,note Amine,21,Oujda,15.5 Sara,20,Rabat, |
Sortie :
1 | La seconde ligne possède une valeur vide dans la colonne note. |
13. Créer un programme complet de lecture et d'écriture CSV
Nous pouvons maintenant réunir DictReader() et DictWriter() dans un même programme. L'objectif est de lire etudiants.csv, sélectionner les étudiants ayant une note supérieure ou égale à 15 et enregistrer ces étudiants dans admis.csv.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | import csv source = "etudiants.csv" destination = "admis.csv" with open(source, "r", encoding="utf-8", newline="") as fichier: lecteur = csv.DictReader(fichier) colonnes = lecteur.fieldnames admis = [ etudiant for etudiant in lecteur if float(etudiant["note"]) >= 15 ] with open(destination, "w", encoding="utf-8", newline="") as fichier: writer = csv.DictWriter(fichier, fieldnames=colonnes) writer.writeheader() writer.writerows(admis) print("Nombre d'étudiants exportés :", len(admis)) |
Sortie :
1 | Nombre d'étudiants exportés : 3 |
Le fichier admis.csv généré contient uniquement les étudiants satisfaisant la condition.
1 2 3 4 | nom,age,ville,note Amine,21,Oujda,15.5 Sara,20,Rabat,17 Lina,19,Casablanca,18 |
Sortie :
1 | Trois lignes ont été sélectionnées puis écrites dans admis.csv. |
Nous pouvons vérifier le résultat en relisant immédiatement le nouveau fichier avec DictReader().
1 2 3 4 5 6 7 8 9 10 11 12 13 | import csv with open("admis.csv", "r", encoding="utf-8", newline="") as fichier: lecteur = csv.DictReader(fichier) for etudiant in lecteur: print( etudiant["nom"], "-", etudiant["ville"], "-", etudiant["note"] ) |
Sortie :
1 2 3 | Amine - Oujda - 15.5 Sara - Rabat - 17 Lina - Casablanca - 18 |
Cet exemple illustre le cycle classique lecture → traitement → écriture utilisé dans de nombreux programmes de manipulation de données CSV.
14. À retenir !
Les classes csv.DictReader() et csv.DictWriter() permettent de manipuler des fichiers CSV en utilisant directement des dictionnaires Python. Elles sont particulièrement adaptées aux fichiers possédant des noms de colonnes.
- DictReader() transforme chaque ligne CSV en dictionnaire.
- La première ligne du fichier sert généralement à déterminer les noms des colonnes.
- L'attribut fieldnames contient les noms des champs.
- Les valeurs peuvent être récupérées avec des expressions comme etudiant["nom"] et etudiant["note"].
- DictWriter() effectue l'opération inverse et transforme des dictionnaires en lignes CSV.
- Le paramètre fieldnames indique les colonnes et leur ordre lors de l'écriture.
- writeheader() écrit la ligne contenant les noms des colonnes.
- writerow() écrit un dictionnaire.
- writerows() écrit plusieurs dictionnaires.
- Le mode "w" crée ou remplace un fichier, tandis que le mode "a" permet d'ajouter des lignes.
- Le paramètre delimiter permet de choisir le séparateur.
- Les nombres lus avec DictReader() doivent généralement être convertis avec int() ou float() avant les calculs.
- La combinaison DictReader() et DictWriter() permet facilement de lire, filtrer, modifier et réécrire des données CSV.
Le modèle suivant résume le passage d'un fichier CSV vers des dictionnaires Python, puis des dictionnaires vers un nouveau fichier CSV.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import csv with open("etudiants.csv", "r", encoding="utf-8", newline="") as source: lecteur = csv.DictReader(source) colonnes = lecteur.fieldnames donnees = list(lecteur) with open("copie.csv", "w", encoding="utf-8", newline="") as destination: writer = csv.DictWriter(destination, fieldnames=colonnes) writer.writeheader() writer.writerows(donnees) print("Lecture et écriture terminées.") print("Nombre de lignes :", len(donnees)) |
Sortie :
1 2 | Lecture et écriture terminées. Nombre de lignes : 4 |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
