Programmation · Prog 12 · Garder des traces

Fichiers

Ce que ton programme doit garder quand il s’arrête, et comment le relire.

Déjà à l'aise ? Aller directement au quiz

Dans la vraie vie

Tu joues depuis une heure, tu viens d’atteindre le niveau 7. Et là, coupure de courant.

Niveau 7 coupure de courant sans sauvegarderetour au niveau 1 avec sauvegardereprise au niveau 7 sauvegarde.txt

Sans sauvegarde, tout est à refaire. Avec, tu reprends au niveau 7.

Un programme, c’est pareil.

Quand il s’arrête, ses variables disparaissent. Pour retrouver un score, des notes ou des réglages la fois suivante, il faut les écrire dans un fichier, puis les relire.

Ouvrir, lire ou écrire, fermer : trois gestes.

Et quelques pièges à connaître, pour ne rien perdre en route.

Garder des traces.

Au programme

  • 01pourquoi un fichier survit
  • 02lire ligne par ligne
  • 03les modes r, w, a et x
  • 04le tampon, et pourquoi fermer
  • 05trouver le fichier : les chemins
  • 06des données rangées en JSON
Question pour toi : ton programme fait f.write("Léa;5.5") et s’arrête net juste après. La ligne est-elle dans le fichier ?

Oui, on vient de l’écrire !

Pas si sûr. Réponse au chapitre 4, avec un serveur de restaurant.

Ce qui reste quand tout s’éteint

Dans la vraie vie

En classe, ce qui est écrit au tableau est effacé à la fin du cours.

Pythagore a² + b² = c² 3² + 4² = 5² effacé à la fin du cours a² + b² = c² 3² + 4² = 5² gardé dans le classeur

Ce que tu as rangé dans ton classeur, tu le retrouves l’an prochain.

Mémoire vive et disque

Les variables vivent dans la mémoire vive (la RAM) : rapide, mais vidée à la fin du programme. Un fichier est rangé sur le disque (SSD, disque dur, clé USB) : il reste, même ordinateur éteint.

mémoire vive (RAM) 42"Léa" 5.5True disque (SSD) score.txt 42 programme arrêté la RAM se vide, le disque garde

Où l’image s’arrête : le tableau, c’est toi qui l’effaces.

La mémoire vive, elle, se vide toute seule dès que le programme s’arrête. Rien n’y survit.

Le meilleur score, d’une partie à l’autre

Un jeu écrit son meilleur score dans score.txt, s’arrête, puis le relit au lancement suivant.

Le meilleur scoreen cours

Pendant la partie, le meilleur score vit dans une variable, en mémoire vive.

Le même programme, en Python

Écrire le score à la fin d’une partie, le relire au lancement suivant.

Pythonscore.py
meilleur = 42
with open("score.txt", "w",
          encoding="utf-8") as f:
    f.write(str(meilleur))  # du texte

# ... au lancement suivant :
with open("score.txt",
          encoding="utf-8") as f:
    meilleur = int(f.read())  # "42" → 42

Un fichier texte ne contient que du texte

write attend une chaîne : on écrit str(meilleur), et l’on reconvertit à la lecture avec int ou float.

score.txt 42 42 str "42" write read "42" int 42 dans le fichier, seulement du texte

Sinon, f.write(42) lève :

TypeError: write() argument must be str, not int

Une ligne à la fois

Dans la vraie vie

Au magasin, tu suis ta liste de courses ligne par ligne, et tu coches à mesure.

Courses pain lait pommes fromage fin de la liste une ligne à la fois

Une fois en bas, il ne reste rien à lire. Pour tout relire, tu repars du haut.

Le curseur de lecture

Un fichier ouvert a un curseur : la position de la prochaine lecture. f.read() lit tout d’un coup ; la boucle for lit une ligne par tour, la façon la plus simple et la plus économe.

