Lecture et écriture de fichiers

Astuce : les blocs de cette page fonctionnent aussi pour les fichiers. Le moteur Python du navigateur dispose d'un petit disque virtuel : un même exemple peut écrire puis relire un fichier et montrer le résultat.

Ce qu'est vraiment un fichier texte

Un fichier texte n'est pas un tableau de lignes. C'est une seule longue chaîne de caractères, dans laquelle le passage à la ligne est un caractère comme les autres, noté \n. Un fichier qui semble contenir trois notes contient en réalité neuf caractères :

1 5 \n 1 8 \n 1 2 \n

Cette idée paraît anodine, et pourtant c'est elle qui explique presque tout le chapitre : pourquoi une ligne lue se termine par un caractère invisible, pourquoi deux écritures se collent l'une à l'autre, et pourquoi une position dans le fichier se compte en caractères et non en lignes.

La figure ci-dessous déroule une lecture sur ce fichier de neuf caractères. Chaque case est un caractère, le saut de ligne s'affiche ⏎, et le trait vertical est la position de lecture. Ce qui est estompé a déjà été consommé.

Deux observations valent d'être faites sur cette figure, parce qu'elles reviendront comme causes de bogues dans tout le reste du chapitre : la valeur renvoyée contient le \n final, et l'appel de trop ne provoque aucune erreur.

Ouvrir : le mode décide de tout

On ouvre un fichier avec open("nom", "mode"). Le mode dit ce qu'on veut en faire, et il agit dès l'ouverture, avant toute lecture ou écriture :

La ligne du milieu est la plus coûteuse en pratique. Le mode "w" ne remplace pas le contenu au moment où l'on écrit : il le supprime à l'instant de l'ouverture. Un programme qui ouvre en "w" puis plante trois lignes plus loin laisse un fichier vide, et l'ancien contenu n'existe plus nulle part.

Refermer sans y penser : with

Un fichier ouvert doit être refermé. Ce n'est pas une politesse : tant qu'il est ouvert, ce qui a été écrit peut encore se trouver dans un tampon en mémoire et pas sur le disque. Un programme interrompu avant la fermeture laisse un fichier incomplet, parfois vide, alors que toutes les lignes de write se sont exécutées sans erreur.

La forme with open(...) as f: s'en charge. Le fichier est refermé à la sortie du bloc, y compris si une erreur survient au milieu, ce qu'un close() placé à la dernière ligne ne garantit pas.

Écrire :

Relire tout de suite :

Le bloc with marque aussi visuellement la zone où le fichier est utilisable. En dehors de l'indentation, f existe encore comme variable, mais toute opération dessus lève une erreur : le fichier est fermé. C'est une limite utile, car elle pousse à sortir du bloc dès que les données sont chargées, plutôt qu'à faire tout le traitement fichier ouvert.

Lire ligne par ligne

Pour traiter un fichier ligne à ligne, on le parcourt comme une séquence. La méthode .strip() retire les espaces et le saut de ligne aux deux extrémités :

Sans .strip(), chaque valeur traînerait son \n. Les conséquences sont discrètes et agaçantes : int("12\n") fonctionne, parce que la conversion tolère les espaces, mais "12\n" == "12" est faux, et un affichage se retrouve espacé d'une ligne sur deux. La règle de survie tient en une phrase : une ligne lue se nettoie avant d'être utilisée.

Trois façons de lire coexistent, et elles ne servent pas aux mêmes fichiers :

La boucle for a un avantage qui ne se voit pas sur un fichier de trois lignes : elle ne charge qu'une ligne à la fois en mémoire. Sur un relevé de capteur d'un million de lignes, read() occupe autant de mémoire que le fichier entier, tandis que la boucle en occupe une ligne.

Le curseur, ou pourquoi un fichier ne se lit qu'une fois

Un fichier ouvert possède une position de lecture, qui avance à chaque caractère consommé et ne recule jamais toute seule. Elle se compte en caractères depuis le début, saut de ligne compris.

La conséquence surprend toujours : après un premier parcours, il n'y a plus rien à lire. Un second read() ne renvoie pas le fichier, ni une erreur, mais la chaîne vide. Une seconde boucle for ne s'exécute tout simplement pas, et le programme reste muet sans rien signaler.

Ce comportement a une raison : un fichier peut être immense, et rien ne garantit qu'il tienne en mémoire. Python ne le conserve donc pas ; il se souvient seulement de l'endroit où la lecture en est.

