7. Les entrées/sorties

Il existe bien des moyens de présenter les sorties d’un programmes ; les données peuvent être imprimées sous une forme lisible par un être humain, ou sauvegardées dans un fichier pour une utilisation future. Ce chapitre présentera donc diverses possibilités.

7.1. Formatage de données

Jusque là, nous avons rencontré deux moyens d’écrire des données : les déclarations d’expressions et la fonction print(). (Une troisième méthode consiste à utiliser la méthode write() des fichiers, le fichier de sortie standard peut être référence en tant que sys.stdout. Voyez le Guide de Référence de la Bibliothèque Standard pour en savoir plus.)

Often you’ll want more control over the formatting of your output than simply printing space-separated values. There are two ways to format your output; the first way is to do all the string handling yourself; using string slicing and concatenation operations you can create any layout you can imagine. The string type has some methods that perform useful operations for padding strings to a given column width; these will be discussed shortly. The second way is to use the str.format() method.

Le module string contient une classe Template qui offre encore une autre façon de remplacer des valeurs au sein de chaînes de caractères.

Mais une question demeure, bien sûr : comment convertir des valeurs en chaînes de caractères ? Heureusement, Python fournit plusieurs moyens de convertir n’importe quelle valeur en chaîne : les fonctions repr() et str().

La fonction str() est destinée à renvoyer des représentations de valeurs qui soient lisibles par un être humain, alors que la fonction repr() est destinée à générer des représentations qui puissent être lues par l’interpréteur (ou forceront une SyntaxError s’il n’existe aucune syntaxe équivalente). Pour les objets qui n’ont pas de représentation humaine spécifique, str() renverra la même valeur que repr(). Beaucoup de valeurs, comme les nombres ou les structures telles que les listes ou les dictionnaires, ont la même représentation en utilisant les deux fonctions. Les chaînes de caractères et les nombres à virgule flottante, en revanche, ont deux représentations distinctes.

Quelques exemples :

>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print(s)
The value of x is 32.5, and y is 40000...
>>> # The repr() of a string adds string quotes and backslashes:
... hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, world\n'
>>> # The argument to repr() may be any Python object:
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"

Voici deux façons d’écrire une table de carrés et de cubes :

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
...     # Note use of 'end' on previous line
...     print(repr(x*x*x).rjust(4))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

>>> for x in range(1, 11):
...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

(Notez que dans ce premier exemple, un espace entre chaque colonne a été ajouté par la façon dont fonctionne print(), qui ajoute toujours des espaces entre ses paramètres.)

Cet exemple démontre l’utilisation de la méthode str.rjust() des chaînes de caractères, qui fait une justification à droite d’une chaîne dans un champ d’une largeur donnée en ajoutant des espaces sur la gauche. Il existe des méthodes similaires str.ljust() et str.center(). Ces méthodes n’écrivent rien, elles retournent simplement une nouvelle chaîne. Si la chaîne passée en paramètre est trop longue, elle n’est pas tronquée mais renvoyée sans modification ; ce qui peut déranger votre mise en page mais est souvent préférable à l’alternative, qui pourrait mentir sur une valeur (et si vous voulez vraiment tronquer vos valeurs, vous pouvez toujours utiliser une tranche, comme dans x.ljust(n)[:n]).

Il existe une autre méthode, str.zfill(), qui comble une chaîne numérique à gauche avec des zéros. Elle comprend les signes plus et moins :

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

L’utilisation de base de la méthode str.format() ressemble à cela :

>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"

Les accolades et les caractères qu’ils contiennent (appelés les champs de formatage) sont remplacés par les objets passés en paramètres à la méthode str.format(). Un nombre entre accolades se réfère à la position de l’objet passé à la méthode str.format().

>>> print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
>>> print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam

Si des arguments nommés sont utilisés dans la méthode str.format(), leurs valeurs sont utilisées en se basant sur le nom des arguments :

>>> print('This {food} is {adjective}.'.format(
...       food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.

Les arguments positionnés et nommés peuvent être combinés arbitrairement :

>>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
                                                       other='Georg'))
The story of Bill, Manfred, and Georg.

'!a' (appliquer ascii()), '!s' (appliquer str()) et '!r' (appliquer repr())peuvent être utilisées pour convertir les valeurs avant leur formatage :

>>> import math
>>> print('The value of PI is approximately {}.'.format(math.pi))
The value of PI is approximately 3.14159265359.
>>> print('The value of PI is approximately {!r}.'.format(math.pi))
The value of PI is approximately 3.141592653589793.

Des caractères ':' suivis d’une spécification de formatage peuvent suivre le nom du champ. Ceci offre un niveau de contrôle plus fin sur la façon dont les valeurs sont formatées. L’exemple suivant arrondit Pi à trois décimales :