f.read() for ligne in f tout d’un coup beaucoup de mémoire ligne 1 ligne 2 ligne 3 ligne 4 une ligne par tour presque rien en mémoire

open et l’encodage

open renvoie un objet fichier ; with le referme à la fin du bloc. Précise toujours encoding="utf-8" : sinon, l’encodage dépend du système, et les accents arrivent déformés ailleurs1.

Léa 4C C3 A9 61 octets lu en UTF-8 lu en cp1252 Léa Léa

notes.csv, ligne par ligne

Le programme reste à l’écran ; à chaque étape, ses lignes s’allument et le curseur de lecture avance dans le fichier.

moyenne.pyPython
total, n = 0, 0with open("notes.csv",          encoding="utf-8") as f:    for ligne in f:        nom, note = ligne.split(";")        total += float(note)        n += 1print(f"moyenne : {total / n}")

with open(…) ouvre notes.csv. Le curseur de lecture est au tout début du fichier.

Premier tour : ligne vaut 'Léa;5.5\n', saut de ligne compris. split(";") la coupe ; float ignore le \n final.

Deuxième tour : le curseur a avancé d’une ligne. total vaut 10.0, n vaut 2.

Troisième tour : Mia, 5. total vaut 15.0. Le curseur arrive à la fin du fichier.

Plus rien à lire : la boucle s’arrête. En sortant du bloc with, le fichier est fermé.

print affiche la moyenne : 15.0 divisé par 3, soit 5.0.

Le \n en fin de ligne surprend tout le monde.

Pourquoi print(ligne) saute-t-il une ligne de plus ?

Parce que print ajoute son propre saut de ligne. ligne.strip() enlève celui du fichier.

Lire, en cinq langages

Tout d’un coup, la liste des lignes, ou une ligne par tour : Python, Java, JavaScript, Go et R.

Pythontrois façons de lire
with open("notes.csv",
          encoding="utf-8") as f:
    texte = f.read()         # tout

with open("notes.csv",
          encoding="utf-8") as f:
    premiere = f.readline()  # 'Léa;5.5\n'
    reste = f.readlines()    # les autres

with open("notes.csv",
          encoding="utf-8") as f:
    for ligne in f:          # une par tour
        print(ligne.strip())
Javajava.nio.file
Path chemin = Path.of("notes.csv");
// tout le fichier, lu en UTF-8
String texte = Files.readString(chemin);
// la liste des lignes, sans les \n
List<String> lignes = Files.readAllLines(chemin);
try (BufferedReader r = Files.newBufferedReader(chemin)) {
    String ligne;
    // null à la fin du fichier
    while ((ligne = r.readLine()) != null) {
        System.out.println(ligne);
    }
}
JavaScript (Node)lire.mjs
import { readFile } from "node:fs/promises";

const texte = await readFile("notes.csv", "utf8");
for (const ligne of texte.trim().split("\n")) {
    const [nom, note] = ligne.split(";");
    console.log(nom, Number(note));
}
Golire.go
f, err := os.Open("notes.csv")
if err != nil {
    log.Fatal(err)
}
defer f.Close()
scanner := bufio.NewScanner(f)
// Text() : la ligne, sans le \n
for scanner.Scan() {
    fmt.Println(scanner.Text())
}
Rlire.R
lignes <- readLines("notes.csv", encoding = "UTF-8")
notes <- read.csv("notes.csv", sep = ";", header = FALSE,
                  col.names = c("nom", "note"))
mean(notes$note)   # 5

Piège : read, puis readlines

f.read() amène le curseur à la fin du fichier. Un f.readlines() juste après renvoie donc []. Pour relire, rouvre le fichier.

fin du fichier f.read() renvoie tout le texte f.readlines() [] il ne reste rien à lire

Bientôt UTF-8 partout.

Jusqu’à Python 3.14, open sans encoding prend celui du système (cp1252 sur un Windows en français)2. Python 3.15 (automne 2026) passe à UTF-84 ; Java le fait déjà avec Files.readString5. Garde encoding="utf-8" : ton code marche partout.