Deux réponses existent, et la seconde est presque toujours la bonne :

• f.seek(0) ramène le curseur au début, ce qui relit le fichier sur le disque.
• Conserver les lignes dans une liste lors du premier parcours, puis travailler sur la liste autant de fois que nécessaire.

Écrire : le saut de ligne n'est pas automatique

f.write() écrit exactement ce qu'on lui donne, et rien de plus. À la différence de print(), qui ajoute un passage à la ligne, write ne suppose rien. Deux écritures successives se retrouvent donc collées sur la même ligne.

Le fichier contient bien deux nombres, mais plus aucun moyen de savoir où s'arrête le premier. La relecture donnera une valeur unique, et l'erreur ne se manifestera qu'à ce moment-là, loin de sa cause.

La correction tient au caractère ajouté à chaque écriture :

Deux points méritent d'être notés au passage. write attend une chaîne : écrire un nombre directement lève une erreur, d'où le f"{m}" qui le convertit. Et pour une liste déjà prête, "\n".join(...) évite la boucle :

Ajouter sans écraser

Le mode "a" ouvre le fichier avec le curseur déjà placé à la fin. C'est ce détail, et non une règle séparée, qui fait que l'ancien contenu survit.

C'est le mode du journal : un programme qui tourne en continu ajoute une ligne à chaque événement, sans jamais relire ni réécrire ce qui précède.

Un fichier de journal ouvert en "w" par erreur perd tout l'historique à chaque démarrage du programme, et personne ne s'en aperçoit tant que l'historique ne sert pas.

Des lignes aux données : une colonne par valeur

Les fichiers réels contiennent rarement une seule valeur par ligne. Le format le plus répandu met plusieurs champs séparés par un point-virgule ou une virgule, et porte l'extension .csv :

capteur;temperature;humidite
A12;21.4;57
A12;22.1;55
B03;19.8;61

Le traitement suit toujours les mêmes trois gestes : nettoyer la ligne, la découper avec .split(";"), puis convertir les champs qui sont des nombres.

L'astuce de ce programme se trouve à la ligne entete = f.readline(). Un seul appel consomme la ligne de titres, et la boucle qui suit reprend là où le curseur s'est arrêté, donc à la première ligne de données. C'est le curseur de la section précédente, employé cette fois à dessein.

Un point de vigilance : .split(";") renvoie toujours des chaînes, même quand le fichier contient des nombres. Sans conversion par float() ou int(), l'addition concatène au lieu d'additionner, et le tri classe "100" avant "9".

Le module csv, pour les fichiers de tableur

.split(";") suffit tant qu'aucun champ ne contient lui-même le séparateur. Un tableur ne s'en prive pas : une cellule « Atelier; poste 3 » est exportée entre guillemets, "Atelier; poste 3", justement pour signaler que ce point-virgule-là fait partie du texte. .split ne connaît pas cette convention et coupe partout. Le module csv de la bibliothèque standard, lui, la respecte.

Le découpage à la main rend quatre champs au lieu de trois, et la température glisse en quatrième position : float(champs[2]) tenterait de convertir ' poste 3"'. csv.reader rend chaque ligne sous forme de liste de champs, guillemets retirés, séparateur intérieur conservé. Le paramètre delimiter=";" est indispensable avec un export français, car le module attend par défaut une virgule. Quant à newline="" à l'ouverture, c'est la recommandation de la documentation : il laisse au module le soin des fins de ligne, y compris celles qui se trouvent à l'intérieur d'un champ entre guillemets.

Mieux encore, csv.DictReader lit lui-même la ligne de titres et rend chaque ligne sous forme de dictionnaire : on désigne une colonne par son nom plutôt que par sa position.

Plus de readline() pour sauter l'en-tête, plus d'indice à compter : ligne["temperature"] reste juste le jour où quelqu'un insère une colonne dans le tableur. Les valeurs, en revanche, restent des chaînes, comme avec .split : la conversion par float() ne disparaît pas. Pour écrire, csv.writer(f, delimiter=";") et sa méthode writerow([...]) font le chemin inverse, et ajoutent d'eux-mêmes les guillemets là où il en faut.

Les accents, et le paramètre qui les sauve

