7. Les entrées/sorties
**********************

Il existe bien des moyens de présenter les sorties d’un programmes ;
les données peuvent être affichées sous une forme lisible par un être
humain ou sauvegardées dans un fichier pour une utilisation future. Ce
chapitre présente quelques 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 l’instruction "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.)

Mais vous voudrez souvent avoir plus de contrôle sur le formatage de
vos sorties que de simplement imprimer des valeurs séparées par des
espaces. Il y a deux méthodes pour formater ces sorties ; la première
est de gérer les chaînes de caractères par vous même ; en utilisant
des tranches sur vos chaînes et des opérations de concaténation, vous
pouvez créer n’importe quelle présentation imaginable. Mais les
chaînes de caractères disposent également de méthodes qui facilitent,
par exemple, les alignements de chaînes de caractères selon une
certaines largeur de colonne, et qui seront présentées rapidement. La
seconde méthode consiste à utiliser la méthode "format()".

Le module "string" contient une classe "Template" qui permet aussi 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.0/7.0)
   '0.142857142857'
   >>> repr(1.0/7.0)
   '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),
   ...     # Note trailing comma 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

(Note that in the first example, one space between each column was
added by the way "print" works: by default it adds spaces between its
arguments.)

Cet exemple illustre l’utilisation de la méthode "str.rjust()" des
chaînes de caractères ; elle justifie à droite 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 renvoient 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 ; cela peut chambouler
votre mise en page mais c’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 à ceci :

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

Les crochets 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 crochets 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.

"'!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.

Un caractère "':'" suivi 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 chiffres après la virgule (NdT : qui, en notation anglo-
saxonne, est un point).

>>> 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 une chaîne de formatage vraiment longue que vous ne
voulez pas découper, il est possible de référencer les variables à
formater par leur nom plutôt que par leur position. Utilisez
simplement un dictionnaire et la notation entre 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

Vous pouvez obtenir le même résultat 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 renvoie un dictionnaire contenant toutes les variables
locales.

Pour avoir une description complète du formatage des chaînes de
caractères avec la méthode "str.format()", lisez : 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 pratiquement comme une chaîne de
formatage de la fonction "sprintf()" à appliquer à l’argument de
droite, et il renvoie 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 String Formatting
Operations.


7.2. Lecture et écriture de fichiers
====================================

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

   >>> f = open('workfile', 'w')
   >>> print f
   <open file 'workfile', mode 'w' at 80a0960>

Le premier argument est une chaîne contenant le nom du fichier. Le
deuxième argument est une autre chaîne contenant quelques caractères
décrivant la façon dont le fichier est utilisé. *mode* peut être "'r'"
quand le fichier n’est 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'".

Sous Windows, "'b'" ajouté au mode ouvre le fichier en mode binaire,
et il existe donc des modes comme "'rb'", "'wb'" et "'r+b'". Python
sous Windows fait effectivement une distinction entre fichiers texte
et binaires ; le caractère de fin de ligne des fichiers texte est
automatiquement modifié lorsqu’une donnée est lue ou écrite. Cette
modification sous le manteau des données du fichier n’est pas un
problème pour les fichiers textes en ASCII, mais elle peut corrompre
les données binaires comme celles des fichiers "JPEG" ou "EXE". Soyez
donc attentifs à toujours bien utiliser le mode binaire lorsque vous
travaillez avec de tels fichiers. Sous Unix, le mode binaire n’a aucun
effet mais vous pouvez l’utiliser pour tous les fichiers binaires pour
que votre code soit indépendant de la plate-forme.


7.2.1. Méthodes des objets fichiers
-----------------------------------

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

Pour lire le contenu d’un fichier, appelez "f.read(size)", qui lit une
certaine quantité de données et les retourne sous la forme d’une
chaîne de caractères. *size* est un argument numérique optionnel.
Quand *size* est omis ou négatif, le contenu entier du fichier est lu
et retourné ; c’est votre problème si le fichier est deux fois plus
gros que la mémoire de votre machine. Sinon, au plus *size* octets
sont lus et retournés. Lorsque la fin du fichier est atteinte,
"f.read()" renvoie une chaîne vide ("""")

   >>> 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()
   ''

Pour lire ligne à ligne, vous pouvez aussi boucler sur l’objet
fichier. C’est plus efficace en terme de gestion mémoire, plus rapide
et donne un code plus simple :

   >>> for line in f:
           print line,

   This is the first line of the file.
   Second line of the file

Pour construire une liste avec 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 "None"

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

Pour écrire autre chose qu’une chaîne, il faut commencer par la
convertir en chaîne

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

"f.tell()" retourne un entier indiquant la position actuelle dans le
fichier, mesurée en octets à partir du début du fichier. Pour modifier
la position dans le fichier, utilisez "f.seek(offset, from_what)". La
position 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', 'r+')
   >>> f.write('0123456789abcdef')
   >>> f.seek(5)      # Go to the 6th byte in the file
   >>> f.read(1)
   '5'
   >>> f.seek(-3, 2)  # Go to the 3rd byte before the end
   >>> f.read(1)
   'd'

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 <module>
   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. Sauvegarde de 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’effort, car
la méthode "read()" ne renvoie que des chaînes. Elles doivent donc
être passées à une fonction comme "int()", qui prend une chaîne comme
"'123'" en entrée et renvoie 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, le traitement
lecture/écriture à la main devient vite compliqué.

Plutôt que de passer son temps à écrire et déboguer du code permettant
de sauvegarder des types de données compliqués, Python permet
d’utiliser JSON (JavaScript Object Notation), un format répandu de
représentation et d’échange de données. Le module standard appelé
"json" peut transformer des données hiérarchisées Python en une
représentation sous forme de chaîne de caractères. 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 sérialisation et sa dé-sérialisation, la chaîne représentant les
données peut avoir été stockée ou transmise à une autre machine.

Note: Le format JSON est couramment utilisé dans les applications
  modernes pour échanger des données. Beaucoup de développeurs le
  maîtrise, ce qui en fait un format de prédilection pour
  l’interopérabilité.

Si vous avez un objet "x", vous pouvez voir sa représentation JSON en
tapant simplement :

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

Une autre variante de la fonction "dumps()", appelée "dump()"
sérialise simplement l’objet dans un fichier.  Donc si "f" est un
*file object* ouvert en écriture, on peut faire :

   json.dump(x, f)

Pour décoder l’objet à nouveau, si "f" est un *file object* ouvert en
lecture :

   x = json.load(f)

Cette méthode de sérialisation peut sérialiser des listes et des
dictionnaires. Mais sérialiser d’autres types de données requiert un
peu plus de travail. La documentation du module "json" explique
comment faire.

Voir aussi: Le module "pickle"

  Au contraire de JSON, *pickle* est un protocole permettant la
  sérialisation d’objets Python arbitrairement complexes. Il est donc
  spécifique à Python et ne peut pas être utilisé pour communiquer
  avec d’autres langages. Il est aussi, par défaut, une source de
  vulnérabilité : dé-sérialiser des données au format *pickle*
  provenant d’une source malveillante et particulièrement habile peut
  mener à exécuter du code arbitraire.