Exercice 1

Que contient la variable ?

notes.csv contient les trois lignes de la scène : Léa;5.5, Tom;4.5 et Mia;5.

Au premier tour de for ligne in f, ligne vaut…

with open("notes.csv",
          encoding="utf-8") as f:
    texte = f.read()
    lignes = f.readlines()
print(lignes)
print("Tom;4.5\n".strip().split(";"))

Ajouter, ou tout effacer ?

Dans la vraie vie

Un cahier peut s’ouvrir de quatre façons : pour le relire sans stylo, pour écrire à la suite, en arrachant d’abord toutes les pages, ou en exigeant un cahier neuf.

relire à la suite tout effacer neuf, ou rien 'r' 'a' 'w' 'x'

Les quatre modes

Le deuxième argument de open est le mode : 'r', par défaut, lit seulement ; 'a' ajoute à la fin ; 'w' vide d’abord le fichier ; 'x' refuse d’écraser un fichier existant2.

open("journal.txt", "w") journal.txt lundi : 3 exercices mardi : 5 exercices vidé dès l’ouverture, avant tout write

write n’ajoute aucun saut de ligne.

C’est à toi d’écrire \n, sinon les lignes se collent.

sans \n avec \n f.write("mardi")f.write("jeudi") f.write("mardi\n")f.write("jeudi\n") mardijeudi mardijeudi

Le même fichier, quatre modes

journal.txt contient déjà une ligne. Regarde ce que write en fait selon le mode d’ouverture.

journal.txtau départ

journal.txt contient déjà une ligne. Selon le mode d'ouverture, write ne fera pas du tout la même chose.

Écrire, en quatre langages

Ajouter, remplacer, créer sans écraser : Python, Java, JavaScript et Go.

Pythonecrire.py
with open("journal.txt", "a",
          encoding="utf-8") as f:
    f.write("mardi : 5 exercices\n")

with open("sauvegarde.txt", "w",
          encoding="utf-8") as f:
    f.write("niveau=3\n")   # tout remplacé

try:
    with open("facture-001.txt", "x",
              encoding="utf-8") as f:
        f.write("Total : 42 CHF\n")
except FileExistsError:
    print("Cette facture existe déjà.")
JavaFiles.writeString
Path journal = Path.of("journal.txt");
// sans option : comme 'w'
Files.writeString(journal, "lundi : 3 exercices\n");
// comme 'a' (CREATE : créé s'il manque)
Files.writeString(journal, "mardi : 5 exercices\n",
        StandardOpenOption.CREATE, StandardOpenOption.APPEND);
// comme 'x' : erreur s'il existe
Files.writeString(Path.of("facture-001.txt"), "Total : 42 CHF\n",
        StandardOpenOption.CREATE_NEW);
JavaScript (Node)ecrire.mjs
import { writeFile, appendFile } from "node:fs/promises";

// comme 'w'
await writeFile("journal.txt", "lundi : 3 exercices\n", "utf8");
// comme 'a'
await appendFile("journal.txt", "mardi : 5 exercices\n", "utf8");
// comme 'x' : EEXIST s'il existe
await writeFile("facture-001.txt", "Total : 42 CHF\n", { flag: "wx" });
Goecrire.go
err := os.WriteFile("journal.txt", []byte("lundi : 3 exercices\n"), 0644)
if err != nil {
    log.Fatal(err)
}
f, err := os.OpenFile("journal.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
    log.Fatal(err)
}
defer f.Close()
if _, err := f.WriteString("mardi : 5 exercices\n"); err != nil {
    log.Fatal(err)
}

Et 0644, en Go ?

Ce sont les droits donnés au fichier s’il est créé, en notation Unix : le propriétaire lit et écrit, le groupe et les autres lisent seulement.

0644 6rw-propriétaire 4r--groupe 4r--les autres lire = 4, écrire = 2, exécuter = 1
Exercice 2