Un fichier texte ne contient pas des lettres mais des octets, et la table qui relie les deux s'appelle l'encodage. Tant que le texte reste en ASCII, tout le monde s'entend. Dès qu'un accent apparaît, l'accord doit être explicite, sans quoi « Café » se relit « Café » ou provoque une UnicodeDecodeError.

La précaution tient en un paramètre, à mettre à l'écriture comme à la lecture :

utf-8 est aujourd'hui le standard. Un fichier exporté par un tableur ancien sous Windows peut réclamer encoding="latin-1" ou encoding="cp1252" : c'est la première chose à essayer devant un fichier illisible.

Quand le fichier n'est pas là

Ouvrir en lecture un fichier absent lève une FileNotFoundError, et le programme s'arrête. C'est le cas le plus fréquent en production, parce que le nom vient souvent de l'extérieur : une saisie, un argument, un dossier partagé.

Le try / except transforme cet arrêt en message utile :

Deux autres erreurs valent d'être connues, car elles disent exactement ce qui cloche :

Plusieurs erreurs, un seul try

Le try / except a été rencontré au chapitre Conditions et boucles, sur une saisie qui refusait de devenir un nombre. Un traitement de fichier en demande davantage, parce qu'il peut échouer de deux façons très différentes : le fichier manque, ou il est là mais une ligne est illisible. Le bloc suivant traite les deux séparément, et emploie les quatre éléments de la forme complète.

Chaque élément a son rôle.

• Plusieurs except : Python les essaie dans l'ordre, et seul le premier qui correspond à l'erreur s'exécute. Le cas le plus précis se place donc en premier.
• as e donne un nom à l'erreur interceptée. L'afficher rend le message de Python, qui en dit souvent plus qu'on ne l'aurait écrit : ici, 'n/a\n' montre à la fois la valeur fautive et son saut de ligne. C'est la forme except ValueError as e qu'emploie le chapitre sur NumPy.
• else ne s'exécute que si aucune erreur n'a eu lieu. Il permet de réduire le try aux lignes qui peuvent échouer : une erreur dans le calcul de la moyenne ne sera pas prise pour une ligne illisible.
• finally s'exécute toujours, erreur ou non, même si la fonction sort par un return. Le with refermant déjà le fichier, il ne sert ici qu'au message de fin ; ailleurs, il remet un appareil dans un état sûr quoi qu'il arrive.

Le raccourci, quand le fichier est court

Pour un fichier qui tient en mémoire, le module pathlib réduit les trois lignes à une seule, avec la fermeture comprise :

.splitlines() découpe et retire les sauts de ligne au passage, ce qui évite le .strip() de chaque ligne. Sur un gros fichier, en revanche, la boucle for ligne in f: reste la seule option raisonnable, puisque read_text charge tout d'un coup.

Enregistrer une structure : le format JSON

Un fichier texte range bien une liste de nombres, un par ligne. Un dictionnaire qui contient des listes, qui contiennent elles-mêmes des dictionnaires, n'a pas de forme évidente en lignes et en colonnes. Pour ces données-là, le format d'échange standard est JSON : du texte lisible, dont la syntaxe ressemble à s'y méprendre à celle des dictionnaires et des listes de Python. C'est sous cette forme qu'arrivent les réponses de la plupart des services web, bien des fichiers de configuration, ou la commande que reçoit une fonction dans l'atelier sur les fonctions avancées.

Le module json fait la traduction dans les deux sens. json.dumps transforme une structure Python en chaîne JSON, json.loads fait le chemin inverse :

La correspondance est presque mot pour mot :

Avec un fichier, on retire le s final, qui voulait dire string : json.dump(donnees, f) écrit dans un fichier ouvert, json.load(f) en relit le contenu.

indent=2 met une valeur par ligne, avec retrait, pour qu'un humain puisse relire et corriger le fichier ; sans lui, tout tient sur une seule ligne. ensure_ascii=False garde les accents tels quels au lieu de les écrire \u00e9, d'où l'encoding="utf-8" à l'ouverture.

Mettre en pratique

Exercice : le relevé de température. Trois mesures sont données. Il s'agit de les enregistrer dans releve.txt, une par ligne, puis de relire le fichier pour afficher chaque mesure et la moyenne.

Pour aller plus loin : reprendre le relevé au format date;temperature, puis n'afficher que les journées au-dessus de 20 °C. Le découpage par .split(";") et la conversion du second champ suffisent.