Apprendre Python et s'initier à la programmation

Parfois, on souhaite pouvoir lire les lignes d'un fichier séparément. Une fois le fichier lu intégralement, on pourrait parcourir la chaine de caractères ainsi obtenue et identifier les lignes en repérant les caractères de retour à la ligne (\n sous Linux et MacOS et \r\n sous Windows).

Pour faciliter les choses, il existe une méthode readlines qui renvoie une liste de chaines de caractères, dont chaque élément correspond à une ligne. Les instructions suivantes ouvrent le fichier data.txt en lecture seule pour récupérer son contenu comme une liste de lignes qui sont ensuite affichées à l'aide d'une boucle for :

file = open('data.txt')
content = file.readlines()
file.close()

for line in content:
    print(line)

Si on suppose que le fichier data.txt possède cinq lignes, chacune contenant juste un chiffre allant de kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp à kitxmlcodeinlinelatexdvp5finkitxmlcodeinlinelatexdvp, le résultat de l'exécution du programme serait le suivant :

1

2

3

4

5

Comme vous le constatez, il y a une série de lignes vides dans l'affichage produit. La méthode readlines ne supprime en fait pas le caractère de fin de ligne dans le résultat qu'elle renvoie. Si on ne veut pas de ce ou ces caractères de fin de ligne, il faut s'en débarrasser manuellement. Pour ce faire, on peut, par exemple, utiliser la méthode rstrip des chaines de caractères qui permet de supprimer tous les caractères blancs (espace, tabulation, retour à la ligne…) qui se trouvent à la droite d'une chaine de caractères. Il suffit donc de remplacer la boucle for par :

for line in content:
    print(line.rstrip())

Avec la méthode readlines, on a le même problème qu'avec read, à savoir que l'intégralité du fichier est lue en une fois, et doit donc être stockée en mémoire. Une autre solution consiste à utiliser un itérateur sur le fichier ouvert, que l'on va pouvoir parcourir à l'aide d'une boucle for. De nouveau, le ou les caractères de retour à la ligne seront inclus et doivent être supprimés avec rstrip si on n'en veut pas. Voici la nouvelle version de la lecture du fichier data.txt :

file = open('data.txt')
for line in file:
    print(line.rstrip())

Le premier avantage est que le code est beaucoup plus compact et lisible. Le deuxième avantage est que le fichier est lu au fur et à mesure sur le disque, et pas intégralement comme avec les deux solutions précédentes.

Voyons maintenant comment écrire un fichier texte. L'ouverture et la fermeture du fichier fonctionnent exactement de la même manière que pour la lecture, si ce n'est que le mode doit inclure w ou a. De nouveau, une exception de type IOError peut se produire, si le disque devient plein pendant l'écriture, par exemple.

Pour écrire dans un fichier, on utilise la méthode write qui ajoute la chaine de caractères reçue en paramètre dans le fichier. L'exemple suivant écrit la table de multiplication de kitxmlcodeinlinelatexdvp7finkitxmlcodeinlinelatexdvp dans le fichier data.txt :

try:
    file = open('data.txt', 'w')
    file.write('Table de 7 :\n')
    for i in range(10):
        file.write('{} x 7 = {}\n'.format(i, i * 7))
    file.close()
except IOError:
    print('Erreur d\'entrée/sortie.')

On ouvre d'abord le fichier en mode écriture avec w. On écrit ensuite une première ligne avant de rentrer dans une boucle pour afficher les lignes de la table de multiplication. Remarquez que l'on doit manuellement ajouter le retour à la ligne dans la chaine de caractères envoyée à la fonction write. Voici le fichier data.txt produit par ce programme :

Table de 7 :
0 x 7 = 0
1 x 7 = 7
2 x 7 = 14
3 x 7 = 21
4 x 7 = 28
5 x 7 = 35
6 x 7 = 42
7 x 7 = 49
8 x 7 = 56
9 x 7 = 63

Quelques remarques sont à soulever par rapport à l'écriture dans un fichier texte.