Quel mode ?

Range chaque besoin dans la bonne case.

'r'lire seulement
'w'tout remplacer
'a'ajouter à la fin
'x'créer, jamais écraser

Écrit, mais pas encore sur le disque

Dans la vraie vie

Au restaurant, le serveur ne court pas en cuisine après chaque plat commandé : il note toute la table sur son carnet, puis transmet tout d’un coup.

pâtes pizza salade pâtes pizza salade le carnet cuisine tout arrive d’un coup

S’il perd son carnet en chemin, aucune commande n’arrive.

Le tampon

Écrire sur le disque prend du temps. Alors write remplit d’abord un tampon en mémoire, vidé d’un coup plus tard : quand il est plein, avec flush, ou à la fermeture du fichier2.

write write tampon, en mémoire Léa;5.5\n Tom;4.5\n (vidé) flush disque tampon.txt 17 octets sur le disque seulement au flush ou au close

write, flush, close

Deux lignes écrites, et la taille réelle du fichier sur le disque à chaque étape.

Le tampon0 octet

open crée tampon.txt sur le disque : 0 octet. Le tampon, en mémoire, est vide.

Réponse à ma question du début : pas forcément.

Mais la ligne a bien été écrite ?

Dans le tampon, oui. Si le programme est arrêté net, elle est perdue. Avec with, le fichier est vidé et fermé à la sortie du bloc, même si une exception survient.

Dans la vraie vie

Tant que tu gardes un livre de la bibliothèque, personne d’autre ne peut l’emprunter.

toi en attente personne d’autre ne peut l’emprunter rendu : au suivant

Le rendre, c’est fermer le fichier.

Vider le tampon

Fermer envoie sur le disque ce qui attend dans le tampon. Sans fermeture, un arrêt brutal le perd.

Libérer la ressource

Fermer libère une ressource du système : un programme ne peut ouvrir qu’un nombre limité de fichiers à la fois.

Laisser la place

Sous Windows, un fichier encore ouvert ne peut en général pas être supprimé.

La documentation

Appeler f.write() sans with ni f.close() « pourrait mener à une situation où les arguments de f.write() ne seraient pas complètement écrits sur le disque, même si le programme se termine avec succès »1.

Sept gestes sur un fichier ouvert

f.read()

Tout le texte d’un coup, dans une seule chaîne. Le curseur finit à la fin du fichier.

f.readline()

La ligne suivante, saut de ligne compris : 'Léa;5.5\n'.

f.readlines()

La liste des lignes qui restent. Juste après un read(), elle est vide.

for ligne in f

Une ligne par tour, sans tout charger en mémoire : la façon la plus simple.

f.write(texte)

Écrit exactement le texte donné, sans saut de ligne, d’abord dans le tampon.

f.flush()

Vide le tampon dans le fichier, sans le fermer.

f.close()

Vide le tampon, puis ferme le fichier. with l’appelle pour toi.

D’où part le chemin ?

Dans la vraie vie

« Entre dans la salle data » : l’indication marche depuis le couloir. Depuis une autre salle, il faut d’abord ressortir.

couloir salle data salle scripts depuis le couloir trouvé pas de salle data ici ressortir d’abord

Une adresse complète, elle, marche d’où que l’on parte.

Relatif ou absolu

open("notes.csv") cherche dans le dossier courant : celui d’où le programme a été lancé, pas forcément celui du script. Un chemin relatif part de ce dossier ; un chemin absolu part de la racine du disque.

relatif : part du dossier courant data/notes.csv absolu : part de la racine /home/lea/projet/data/notes.csv

Le même script, lancé de deux endroits

Un chemin relatif, le dossier parent, un chemin absolu, puis le dossier du script.

Le projetdepuis projet

Lancé depuis projet/ : le chemin relatif data/notes.csv part du dossier courant et trouve le fichier.

Construire un chemin, en quatre langages

