Il y a plusieurs type de fichiers. En particulier, on fait la différence entre les fichiers qui contiennent du texte (et dans lesquelles chaque ligne est terminée par un caractère de “newline”) et le fichiers binaires (images, vidéos etc). Dans cet article nous traiterons les opérations de base sur les fichiers de texte.
La lecture et l’écriture des fichiers de texte sont des activités qui sont présentes dans quasiment tous les logiciels. Nous utilisons des fichiers de texte pour stocker des paramétrés, par exemple notre pseudonyme et notre personnage préféré dans un jeu vidéo et pour le retrouver lors du prochain démarrage du jeu.
Les fichiers de texte qu’on utilise peuvent être structurés ou pas. Exemples de fichiers structurés sont les fichiers ou chaque valeur est sépare par une virgule (Comma Separated Values ou CSV) come celui ci:
Name, Address, Email
ABC,Ville A, abc@xyz.com
LMN,Ville B, lmn@xyz.com
PQR,Ville A, pqr@xyz.com
Ici la première ligne définit les noms des valeurs et les trois lignes qui suivent sont des données enregistrées. Les séparateurs peuvent être des tabs (\t) ou des autres symboles. Des autres formats structurés existent aussi, par exemple les fichiers “Javascript Object Notation” (ou JSON) ou les fichiers .INI de Windows.
Il y a aussi des fichiers de texte que n’ont pas de structure, par exemple un fichier que contient le texte d’une chanson ou d’un discours ou d’un livre ou simplement une liste de mots.
En python, nous ouvrons un fichier en utilisant la commande (devinez un peu…) open! Ça fonctionne comme ça:
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
La fonction open, si le fichier existe retourne un objet-fichier qui possède des méthodes et des attributs pour obtenir des informations et manipuler le fichier ouvert. L’objet-fichier doit toujours être fermé avec la méthode close().
Les deux paramétrés plus importants de open sont le nom du fichier (file) et le mode d’ouverture. Le nom du fichier est une chaîne de caractères que représente soit le nom du fichier (que doit être stocké dans le même dossier du programme python) soit le parcours complet du fichier. Exemples:
- “D:\\dir1\\monfichier.txt” (en windows)
- “/dir1/monfichier.txt” (en Linux)
- “monfichier,txt” (en windows et linux, doit être dans le même dossier que le programme)
Le mode d’ouverture du fichier définit à la fois l’opération que nous allons exécuter sur le fichier (lecture, écriture ou si nous voulons ajouter de lignes) et le type de fichier. Nous ajoutons une petite “b” (binary) si on travaille sur un fichier binaire, rien pour du texte, Voici la liste complète des “modes”:
- r: Ouvrir un fichier en lecture. Démarre la lecture au début du fichier. C’est aussi la modalité standard si nous ne passons pas le mode.
- rb: Ouvrir un fichier en lecture, modalité binaire. Démarre la lecture au début du fichier.
- r+: Ouvrir un fichier en lecture et écriture. Le pointer du fichier est au début du fichier.
- w: Ouvrir un fichier écriture, mode texte. Le pointer du fichier est au début du fichier. Si le fichier existe déjà il est effacé. S’il n’existe pas, il est crée.
- wb: Comme w mais en modalité binaire.
- w+: Comme w mais on peut aussi lire du fichier.
- wb+: Comme wb mais en modalité binaire.
- a: Ouvre le fichier en modalité écriture et texte à partir de la fin du fichier. Nous ajoutons des lignes. Le fichier est crée s’il n’existe pas.
- ab: Comme a mais en modalité binaire.
- a+: Comme a mais on peut aussi lire du fichier.
- ab+: Comme ab mais en modalité binaire.
Maintenant nous savons comment ouvrir un fichier. Mais comment le lire ou écrire? On verra d’abord la lecture.
Trois opérations existent pour lire à partir d’un objet-fichier.
- read([n])
- readline([n])
- readlines()
La méthode read() retourne tout le fichier si nous ne spécifions pas le nombre de caractères que nous voulons lire.
Si par exemple on a le fichier couleurs.txt suivant
rouge
jeaune
bleau
orange
vert
blanc
noir
violet
rose
et nous lisons tout le fichier avec read:
couleurs = open("couleurs.txt")
mescouleurs = couleurs.read()
print(mescouleurs)
couleurs.close()
####### Resultats #######
rouge
jeaune
bleau
orange
vert
blanc
noir
violet
rose
Mais si nous appelons read(4)
couleurs = open("couleurs.txt")
mescouleurs = couleurs.read(4)
print(mescouleurs)
couleurs.close()
####### Resultats #######
roug
La méthode readline() sert à lire une ligne à la fois, jusqu’au nombre de caractères spécifie ou à la fin de la ligne. Nous pourrions par exemple lire chaque ligne et remplir un dictionnaire comme ça.
Fichier d’exemple (dictio.txt):
joueur:anto
couleur:rouge
avatar:mario
Exemple de lecture ligne par ligne et de création d’un dictionnaire :
# Ouverture fichier
dict = open("dictio.txt")
# Creation d'un dictionnaire vide
mon_dictio = {}
# Lecture du fichier jusqu'à sa fin
while 1:
ligne = dict.readline()
# S'il n'y a pas de ligne c'est qu'on a fini
if not ligne:
break
# separe le cles des valeurs
clesValeurs = ligne.split(":")
mon_dictio[clesValeurs[0]] = clesValeurs[1]
print (mon_dictio)
dict.close()
####### Resultats ##########
{'joueur': 'anto\n', 'couleur': 'rouge\n', 'avatar': 'mario\n'}
Mais nous pourrons aussi bien utiliser la dernière méthode pour la lecture, readlines, qui lit toutes les lignes du fichier et les mets dans une liste:
# Ouverture fichier
dict = open("dictio.txt")
# Creation d'un dictionnaire vide
mon_dictio = {}
# Lecture du fichier dans un seul coup
lignes = dict.readlines()
# On utilise maintenant une boucle for sur la liste
for ligne in lignes:
# separe le cles des valeurs
clesValeurs = ligne.split(":")
mon_dictio[clesValeurs[0]] = clesValeurs[1]
print (mon_dictio)
dict.close()
####### Resultats ########
{'joueur': 'anto\n', 'couleur': 'rouge\n', 'avatar': 'mario\n'}
Pour l’écriture, nous disposons de deux méthodes :
- write(chaine)
- writelines(liste)
C’est très évident ce qui les deux font. Nous irons ouvrir le fichier “dictio.txt” et rajouter l’élément {‘age’:’50’} dedans.
# Ouverture fichier en "append"
dict = open("dictio.txt", "a")
# Eriture du fichier
dict.writelines(["age:50"])
dict.close()
# Si on lit le fichier à nouveau, notre dictionnaire sera:
{'joueur': 'anto\n', 'couleur': 'rouge\n', 'avatar': 'mario\n', 'age': "'50'"}
J’ai utilisé writelines et passé une liste.
Autre méthodes des objet-fichiers:
- readable(): Vrai si le fichier est lisible, Faux si non
- writable(): Vrai si on sait écrire sur le fichier, Faux si non
- fileno(): Nombre entier utilisé par Python pour communiquer les opérations sur le fichiers au OS
- flush(): Nettoie le buffer du fichier
- isatty(): Vrai si le fichier est connecté à une porte TTY
- truncate([size]): Coupe le fichier au nombre d’octets spécifié
- next(iterator,[default]): Itération sur le fichier jusqu’à sa fin (EOF) en lecture quand le fichier est utilisé comme “Iterator”.
Voici un petit exemple:
dict = open("dictio.txt", "r")
print("Dict est lisible ", dict.readable())
print("Nous pouvons ecrire ", dict.writable())
print("File no", dict.fileno())
dict.close()
######## Résultats #########
Dict est lisible True
Nous pouvons ecrire False
File no 5
Ici on ouvre le fichier en lecture, c’est normal de ne pas pouvoir y écrire.
Il y a des autres façons de gérer les fichiers, par exemple avec la librairie os. Mais ce sera le sujet d’un autre article.
