Écrire des fichiers et CSV

Les quatre portes

Lire était une porte à sens unique : "r" laisse entrer les données. Écrire exige le vocabulaire de l’intention, car chaque mode promet quelque chose de différent sur le sort du fichier :

open("file.txt", "r")   # lecture (par défaut)
open("file.txt", "w")   # écriture (écrase !)
open("file.txt", "a")   # ajout (ajoute à la fin)
open("file.txt", "x")   # création (erreur si le fichier existe)

"w" jette l’ancien contenu à l’instant où il ouvre ; "a" le garde et raccroche à la fin ; "x" refuse de toucher un fichier qui existe déjà. Choisissez le mode qui énonce ce que vous voulez vraiment, le fichier est détruit ou préservé selon ce choix.

Écrire des fichiers texte

# Le mode "w" crée ou écrase
with open("output.txt", "w") as f:
    f.write("Hello, World!\n")
    f.write("Second line\n")

# writelines pour plusieurs chaînes
lines = ["line 1\n", "line 2\n", "line 3\n"]
with open("output.txt", "w") as f:
    f.writelines(lines)

write livre une chaîne à la fois ; writelines livre toute une liste en un appel. Les deux respectent le même contrat with que vous connaissez déjà, quand le bloc se termine, le fichier est vidé et fermé. Remarquez le \n qui se glisse dans chaque chaîne écrite, le saut de ligne n’est pas ajouté pour vous, seulement stocké.

Ajouter

Les journaux grandissent et ne réécrivent jamais l’histoire. "a" gare le curseur à la fin :

with open("log.txt", "a") as f:
    f.write("New entry\n")  # ajoute à la fin, n'écrase pas

Le mode ajout fait du fichier un accumulateur : chaque exécution ajoute une ligne, et tout ce qui a été écrit avant survit intact.

Travailler avec CSV

Un CSV est une table sur un fil : lignes séparées par des sauts de ligne, cellules séparées par des virgules. Le module csv possède les parties délicates, guillemets, échappement des délimiteurs, fins de ligne :

import csv

# Écrire un CSV
with open("data.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["Name", "Score"])
    writer.writerow(["Alice", 85])
    writer.writerow(["Bob", 92])

# Lire un CSV
with open("data.csv") as f:
    reader = csv.reader(f)
    header = next(reader)  # ['Name', 'Score']
    for row in reader:
        print(f"{row[0]}: {row[1]}")

L’écrivain accepte une liste par ligne et insère les virgules ; le lecteur reparse chaque ligne en une liste. next(reader) enlève la ligne d’en-tête, et l’itération continue avec les données, la même marche que vous connaissez, sur un fichier dont les lignes sont des structures.

DictReader et DictWriter

Les listes conviennent, mais des champs nommés vous épargnent de demander ce que voulait dire row[0]. Les dicts nomment les colonnes une fois, à l’en-tête :

import csv

# DictReader — les lignes deviennent des dicts aux clés de l'en-tête
with open("data.csv") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"{row['Name']}: {row['Score']}")

# DictWriter — écrire depuis des dicts
with open("output.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["Name", "Score"])
    writer.writeheader()
    writer.writerow({"Name": "Charlie", "Score": 88})

DictReader lit l’en-tête et transforme chaque ligne suivante en un dict indexé par elle ; DictWriter fait l’inverse, déclarez les fieldnames, écrivez l’en-tête, puis nourrissez-le de dicts dont les valeurs atterrissent sous leurs colonnes nommées.

Pathlib pour écrire

Le chemin orienté objet travaille maintenant dans les deux sens :

from pathlib import Path

Path("output.txt").write_text("Hello!\n")
content = Path("output.txt").read_text()

# Créer des répertoires
Path("data/logs").mkdir(parents=True, exist_ok=True)

write_text compresse ouvrir-écrire-fermer en un seul appel, et mkdir avec parents=True fait pousser des arbres de dossiers entiers en une commande plutôt qu’un niveau à la fois.

Un exemple travaillé : le carnet de notes, versé en CSV

La correspondance va au disque comme un tableau, l’en-tête d’abord, puis une ligne par entrée :

import csv

scores = {"Alice": 85, "Bob": 92, "Charlie": 78}

with open("grades.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["Name", "Score"])
    for name, score in scores.items():
        writer.writerow([name, score])

Les items() du dict deviennent les lignes ; l’en-tête nomme les colonnes. newline="" épingle les fins de ligne, et le bloc with vide et ferme le fichier une fois terminé.

Pièges courants

• "w" écrase en silence. L’ancien fichier est parti à l’instant où le mode ouvre. Si le passé compte, choisissez "a".
• Oublier newline="" en CSV. Sur Windows l’écrivain double les fins de ligne sauf si vous épinglez newline="" ; des lignes vides apparaissent entre les données.
• Sauter writeheader(). Un DictWriter nourri de dicts n’écrit aucune ligne d’en-tête si vous ne l’appelez pas, les lecteurs perdent leurs clés.
• writerow prend une séquence, et une chaîne est une séquence de caractères. writer.writerow("Alice") éparpille A,l,i,c,e dans cinq cellules. Enveloppez la valeur dans une liste quand le champ est une seule chaîne.