pathlib en Python, Path en Java, node:path en JavaScript, filepath en Go.

Pythonpathlib
from pathlib import Path

ici = Path(__file__).parent   # le script
chemin = ici / ".." / "data" / "notes.csv"
with open(chemin, encoding="utf-8") as f:
    print(f.read())

print(Path.cwd())   # le dossier courant
JavaPath
Path chemin = Path.of("data", "notes.csv");
// le dossier courant
System.out.println(System.getProperty("user.dir"));
// dossier courant + data/notes.csv
System.out.println(chemin.toAbsolutePath());
JavaScript (Node)node:path
import path from "node:path";
import { readFile } from "node:fs/promises";

// import.meta.dirname : ce dossier
const chemin = path.join(import.meta.dirname,
    "..", "data", "notes.csv");
console.log(await readFile(chemin, "utf8"));
Gopath/filepath
// data/notes.csv, data\notes.csv sous Windows
chemin := filepath.Join("data", "notes.csv")
contenu, err := os.ReadFile(chemin)
if err != nil {
    log.Fatal(err)
}
fmt.Print(string(contenu))

Windows, ou macOS et Linux

Windows sépare les dossiers par \, macOS et Linux par /. Construis tes chemins avec Path (Python, Java), path.join (Node) ou filepath.Join (Go) : ils choisissent le bon séparateur.

Path("data", "notes.csv") Windows macOS, Linux data\notes.csv data/notes.csv
Exercice 3

Tampon et chemins

Touche la bonne réponse.

f = open("essai.txt", "w",
         encoding="utf-8")
f.write("Bonjour\n")
# essai.txt, sur le disque, contient ?

Le script scripts/moyenne.py fait open("data/notes.csv"). On le lance depuis le dossier scripts/. Résultat ?

Dans ../data/notes.csv, que désigne .. ?

Un dictionnaire devient du texte

Dans la vraie vie

Pour déménager une armoire, on la démonte et on range les pièces à plat dans un carton, avec la notice. À l’arrivée, on la remonte.

chez toi démonter à plat, avec la notice remonter à l’arrivée

Le carton passe par toutes les portes et dans tous les camions.

JSON

Un dictionnaire ou une liste se convertit en texte, dans un format standard : JSON. json.dump écrit dans un fichier, json.load relit ; dumps et loads font la même chose avec une chaîne3.

Python JSON True true None null 'Léa' "Léa" (1, 2) [1, 2]

Où l’image s’arrête : certaines pièces reviennent un peu changées.

Un tuple revient en liste, et une clé 1 revient en "1" : en JSON, les clés sont toujours des chaînes3.

Aller-retour en JSON

Un dictionnaire devient du texte, puis redevient un dictionnaire : regarde ce qui change en route.

1. Un dictionnaire Python, en mémoire : une chaîne, un entier, un booléen et None.

2. json.dumps(d, indent=2) : True devient true, None devient null, tout est entre guillemets doubles.

3. ensure_ascii=False : par défaut, « é » s'écrit \u00e9 ; avec cette option, les accents restent lisibles.

4. json.loads(texte) : retour en Python, dictionnaire égal à l'original. Un tuple, lui, reviendrait en liste.

JSON en trois langages

Le même élève, écrit et relu en Python, en JavaScript et en Go.

Pythoneleve.py
import json

eleve = {"nom": "Léa", "age": 16,
         "notes": [5.5, 6]}
with open("eleve.json", "w",
          encoding="utf-8") as f:
    json.dump(eleve, f, ensure_ascii=False,
              indent=2)

with open("eleve.json",
          encoding="utf-8") as f:
    relu = json.load(f)
print(relu["notes"][1])   # 6
JavaScripteleve.js
const eleve = { nom: "Léa", age: 16,
                notes: [5.5, 6] };