>>> import math
>>> print('The value of PI is approximately {0:.3f}.'.format(math.pi))
The value of PI is approximately 3.142.

Indiquer un entier après le ':' indique la largeur minimale de ce champ en nombre de caractères. C’est utile pour faire de jolis tableaux :

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, phone))
...
Jack       ==>       4098
Dcab       ==>       7678
Sjoerd     ==>       4127

Si vous avez vraiment une longue chaîne de formatage que vous ne voulez pas découper, ce serait bien de pouvoir référencer les variables à formater par leur nom plutôt que par leur position. Cela peut être fait simplement en passant un dictionnaire et en utilisant des crochets '[]' pour accéder aux clés :

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
...       'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

On pourrait également faire ça en passant le tableau comme des arguments nommés en utilisant la notation “**”

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

C’est particulièrement utile en combinaison avec la fonction native vars(), qui retourne un dictionnaire contenant toutes les variables locales.

Pour avoir une vue complète du formatage des chaînes de caractères avec la méthode str.format(), voyez : Syntaxe de formatage de chaîne.

7.1.1. Anciennes méthodes de formatage de chaînes

L’opérateur % peut aussi être utilisé pour formater des chaînes. Il interprète l’argument de gauche un peu comme une chaîne de formatage d’une fonction sprintf() à appliquer à l’argument de droite, et retourne la chaîne résultant de cette opération de formatage. Par exemple :

>>> import math
>>> print('The value of PI is approximately %5.3f.' % math.pi)
The value of PI is approximately 3.142.

Vous trouverez plus d’informations dans la section Formattage de chaines à la printf.

7.2. Lecture et écriture de fichiers

open() retourne un objet fichier, et est le plus souvent utilisé avecdeux arguments : open(filename, mode).

>>> f = open('workfile', 'w')

Le premier argument est une chaîne contenant le nom du fichier. Le second argument est une autre chaîne contenant quelques caractères décrivant la façon dont le fichier sera utilisé. mode peut être 'r' quand le fichier ne sera accédé qu’en lecture, 'w' en écriture seulement (un fichier existant portant le même nom sera alors écrasé), et 'a' ouvre le fichier en mode ajout (toute donnée écrite dans le fichier est automatiquement ajoutée à la fin). 'r+' ouvre le fichier en mode lecture/écriture. L’argument mode est optionnel ; sa valeur par défaut est 'r'.

Normally, files are opened in text mode, that means, you read and write strings from and to the file, which are encoded in a specific encoding (the default being UTF-8). 'b' appended to the mode opens the file in binary mode: now the data is read and written in the form of bytes objects. This mode should be used for all files that don’t contain text.

En mode texte, le comportement par défaut, à la lecture, est de convertir les fin de lignes spécifiques à la plateforme (\n sur Unix, \r\n sur windows etc…) en simples \n. Lors de l’écriture, le comprennent par défaut est d’appliquer l’opération contraire : les \n sont convertis dans leur équivalent sur la plateforme courante. Ces modifications effectuées automatiquement sont normales pour du texte mais détérioreraient des données binaires comme un fichier JPEG ou EXE. Soyez particulièrement attentifs à ouvrir ces fichiers binaires en mode binaire.

7.2.1. Méthodes des objets fichiers

Les derniers exemples de cette section supposeront qu’un objet fichier appelé f a déjà été créé.

To read a file’s contents, call f.read(size), which reads some quantity of data and returns it as a string or bytes object. size is an optional numeric argument. When size is omitted or negative, the entire contents of the file will be read and returned; it’s your problem if the file is twice as large as your machine’s memory. Otherwise, at most size bytes are read and returned. If the end of the file has been reached, f.read() will return an empty string ('').

>>> f.read()
'This is the entire file.\n'
>>> f.read()
''

f.readline() lit une seule ligne du fichier ; un caractère de fin de ligne (\n) est laissé à la fin de la chaîne, et n’est omis que sur la dernière ligne du fichier si celui-ci ne se termine pas un caractère de fin de ligne. Ceci permet de rendre la valeur de retour non ambigüe : si f.readline() retourne une chaîne vide, c’est que la fin du fichier a été atteinte, alors qu’une ligne vide est représentée par '\n', une chaîne de caractères ne contenant qu’une fin de ligne.

>>> f.readline()
'This is the first line of the file.\n'
>>> f.readline()
'Second line of the file\n'
>>> f.readline()
''

Une autre approche de lecture des lignes est de faire une boucle sur l’objet fichier. Cela est plus efficace en terme de gestion mémoire, plus rapide, et donne un code plus simple :

>>> for line in f:
...     print(line, end='')
...
This is the first line of the file.
Second line of the file

