Les fichiers

NB : on se limitera dans ce chapitre au traitement des fichiers texte.

Ouverture et fermeture

L'ouverture s'effectue via la fonction open(), qui retourne le fichier sous forme d'objet. On reconnapit les trois modes d'ouverture :

• 'r' : Lecture (seule).
• 'w' : Écriture : à la première instruction d'écriture, le fichier existant est écrasé.
• 'a' : Ajout : les écritures se font successivement, à la fin du fichier.

Jamais à court de ressources, Python en propose trois autres :

• 'r+' : Lecture et écriture, mais le fichier doit exister pour ne pas provoquer une erreur.
• 'w+' : Lecture et écriture, avec création du nouveau fichier s'il n'existe pas.
• 'a+' : Lecture et ajout.

Pour utiliser un fichier en mode binaire, on rajoute 'b' aux codes précédents (par exemple, 'rb' pour lire un fichier binaire).

La fermeture s'effectue via la méthode close(). L'ensemble donne donc une syntaxe standard :

monFichier = open('chemin/fichier.txt', mode, encoding='utf-8')
# Opérations sur monFichier
monFichier.close()

Lecture(s) d'un fichier

La lecture d'un fichier peut se faire ligne par ligne ou d'un seul coup, au choix du programmeur. Pour une lecture ligne à ligne, la solution la plus proche de l'algorithmique consiste à employer la méthode readline(). Lorsqu'on atteint la fin du fichier, celle-ci renvoie une chaîne vide.

Toutefois, un premier problème se pose : si python découpe bien le fichier en fonction du caractère de fin de ligne, à savoir \n, en revanche il inclut systématiquement ce caractère dans la séquence récupérée. Il faudra donc systématiquement le purger, le plus simple étant d'utiliser la méthode rsplit. On pourra donc écrire quelque chose du genre :

fichier = open('donnees.txt', 'r', encoding='utf-8')
ligne = 'bidon'
while ligne != '' :
   ligne = fichier.readline()
   ligne = ligne.rstrip('\n')
   print(ligne)
fichier.close()

Python propose toutefois une autre manière de procéder, liée au fait qu'un objet fichier est par nature dit « itérable » (comme une liste, ou une chaîne). On peut donc lui appliquer l'instruction de boucle déjà rencontrée plusieurs fois :

fichier = open('donnees.txt', 'r', encoding='utf-8')
for ligne in fichier:
   ligne = ligne.rstrip('\n')
   print(ligne)

Dans ces exemples, on s'est contenté d'afficher le contenu du fichier à l'écran. Mais pour traiter les informations qu'il contient, on peut souhaiter ranger les lignes dans une liste. Ceci peut se faire via une instruction append à l'intérieur de la boucle :

fichier = open('donnees.txt', 'r', encoding='utf-8')
listeFic = []
for ligne in fichier:
   listeFic.append(ligne.rstrip('\n'))

Python propose également une instruction qui économise toute boucle, en la gérant automatiquement : il s'agit de la méthode readlines – au pluriel, donc. Démonstration :

fichier = open('donnees.txt', 'r', encoding='utf-8')
listeFic = fichier.readlines()
fichier.close()

Faut-il préférer l'approche ligne à ligne, via une boucle, ou l'approche globale, via readlines ? À titre personnel, et même lorsque la méthode rapide ne semble poser aucun problème, j'ai une préférence marquée pour l'approche itérative, consistant à lire les lignes une par une via une boucle. D'une part, celle-ci permet de traiter d'emblée le problème du \n final de chaque ligne ; d'autre part, cette méthode permet un contrôle plus fin sur le processus, bien utile lorsque le fichier est volumineux ou que sa lecture est susceptible de générer des erreurs.

Écriture(s) d'un fichier

Faut-il le rappeler, pour écrire dans un fichier, il faut avoir pris soin de l'ouvrir dans un des modes permettant cette opération (w, a ou r+). Pour un fichier texte, l'écriture d'une ligne constituée d'une chaîne de caractères se fait par la méthode write. En toute logique étant donné ce qui précède, le code devra procéder à l'ajout du saut de ligne final \n, qui n'est pas géré automatiquement.

