Vider le tampon
Fermer envoie sur le disque ce qui attend dans le tampon. Sans fermeture, un arrêt brutal le perd.
Programmation · Prog 12 · Garder des traces
Ce que ton programme doit garder quand il s’arrête, et comment le relire.
Déjà à l'aise ? Aller directement au quizDans la vraie vie
Tu joues depuis une heure, tu viens d’atteindre le niveau 7. Et là, coupure de courant.
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.
Oui, on vient de l’écrire !
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.
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.
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.
Un jeu écrit son meilleur score dans score.txt, s’arrête, puis le relit au lancement suivant.
Pendant la partie, le meilleur score vit dans une variable, en mémoire vive.
Écrire le score à la fin d’une partie, le relire au lancement suivant.
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" → 42Un 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.
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.
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.
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.
Le programme reste à l’écran ; à chaque étape, ses lignes s’allument et le curseur de lecture avance dans le fichier.
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.
Pourquoi print(ligne) saute-t-il une ligne de plus ?
Tout d’un coup, la liste des lignes, ou une ligne par tour : Python, Java, JavaScript, Go et R.
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())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);
}
}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));
}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())
}lignes <- readLines("notes.csv", encoding = "UTF-8")
notes <- read.csv("notes.csv", sep = ";", header = FALSE,
col.names = c("nom", "note"))
mean(notes$note) # 5Piè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.
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.
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.
write n’ajoute aucun saut de ligne.
C’est à toi d’écrire \n, sinon les lignes se collent.
journal.txt contient déjà une ligne. Regarde ce que write en fait selon le mode d’ouverture.
journal.txt contient déjà une ligne. Selon le mode d'ouverture, write ne fera pas du tout la même chose.
Ajouter, remplacer, créer sans écraser : Python, Java, JavaScript et Go.
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à.")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);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" });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.
Range chaque besoin dans la bonne case.
É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.
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.
Deux lignes écrites, et la taille réelle du fichier sur le disque à chaque étape.
open crée tampon.txt sur le disque : 0 octet. Le tampon, en mémoire, est vide.
Mais la ligne a bien été écrite ?
Dans la vraie vie
Tant que tu gardes un livre de la bibliothèque, personne d’autre ne peut l’emprunter.
Le rendre, c’est fermer le fichier.
Fermer envoie sur le disque ce qui attend dans le tampon. Sans fermeture, un arrêt brutal le perd.
Fermer libère une ressource du système : un programme ne peut ouvrir qu’un nombre limité de fichiers à la fois.
Sous Windows, un fichier encore ouvert ne peut en général pas être supprimé.
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.
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 fUne 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.
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.
Un chemin relatif, le dossier parent, un chemin absolu, puis le dossier du script.
Lancé depuis projet/ : le chemin relatif data/notes.csv part du dossier courant et trouve le fichier.
pathlib en Python, Path en Java, node:path en JavaScript, filepath en Go.
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 courantPath 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());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"));// 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.
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.
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.
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.
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.
Le même élève, écrit et relu en Python, en JavaScript et en Go.
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]) # 6const 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]); // 6type 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)
Touche la bonne réponse.
print(json.dumps({"ok": True, "x": None}))d = json.loads(json.dumps({"t": (1, 2)}))
print(d["t"])Remets les lignes dans l'ordre. Avec le notes.csv de la fiche, le programme affiche 5.5.
La fiche en six cartes
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.
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.
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.
'w' vide le fichier dès l’ouverture, 'a' ajoute à la fin, 'x' refuse d’écraser, 'r' ne fait que lire.
write passe par un tampon : les données n’arrivent sur le disque qu’au flush, au close ou quand il est plein.
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
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.
10 questions · zéro faute · chronomètre
Les vidéos de Graven, en français, sur les fichiers en Java et en Python.
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).