Pour lire toutes les lignes d’un fichier, il est aussi possible d’utiliser list(f) ou f.readlines().

f.write(string) écrit le contenu de string dans le fichier, et renvoie le nombre de caractères écrits.

>>> f.write('This is a test\n')
15

To write something other than a string, it needs to be converted to a string first:

>>> value = ('the answer', 42)
>>> s = str(value)
>>> f.write(s)
18

f.tell() retourne un entier indiquant la position actuelle dans le fichier, mesurée en octets à partir du début du fichier, lorsque le fichier est ouvert en mode binaire, ou un nombre obscure en mode texte.

Pour modifier la position dans le fichier, utilisez f.seek(offset, from_what). Laposition est calculée en ajoutant offset à un point de référence ; ce point de référence est sélectionné par l’argument from_what : 0 pour le début du fichier, 1 pour la position actuelle, et 2 pour la fin du fichier. from_what peut être omis et sa valeur par défaut est 0, utilisant le début du fichier comme point de référence :

>>> f = open('workfile', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # Go to the 6th byte in the file
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # Go to the 3rd byte before the end
13
>>> f.read(1)
b'd'

Sur un fichier en mode texte (ceux ouverts sans b dans le mode), seuls les changements de position relatifs au début du fichier sont autorisés (sauf une exception : se rendre à la fin du fichier avec seek(0, 2)) et les seuls valeurs possible pour le paramètre offset sont les valeurs renvoyées par f.tell(), ou zéro. Toute autre valeur pour le paramètre offset engendrera un comportement indéfini.

Quand vous avez terminé d’utiliser un fichier, appeler f.close() pour le fermer et libérer toutes les ressources système qu’il a pu utiliser. Après l’appel de f.close(), toute tentative d’utilisation de l’objet fichier échouera systématiquement :

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file

C’est une bonne pratique d’utiliser le mot-clé with lorsque vous traitez des fichiers. Ceci procure l’avantage de toujours fermer correctement le fichier, même si une exception a été déclenchée. C’est aussi beaucoup plus court que d’utiliser l’équivalent avec des blocs try- finally

>>> with open('workfile', 'r') as f:
...     read_data = f.read()
>>> f.closed
True

Les fichiers disposent de méthodes supplémentaires, telles que isatty() et truncate() qui sont moins souvent utilisées ; consultez la Référence de la Bibliothèque Standard pour avoir un guide complet des objets fichiers.

7.2.2. Sauvegarder des données structurées avec le module json

Les chaînes de caractères peuvent facilement être écrites dans un fichier et relues. Les nombres nécessitent un peu plus d’efforts, car la méthode read() ne retourne que des chaînes, qui doivent donc être passées à une fonction comme int(), qui prend une chaîne comme '123' en entrée et retourne sa valeur numérique 123. Mais dès que vous voulez enregistrer des types de données plus complexes comme des listes, des dictionnaires ou des instances de classes, les choses se compliquent beaucoup plus.

Plutôt que de passer son temps à écrire et déboguer du code permettant de sauvegarder des types de données compliquées, Python permet d’utiliser JSON (JavaScript Object Notation), un format répandu de représentation et d’échange de données. Le module standard appellé json peut transformer des hiérarchies de données Python en leur représentation sous forme de chaîne de caractère. Ce processus est nommé sérialiser. Reconstruire les données à partir de leur représentation sous forme de chaîne est appelé déserialiser. Entre sa serialisation et sa déserialisation, la chaîne représentant les données peuvent avoir été stockées ou transmises à une autre machine.

Note

Le format JSON se retrouve communément dans les applications modernes pour échanger des données. Beaucoup de développeurs sont déjà familier avec le JSON, en faisant un format de prédilection pour l’interopérabilité.

Si vous avez un objet x, vous pouvez simplement voir sa représentation JSON

>>> json.dumps([1, 'simple', 'list'])
'[1, "simple", "list"]'

Une variation de la fonction dumps(), nommée dump(), sérialise simplement l’objet donné vers un fichier texte. Donc si f est un fichier texte ouvert en écriture, il devient possible de faire :

json.dump(x, f)

Pour reconstruire l’objet, si f est cette fois un fichier texte ouverten lecture :

x = json.load(f)

Cette méthode de serialisation peut sérialiser des listes et des dictionnaires, mais sérialiser d’autres types de données nécessité un peu plus de travail. La documentation du module json explique comment faire.

Voir aussi

Le module pickle

À l’inverse de JSON, pickle est un protocole permettant la serialisation d’objets Python arbitrairement complexes. Il est donc spécifique à Python et ne peut être utilisé pour communiquer avec d’autres langages. Il n’est aussi pas sans failles : desérialiser des données au format pickle provenant d’une source malveillante et particulièrement habile pourrait mener exécuter du code arbitraire.