# on suppose qu'on a une liste de lignes appelée listeLignes
fichier = open('resultats.txt', 'w', encoding='utf-8')
for ligne in listeLignes:
   fichier.write(ligne + '\n')
fichier.close()

Tout comme on peut lire d'un seul coup un fichier texte en récupérant les lignes dans une liste avec Readlines(), on peut en sens inverse écrire d'un seul coup une liste dans un fichier sous forme de lignes, avec la méthode Writelines() – là encore, le saut de ligne final doit impérativement figurer dans les chaînes de caractères envoyées à l'écriture :

listeLignes = ['Ligne 1\n', 'Ligne 2\n', 'Ligne 3\n']
fichier = open('resultats.txt', 'w', encoding='utf-8')
fichier.writelines(listeLignes)
fichier.close()

Structuration en champs

Dans un fichier texte, on cherche très souvent à mémoriser l'équivalent d'une table en base de données, c'est-à-dire qu'on ne se contente pas de différents individus ou objets (les enregistrements) mais, pour chacun d'eux, on renseigne différentes informations (les champs). La structuration en ligne correspond aux enregistrements ; reste à trouver le moyen de stocker et restituer les différents champs. Pour ce faire, il existe deux grandes stratégies : oprére soit avec des champs de largeur fixe, soit avec des champs délimités (par un caractère choisi comme séparateur). En python, les deux méthodes sont possibles, mais la plus facile à programmer est clairement celle des champs délimités.

Dans le cas le plus fréquent, on aura besoin de stocker l'intégralité du fichier en mémoire afin de travailler sur les informations, avant de les enregistrer à nouveau. Il faut donc se poser la question du type de données à utiliser à cette fin. Prenons l'exemple classique d'un petit annuaire personnel, où pour chaque individu nous voulons gérer le nom, le prénom, le mail et le numéro de téléphone.

Solution 1 : autant de listes que de champs