• Lorsqu'on fait une écriture de fichier, sa fermeture à la fin des opérations avec la méthode close est très importante. En effet, sans cet appel, il se peut que les données ne soient pas écrites sur le disque, mais uniquement dans la mémoire tampon du système d'exploitation. Le fichier créé sera donc vide sur le disque.
• Avec le mode w, si le fichier existe, son contenu est complètement effacé et l'écriture commence à son début. Pour éviter cela, il faut soit utiliser le mode a, dans lequel l'écriture commence après le contenu actuel du fichier s'il existe déjà, soit utiliser le mode x qui provoque une erreur de type FileExistsError si le fichier existe déjà, ou enfin tester avant si le fichier existe ou non, avec la fonction exists du module os.path.
• Enfin, si on utilise le caractère \n pour la fin de ligne, elles ne seront pas forcément valables sur tous les systèmes d'exploitation. Le ou les caractères qui identifient une fin de ligne se trouvent dans la variable globale os.linesep du module os.

En informatique, tout caractère est en fait associé à un identifiant numérique qui est typiquement un nombre entier. Cette correspondance est établie dans une table de caractères. Par exemple, la table de caractères ASCII ou iso-646 (l'American Standard Code for Information Interchange (ASCII) a été développé pour représenter les caractères anglais) contient un total de kitxmlcodeinlinelatexdvp128finkitxmlcodeinlinelatexdvp caractères et est utilisée pour représenter les caractères anglais. Cette dernière est reprise à la figure 3, où l'identifiant numérique de chaque caractère est obtenu en additionnant le produit du numéro de sa ligne par kitxmlcodeinlinelatexdvp16finkitxmlcodeinlinelatexdvp avec le numéro de sa colonne (sachant que kitxmlcodeinlinelatexdvpA = 10finkitxmlcodeinlinelatexdvp, kitxmlcodeinlinelatexdvpB = 11finkitxmlcodeinlinelatexdvp…).

Deux fonctions prédéfinies permettent d'effectuer la conversion entre un caractère et son identifiant numérique correspondant. La fonction ord donne l'identifiant numérique correspondant à un caractère tandis que la fonction chr fait l'opération inverse. Examinons l'exemple suivant :

print(ord('|'))
print(chr(65))

Le caractère | doit avoir comme code kitxmlcodeinlinelatexdvp7 \times 16 + 12 = 124finkitxmlcodeinlinelatexdvp et le caractère dont le code est kitxmlcodeinlinelatexdvp65 = 4 \times 16 + 1finkitxmlcodeinlinelatexdvp est le A. Ces calculs sont confirmés par le résultat de l'exécution des deux instructions :

124
A

À la table de caractères, il faut associer une méthode d'encodage, c'est-à-dire une manière de représenter chaque identifiant numérique en une suite de bits. Pour l'ASCII, ce n'est pas très compliqué, il suffit de kitxmlcodeinlinelatexdvp7finkitxmlcodeinlinelatexdvp bits pour chaque caractère afin de pouvoir tous les représenter et c'est ce qui est fait.

Python fonctionne avec la table de caractères Unicode (ISO 10646), un standard d'échange de texte qui a vu le jour en 1987. Cette table comporte plus de kitxmlcodeinlinelatexdvp128000finkitxmlcodeinlinelatexdvp caractères (la liste de tous les caractères Unicode peut être consultée sur le site web suivant : http://unicode-table.com/) dans sa dernière version.

De plus, Python utilise l'encodage UTF-8 pour représenter les caractères Unicode, dans lequel l'unité de base est un bloc de kitxmlcodeinlinelatexdvp8finkitxmlcodeinlinelatexdvp bits. Cet encodage est compatible avec l'ASCII, c'est-à-dire que ses kitxmlcodeinlinelatexdvp128finkitxmlcodeinlinelatexdvp caractères ont le même identifiant numérique.

Comme le montre la figure 4, Unicode contient beaucoup de caractères, permettant ainsi de couvrir toutes les langues du monde et encore plus, comme les emojis, par exemple.

Si on souhaite insérer un caractère Unicode dans une chaine de caractères, sans savoir le taper directement au clavier, on peut utiliser une séquence d'échappement comme on a vu au chapitre 2.

Pour insérer un caractère Unicode, il suffit d'écrire \u ou \U suivi de l'identifiant numérique du caractère voulu. La différence entre les deux notations est que la première se limite aux identifiants représentables sur 16 bits alors que la seconde permet d'aller jusque 32 bits.

Par exemple, pour écrire le symbole de l'intégrale double et l'emoji étonné/effrayé, il suffit d'écrire les instructions suivantes :

print('\u222C')
print('\U0001F631')

Lorsqu'on lit ou écrit un fichier texte dont l'encodage n'est pas UTF-8, il faut le préciser lors de l'ouverture à l'aide du paramètre nommé encoding. Évidemment, on sera du coup limité par rapport aux caractères que l'on pourra lire et écrire.

Par exemple, le programme suivant provoque une erreur d'exécution, car on tente d'écrire un caractère n'étant pas dans la table ASCII alors que le fichier a été créé suivant cet encodage :

file = open('data.txt', 'w', encoding='ascii')
file.write('€')
file.close()

Traceback (most recent call last):
  File "program.py", line 3, in <module>
    file.write('€')
UnicodeEncodeError: 'ascii' codec can't encode character '\u20ac' in position 0: ordinal not in range(128)

Pour lire un fichier binaire, on utilise simplement la fonction load du module pickle. Il faut lire les objets successivement dans le fichier, avec autant d'appels que nécessaires à la fonction load. Les instructions suivantes lisent le fichier qui a été écrit par l'exemple précédent :

import pickle

try:
    with open('data.bin', 'rb') as file:
        name = pickle.load(file)
        data = pickle.load(file)
        print(name, data, sep='\n')
except (IOError, pickle.UnpicklingError):
    print('Erreur de lecture.')

La fonction load prend en seul paramètre une référence vers le fichier dans lequel elle doit lire un objet. Cette lecture peut provoquer une erreur de type pickle.UnpicklingError si jamais l'objet ne sait pas être lu depuis le fichier. De nouveau, une exception de type IOError peut se produire, en cas d'erreur de lecture cette fois-ci.

L'exécution du programme récupère bien les deux objets qui étaient stockés dans le fichier data.bin, comme en témoigne le résultat affiché :

Temperature (2016)
[12, -9, 7, 112, 99]

Comme on l'a vu précédemment, un caractère n'est rien d'autre qu'un nombre entier, à savoir son identifiant numérique. On peut convertir une chaine de caractères en la suite d'octets correspondants, à l'aide de la méthode encode, qui prend en paramètre l'encodage désiré. On obtient en retour un objet bytes, qui représente une liste d'octets.

L'exemple suivant encode une chaine de caractères en UTF-8 et affiche la liste des différents octets correspondants :

s = 'Hello'
data = s.encode('utf-8')

print(type(data))
print(data)
for b in data:
    print(b)

<class 'bytes'>
b'Hello'
72
101
108
108
111

Comme on peut le constater sur le résultat de l'exécution, la variable data est bien de type bytes. De plus, si on affiche simplement la variable, Python affiche la chaine de caractères correspondante, préfixée d'un b pour se rappeler que c'est une séquence d'octets et pas de caractères. Enfin, la boucle for qui parcourt data affiche bien cinq nombres entiers, qui sont les identifiants numériques des lettres du mot « Hello ».

Dans l'autre sens, on peut convertir une séquence d'octets représentée par un objet bytes en une chaine de caractères avec la méthode decode. Pour reconvertir la variable data en une chaine de caractères, on écrit l'instruction suivante :

print(data.decode('utf-8'))

L'exécution de cette instruction affiche bien Hello, sans le préfixe b cette fois-ci puisqu'il s'agit d'une chaine de caractères de type str :

Hello

Reprenons le même exemple que précédemment, à savoir l'écriture d'une chaine de caractères et d'une liste d'entiers. Pour utiliser le module struct, il faut avant tout définir précisément le format de la donnée à écrire, octet par octet. La figure 6 montre comment on va stocker ces données dans le fichier :

1. On commence par écrire un nombre entier, qui représente le nombre de caractères que contient la chaine à écrire ;
2. Viennent ensuite les caractères de la chaine en question ;
3. Puis on écrit de nouveau un nombre entier, qui représente cette fois-ci le nombre d'éléments de la liste d'entiers ;
4. Et on termine avec les éléments de la liste.

Pour écrire une séquence d'octets dans un fichier binaire, on utilise la fonction pack du module struct. Cette dernière prend en paramètres une chaine de caractères qui décrit le type de la donnée à écrire et la donnée en question. Le tableau de la figure 7 reprend les principaux descripteurs de type de donnée à utiliser avec la fonction pack.

Pour écrire dans le fichier binaire, on passe par la méthode write, comme avec les fichiers texte, à qui on passe en paramètre le résultat de l'appel de la fonction pack. Voici comment l'exemple précédent, qui écrit une chaine de caractères suivie d'une liste de nombres entiers, se réécrit avec le module struct :

import struct

name = 'Temperature (2016)'
data = [12, -9, 7, 112, 99]

try:
    with open('data.bin', 'wb') as file:
        file.write(struct.pack('H', len(name)))
        for c in name:
            file.write(struct.pack('c', c.encode('utf-8')))
        file.write(struct.pack('H', len(data)))
        for elem in data:
            file.write(struct.pack('h', elem))
except IOError:
    print('Erreur d\'écriture.')

On écrit donc le nombre de caractères de la chaine comme un entier (H) puis, grâce à une boucle, chacun des caractères (c) encodé avec UTF-8. On suit exactement le même principe pour la liste d'entiers.

On aurait pu écrire les données d'une autre manière, en passant directement à pack tous les caractères ou tous les nombres entiers en une fois. Il suffit pour cela de faire précéder le descripteur de type de donnée par le nombre d'éléments à écrire.

On peut donc modifier l'exemple précédent en remplaçant les instructions qui font l'écriture avec les suivantes :

n = len(name)
file.write(struct.pack('H', n))
file.write(struct.pack('{}s'.format(n), name.encode('utf-8')))
n = len(data)
file.write(struct.pack('H', n))
file.write(struct.pack('{}h'.format(n), *data))

La lecture d'un fichier binaire créé avec struct se fait avec la fonction unpack qui prend deux paramètres, à savoir le format décrivant le type de donnée à lire et la séquence d'octets lue à l'aide de la fonction read sur le fichier. La fonction unpack renvoie un tuple avec les données qu'elle a lues, ce qui fait que lorsqu'on ne souhaite lire qu'un seul élément, il va falloir récupérer le premier élément du tuple comme on peut le voir sur l'exemple suivant qui lit le fichier créé précédemment :

import struct

try:
    with open('data.bin', 'rb') as file:
        n = struct.unpack('H', file.read(2))[0]
        name = ''
        for i in range(n):
            raw = struct.unpack('c', file.read(1))
            name += raw[0].decode('utf-8')
        n = struct.unpack('H', file.read(2))[0]
        data = []
        for i in range(n):
            raw = struct.unpack('h', file.read(2))
            data.append(raw[0])
    print(name, data, sep='\n')
except IOError:
    print('Erreur de lecture.')

Lorsqu'on effectue la lecture dans le fichier, avec la méthode read, il faut préciser le nombre d'octets que l'on veut lire. Un nombre entier non signé court occupe deux octets et un caractère en occupe un.

Notez enfin que ce programme de lecture fonctionne évidemment avec les deux manières d'écrire que l'on vient de voir. En effet, les deux façons de procéder écrivent les données dans le même ordre dans le fichier binaire. Il est donc très important de bien définir le format dans lequel les données sont écrites, ce qui permet de lire et écrire des fichiers écrits avec le module struct.

Tout comme pour l'écriture, on peut simplifier la lecture en lisant directement plusieurs données du même type :

n = struct.unpack('H', file.read(2))[0]
raw = struct.unpack('{}s'.format(n), file.read(n))
name = raw[0].decode('utf-8')
n = struct.unpack('H', file.read(2))[0]
raw = struct.unpack('{}h'.format(n), file.read(2 * n))
data = list(raw)

Le module struct est plus complexe à utiliser que le module pickle, ce dernier écrivant directement et automatiquement des objets Python dans un fichier binaire, alors qu'il faut soi-même définir le format lorsqu'on utilise le module struct. Par contre, l'avantage du module struct est qu'il génère un fichier binaire bien plus compact. Pour l'exemple que l'on a utilisé, on se retrouve avec un fichier qui fait kitxmlcodeinlinelatexdvp33finkitxmlcodeinlinelatexdvp octets au lieu de kitxmlcodeinlinelatexdvp63finkitxmlcodeinlinelatexdvp pour le fichier créé avec le module pickle.