Les fichiers

Ouverture et fermeture

L'ouverture s'effectue via la fonction open(), qui retourne le fichier sous forme d'objet. L'originalité de Python est de proposer de nombreux modes d'ouverture, en plus des trois classiques :

'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.
'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)
## 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, on emploie la méthode readline(), ce qui donnera quelque chose du genre :

fichier = open('donnees.txt', 'r')
ligne = fichier.readline()
while ligne:
print(ligne.strip())
ligne = fichier.readline()
fichier.close()

Ici, 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. Mais comme (presque) toujours en Python, il existe une instruction qui fait cela toute seule, en l'occurence readlines – au pluriel, donc. Démonstration :

fichier = open('donnees.txt', 'r')
lignes = fichier.readlines()
fichier.close()

À l'issue de ce code, les lignes du fichier seront stockées sous forme de liste dans lignes.

Une autre approche (notamment lorsque le fichier n'est pas spécialement structuré en lignes) consiste à le lire d'un seul coup, le rangeant ainsi dans une variable dont on se dépatouillera plus tard, via l'instruction read :

fichier = open('donnees.txt', 'r')
contenu = fichier.read()
fichier.close()

É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ère se fait par la méthode write. Attention, l'ajout du saut de ligne final n'est pas réalisée automatiquement. La chaîne écrite doit donc se terminer par la séquence \n :

fichier = open('resultats.txt', 'w')
fichier.write('Voici une ligne de résultats\n')
fichier.close()

Tout comme on pouvait 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() :

lignes = ['Ligne 1\n', 'Ligne 2\n', 'Ligne 3\n']
fichier = open('resultats.txt', 'w')
fichier.writelines(lignes)
fichier.close()

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

Travailler avec des fichiers CSV

Lorsque le fichier est de type texte, où le caractère de délimitation est a priori la virgule, Python propose comme toujours des instructions afin de nous mâcher le travail. La lecture d’un tel fichier, en particulier, peut nous permettre de récupérer non seulement la structure des enregistrements (des lignes), mais aussi celle des champs. Imaginons que nous traitions un fichier d'employés comportant trois champs (nom, service, date de naissance) séparés par des virgules. On pourra afficher le contenu du fichier par le code suivant :

import csv
with open('anniversaires.csv') as mon_fichier:
csv_lecture = csv.reader(mon_fichier, delimiter=',')

csv_lecture est ici un objet d'un type particulier. On peut s'en servir directement, en écrivant par exemple une boucle telle que :

for row in csv_lecture:
print(f'\t{row[0]}, né.e le {row[2]}, travaille dans le service {row[1]}.')

On peut également convertir cet objet en liste, afin de revenir en territoire connu :

listeFichier = list(csv_lecture)

Plus fort encore, on peut recopier (« parser ») directement le contenu d'un fichier csv dans un dictionnaire. Il suffit pour cela que la première ligne du fichier contienne bien les noms de champ, qui seront utilisés par python comme les noms des clés du dictionnaire. Démonstration :

import csv
with open('anniversaires.csv', mode='r') as mon_fichier:
   csv_lecture = csv.DictReader(mon_fichier)
   for row in csv_lecture:
      print(f'\t{row["nom"]}, né.e le {row["dateNaissance"], travaille dans le service {row["service"]}.')

La question de l'écriture se pose exactement dans les mêmes termes, mais en quelque sorte à l'envers. Si chaque ligne à écrire est consitituée à partir d'une liste, on pourra avoir un code du genre :

import csv
with open('anniversaires.csv', mode='w') as mon_fichier:
   csv_ecriture = csv.writer(mon_fichier, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
   csv_ecriture.writerow(['Albert Martin', 'Achats', '13/05/1998'])
   csv_ecriture.writerow(['Patricia Durand', 'Ressources humaines', '07/10/1982'])
   etc.

A noter que le quoting, c'est-à-dire l'insertion forcée de guillemets autour de chaque donnée, est montré ici, mais n'a rien d'une obligation. On peut tout à fait omettre les arguments le concernant dans la méthode csv_writer Quant à écrire un fichier csv à partir d'un dictionnaire, on peut s'inspirer de l'exemple suivant :

import csv
with open('anniversaires.csv', mode='w') as mon_fichier:
   fieldnames = ['nom', 'service', 'dateNaissance']
   csv_ecriture = csv.DictWriter(mon_fichier, fieldnames=fieldnames)
   csv_ecriture.writeheader()
   csv_ecriture.writerow({'nom': 'Albert Martin', 'service': 'Achats', 'dateNaissance': '13/05/1998'})
   csv_ecriture.writerow({'nom': 'Patricia Durand', 'service': 'Ressources humaines', 'dateNaissance': '07/10/1982'})

Nous en savons à présent suffisamment pour nous lancer dans une petite application.

Ex 1 : Meilleurs scores

On joue au jeu le plus idiot de la terre : il consiste à lancer 10 dés et à additionner les points obtenus. Toutefois, on tient le compte des dix meilleurs scores jamais réalisés. À chaque partie, la machine devra donc vérifier si le score réalisé par le joueur entre dans le Top 10. Dans ce cas, elle lui demandera son nom, puis affichera un message tel que : « Félicitations ! Vous intégrez le Hall of Fame. » La machine affiche ensuite les dix meilleurs scores (par ordre décroissant), avec pour chaque d'eux le nom et le score.

NB : Le fichier des meilleurs scores devra impérativement être codé en csv. Et comme les petits obstacles techniques à franchir ne manquent pas, n'hésitez pas à recourir à Google pour débloquer les situations !