Une première solution (qui n'est mentionnée ici que pour être écartée aussitôt) serait de construire quatre listes nom[ ], prenom[ ], email[ ] et tel[ ], puis de veiller ensuite à les gérer de manière coordonnée, que ce soit pour l'ajout ou pour la suppression : le 27e élément de l'une doit toujours bien correspondre au 27e élément des trois autres ! On voit tout de suite qu'un tel choix n'est guère judicieux. En plus de sa lourdeur, il est extrêmement propice aux erreurs de programmation.

Solution 2 : une liste de listes

Une option nettement meilleure sera d'utiliser une liste de listes – l'équivalent en python d'un tableau en deux dimensions. Une fois chargé en mémoire, notre carnet d'adresse ressemblera donc à ceci :

[
 ['Lemarchand', 'Priscille', 'plemarchand@wanadoo.fr', '0687498954'],
 ['Bekouche', 'Mourad', 'mourad.bekouche@gmail.com', '0619435578'],
 ['Vandevelde', 'Gérard', 'vandevelde@yahoo.fr', '0644835712'],
 etc.]

Cette dernière solution est assez performante. Son principal inconvénient est que pour la suite, on ne pourra pas désigner chaque information par un intitulé (nom, prénom, etc.) : on sera obligé de passer par des indices (0 pour le nom, 1 pour le prénom, etc.) ce qui handicape la lisibilité du code. Le nom du troisième individu s'écrit par exemple :

listeFichier[2][0]

Solution 3 : une liste de dictionnaires

On peut donc également envisager deux solutions apparemment un peu plus lourdes, mais qui ont l'avantage de pallier cet inconvénient. La première consiste à utiliser, au lieu d'une liste de listes, une liste de dictionnaires :

[
 {nom : 'Lemarchand', prenom : 'Priscille', email : 'plemarchand@wanadoo.fr', tel : '0687498954'},
 {nom : 'Bekouche', prenom : 'Mourad', email : 'mourad.bekouche@gmail.com', tel : '0619435578'},
 {nom : 'Vandevelde', prenom : 'Gérard', email : 'vandevelde@yahoo.fr', tel : '0644835712'},
 etc.]

Avec cette architecture, on pourra faire apparaître en clair les champs en tant que clés, en demandant par exemple le mail du deuxième individu :

listeFichier[1]['email']

Solution 4 : une liste de structures

Une autre possibilité, qui n'a été implémentée que dans les versions relativement récentes de python, consiste, sur le modèle de ce que nous avons rencontré en algorithmique, à constituer à partir du fichier une liste de structures – et comme on est en programmation objet, une structure est une classe (sans méthodes) :

from dataclasses import dataclass
# déclaration de la structure adresse
@dataclass
class adresse:
   nom: str
   prenom: str
   email: str
   tel: str
...
# une fois le fichier recopié dans une liste de structures
mesAdresses = [
   adresse('Lemarchand', 'Priscille', 'plemarchand@wanadoo.fr', '0687498954'),
   adresse('Bekouche', 'Mourad', 'mourad.bekouche@gmail.com', '0619435578')
   adresse('Vandevelde', 'Gérard', 'vandevelde@yahoo.fr', '0644835712')
   etc. ]

Ainsi, on pourra ensuite obtenir le numéro de téléphone du huitième individu en demandant mesAdresses[7].tel

Recopier les données du fichier en mémoire vive

Bien évidemment, les instructions qui vont permettre de recopier les informations depuis le fichier vers la mémoire vive vont varier selon le type de données choisies pour les accueillir. En supposant qu'à chaque fois, on ait opté pour une itération ligne à ligne, voici les différentes déclinaisons de notre exemple.

Vers une liste de listes

On va pouvoir utiliser un outil déjà signalé dans un chapitre précédent : la méthode split(), qui permet de découper automatiquement une chaîne selon un caractère de délimitation pour en faire une liste. En admettant que dans notre fichier, nous ayons opté pour une délimitation par des points-virgules, nous aurons :

fichier = open('donnees.txt', 'r', encoding='utf-8')
listeFic = []
for ligne in fichier:
   ligne = ligne.rstrip("\n")
   decoupe = ligne.split(';')
   listeFic.append(decoupe)

Vers une liste de dictionnaires

Là, il s'agit d'écrire à chaque fois les bonnes valeurs des clés et des valeurs. On crée donc la liste des clés (qui pourrait exister comme en-tête de colonnes, dans la première ligne du fichier : mais ce n'est pas cette option que l'on a choisi dans cet exemple) :

fichier = open('donnees.txt', 'r', encoding='utf-8')
listeFic = []
champs = ['nom', 'prenom', 'email', 'tel']
for ligne in fichier:
   ligne = ligne.rstrip("\n")
   decoupe = ligne.split(';')
   contact = {}
   for i in range(0, 4):
      contact[champs[i]] = decoupe[i]
   listeFic.append(contact)

Vers une liste de structures

Pour chaque ligne du fichier, il s'agit ici d'envoyer les informations vers les quatre champs qui constituent la structure, puis d'ajouter celle-ci à la liste :

from dataclasses import dataclass
# déclaration de la structure adresse
@dataclass
class adresse:
   nom: str
   prenom: str
   email: str
   tel: str

fichier = open('c:\genre\carnet.txt', 'r', encoding='utf-8')
listeFic = []
for ligne in fichier:
   ligne = ligne.rstrip("\n")
   nom, prenom, mail, tel = ligne.split(';')
   individu = adresse(nom, prenom, mail, tel)
   listeFic.append(individu)

Le gestionnaire de fichiers .csv

Les techniques ci-dessus, qui passent par le split possèdent l'avantage d'une certaine légèreté. Elles ont néanmoins un inconvénient majeur : celui de ne fonctionner qu'à condition que la structure du fichier soit toujours parfaitement régulière. Il suffira par exemple qu'un des champs du fichier contienne des guillemets, un saut de ligne ou le caractère séparateur pour qu'un erreur se produise. Le module csv, lui, gère beaucoup de cas problématiques qui apparaissent très vite dans des données sur lequelles on n'a pas un contrôle parfait, ce qui est souvent le cas.

Avec une liste de listes

On ne reprendra pas ici l'intégralité des solutions proposées précédemment. Regardons simplement ce qui se passe lorsqu'on décide de gérer le fichier avec une liste de liste - et dorénavant, on décide que la première ligne du fichier contiendra les noms de champs. Les deux instructions utiles sont writerow (pour écrire une seule ligne) et writerows (pour écrire une série de lignes à partir d'une liste). Ainsi, si notre fichier contient une petite base de données sur des films, du genre :

titre,annee,realisation,note
Alien,1979,Ridley Scott,9
Blade Runner,1982,Ridley Scott,10
Brazil,1985,Terry Gilliam,8

La lecture s'effectuera ainsi :

import csv
...
fichier = open('c:/genre/films.csv', encoding='utf-8')
reader = csv.reader(fichier)
header = next(reader)
listeFic = []
for row in reader:
   titre = row[0]
   annee = int(row[1])
   realisateur = row[2]
   note = int(row[3])
   listeFic.append([titre, annee, realisateur, note])

On notera que dans ce cas, en mémoire vive, on a transformé deux des champs texte en numériques (entiers). On reprend donc cette convention pour l'écriture, à partir d'une liste mélangeant les deux types de données :

import csv
...
films = [
   ['Alien', 1979, 'Ridley Scott', 9],
   ['Blade Runner', 1982, 'Ridley Scott', 10],
   ['Brazil', 1985, 'Terry Gilliam', 8]
]
...
fichier = open('films.csv', 'w', newline='', encoding='utf-8')
writer = csv.writer(fichier)
writer.writerow(['titre', 'annee', 'realisateur', 'note'])
writer.writerows(films)

Avec une liste de dictionnaires

Dans le cas où on a choisi d'utiliser en mémoire vive une liste de dictionnaires, il existe alors deux armes fatales. Pour la lecture, DictReader :

import csv
...
films = []
fichier = open('c:/genre/films.csv', encoding='utf-8')
lecteur = csv.DictReader(fichier)
for ligne in lecteur:
   films.append(ligne)

NB : si le délimiteur est autre que la virgule, on peut le préciser sous forme d'argument supplémentaire dans DictReader :

lecteur = csv.DictReader(fichier, delimiter=';')

Quant à l'écriture, elle s'effectue grâce à la méthode inverse, DictWriter :

import csv
...
fichier = open('films.csv', 'w', newline='', encoding='utf-8')
writer = csv.DictWriter(fichier, fieldnames=['titre', 'annee', 'realisateur', 'note'])
writer.writeheader()
writer.writerows(films)

Techniques supplémentaires

Prévenir les erreurs

Un des problèmes qui se posent lorsqu'on veut utiliser un fichier en lecture dans un programme est sa possible absence de l'emplacement programmé. Aussi est-il est sage d'ouvrir le parapluie et de prévenir qu'une telle erreur interrompe l'exécution du programme. Python propose pour cela un bloc try, qui permet en quelque sorte d'attraper une erreur au vol avant qu'elle n'interrompe l'exécution, et de la gérer via l'instruction except. On pourra ainsi écrire quelque chose du genre :

try:
   monFichier = open('bidule.txt', 'r')
   contenu = monFichier.read()
   monFichier.close()
except FileNotFoundError:
   print("Fichier introuvable")

Économiser l'instruction close

Bien des programmeurs aiment économiser l'instruction Close() en ouvrant le fichier via l'instruction With. Ainsi, au lieu d'écrire comme précédemment :

monFichier = open('chemin/fichier.txt', mode)
# Opérations sur monFichier
monFichier.close()

On aura à présent :

with open('chemin/fichier.txt', mode) as monFichier:
# Opérations sur monFichier