// objet → texte, puis texte → objet
const texte = JSON.stringify(eleve, null, 2);
const relu = JSON.parse(texte);
console.log(relu.notes[1]);   // 6
Goencoding/json
type Eleve struct {
    Nom   string    `json:"nom"`
    Age   int       `json:"age"`
    Notes []float64 `json:"notes"`
}

e := Eleve{"Léa", 16, []float64{5.5, 6}}
data, err := json.Marshal(e)
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(data))
// {"nom":"Léa","age":16,"notes":[5.5,6]}

Et en Java ?

Sa bibliothèque standard ne contient pas de module JSON : on ajoute une bibliothèque, comme Jackson ou Gson. Le format, lui, reste le même.

Piège : les guillemets simples

JSON exige des guillemets doubles. json.loads("{'nom': 'Léa'}") refuse le texte :

JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
Exercice 4

Python ou JSON ?

Touche la bonne réponse.

print(json.dumps({"ok": True, "x": None}))
d = json.loads(json.dumps({"t": (1, 2)}))
print(d["t"])
Exercice 5

Trouve la meilleure note

Remets les lignes dans l'ordre. Avec le notes.csv de la fiche, le programme affiche 5.5.

  1. meilleure = 0
  2. with open("notes.csv",
  3. encoding="utf-8") as f:
  4. for ligne in f:
  5. nom, note = ligne.split(";")
  6. if float(note) > meilleure:
  7. meilleure = float(note)
  8. print(meilleure)

La fiche en six cartes

Le fichier

Les variables disparaissent à la fin du programme ; un fichier reste sur le disque. Il ne contient que du texte : str pour écrire, int ou float pour relire.

Ouvrir

with open(chemin, mode, encoding="utf-8") as f: ouvre le fichier et le ferme à la fin du bloc, même en cas d’exception.

Lire

for ligne in f lit une ligne par tour, saut de ligne compris : strip() l’enlève. Après read(), le curseur est à la fin.

Les modes

'w' vide le fichier dès l’ouverture, 'a' ajoute à la fin, 'x' refuse d’écraser, 'r' ne fait que lire.

Le tampon

write passe par un tampon : les données n’arrivent sur le disque qu’au flush, au close ou quand il est plein.

Chemins et JSON

Un chemin relatif part du dossier courant ; Path(__file__).parent part du dossier du script. JSON : dump / load pour un fichier, dumps / loads pour une chaîne.

À toi de jouer

Mode survie

Dix questions tirées au hasard, de plus en plus difficiles. À la première erreur, la partie s’arrête : lis l’explication, puis relance.

Mon conseil : pour chaque question, demande-toi où est le curseur, ce qui attend dans le tampon, et d’où part le chemin.

10 questions · zéro faute · chronomètre

Sources

  1. Python Software Foundation, Le tutoriel Python : Les entrées/sorties (lecture et écriture de fichiers, with, méthodes des objets fichiers, json), documentation Python 3, consultée en 2026. docs.python.org
  2. Python Software Foundation, Fonctions natives : open() (modes, encodage par défaut, mise en mémoire tampon), documentation Python 3, consultée en 2026. docs.python.org
  3. Python Software Foundation, json : encodage et décodage JSON (table de conversion, ensure_ascii, clés), documentation Python 3, consultée en 2026. docs.python.org
  4. Inada Naoki, PEP 686 : Make UTF-8 mode default, 2022 (pour Python 3.15), consultée en 2026. peps.python.org
  5. Oracle, Java SE 21 API : Files (readString, writeString, readAllLines), consulté en 2026. docs.oracle.com
  6. Projet Node.js, File system, documentation de l'API (fs/promises, drapeaux a, w et wx, API synchrones), consulté en 2026. nodejs.org

Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Extraits exécutés : Python 3.14, Java 21, Node 25 ; tailles de fichier, sorties et messages d'erreur recopiés de ces exécutions. Extraits Go et R relus (compilateurs non disponibles).

Glisser pour continuer vers Prog 13 : Génériques
Gymnase 3