 |
 |
 |
Tutoriel Python |  |
 |
|
Il y a plusieurs manières de présenter l'affichage produit par un programme; les données peuvent être imprimées sous une forme humainement lisible, ou être écrites dans un fichier pour un usage ultérieur. Ce chapitre présentera certaines de ces possibilités.
Jusqu'ici nous avons rencontré deux manières d'afficher des valeurs: les instructions d'expression et l'instruction print. (Une troisième manière est d'utiliser la méthode write() des objets fichier; le fichier de sortie standard peut être référencé par sys.stdout. Voyez le manuel Library Reference pour plus d'informations.)
Vous souhaiterez souvent avoir plus de contrôle sur le formatage de vos sorties que d'imprimer simplement des valeurs séparées par des espaces. Il y a deux manières de formater vos sorties; la première manière est de faire toutes les manipulations de chaînes de caractères vous-même; en utilisant les opérations de concaténation et de découpage de chaînes de caractères, vous pouvez créer n'importe quel format que vous puissiez imaginer. Le module standard string contient quelques opérations utiles pour remplir des chaînes de caractères à une largeur de colonne donnée; celles-ci seront discutées sous peu. La deuxième manière est d'utiliser l'opérateur % avec une chaîne de caractères comme argument de gauche, % interprète l'argument de gauche comme une chaîne de formatage comme pour la fonction sprintf() du langage C à appliquer à l'argument de droite, et retourne une chaîne de caractères résultant de cette opération de formatage.
Il reste naturellement une question: comment convertissez-vous des valeurs en chaînes de caractères? Heureusement, Python a un moyen de convertir n'importe quelle valeur en chaîne de caractères: passez-la à la fonction repr(), ou écrivez juste la valeur entre des guillemets renversés (anti-quotes: ``). Quelques exemples:
>>> x = 10 * 3.14
>>> y = 200*200
>>> s = 'La valeur de x est ' + `x` + ', et y est ' + `y` + '...'
>>> print s
La valeur de x est 31.4, et y est 40000...
>>> # Les anti-quotes marchent avec d'autres types en dehors des nombres:
... p = [x, y]
>>> ps = repr(p)
>>> ps
'[31.4, 40000]'
>>> # Convertir une chaîne ajoute des quotes de chaîne et des antislash:
... salut = 'salut, monde\n'
>>> saluts = `salut`
>>> print saluts
'salut, monde\012'
>>> # L'argument des anti-quotes peut être un tuple:
... `x, y, ('spam', 'eggs')`
"(31.4, 40000, ('spam', 'eggs'))"
Voici deux manières d'écrire une table des carrés et des cubes:
>>> import string >>> for x in range(1, 11): ... print string.rjust(`x`, 2), string.rjust(`x*x`, 3), ... # Notez la virgule à la fin de la ligne précédente ... print string.rjust(`x*x*x`, 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'%2d %3d %4d' % (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 qu'un espace entre chaque colonne a été ajouté à cause de la façon dont print fonctionne: elle ajoute toujours des espaces entre ses arguments.)
Cet exemple présente la fonction string.rjust(), qui justifie à droite une chaîne de caractères dans un champ d'une largeur donnée en la complétant avec des espaces du côté gauche. Il y a les fonctions semblables string.ljust() et string.center(). Ces fonctions n'écrivent rien, elles renvoient juste une nouvelle chaîne de caractères. Si la chaîne de caractères d'entrée est trop longue, elles ne la tronquent pas, mais la renvoient sans changement; ceci gâchera votre présentation de colonne mais c'est habituellement mieux que l'alternative, qui serait de tricher au sujet d'une valeur. (Si vous voulez vraiment la troncature vous pouvez toujours ajouter une opération de découpage, comme "string.ljust(x, n)[0:n]".)
Il y a une autre fonction, string.zfill(), qui complète une chaîne de caractères numérique du côté gauche avec des zéros. Elle sait gérer les signes positifs et négatifs :
>>> string.zfill('12', 5)
'00012'
>>> string.zfill('-3.14', 7)
'-003.14'
>>> string.zfill('3.14159265359', 5)
'3.14159265359'
>>> import math >>> print 'La valeur de PI est approximativement %5.3f.' % math.pi La valeur de PI est approximativement 3.142.
S'il y a plus d'un descripteur de format dans la chaîne de caractères, vous passez un tuple comme opérande de droite, par exemple.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> for nom, telephone in table.items():
... print'%-10s ==> %10d' % (nom, telephone)
...
Jack ==> 4098
Dcab ==> 8637678
Sjoerd ==> 4127
La plupart des formats fonctionnent exactement comme en C et exigent que vous passiez le type approprié; cependant, si vous ne le faites pas vous obtenez une exception, pas un core dump. Le format de %s est moins strict : si l'argument correspondant n'est pas un objet chaîne de caractères, il est converti en chaîne de caractères en utilisant la fonction intégrée str(). Utiliser *pour passer la largeur ou la précision comme argument (entier) séparé est possible. Les formats %n et %p du C ne sont pas supportés. Si vous avez une chaîne de caractères de formatage vraiment longue que vous ne voulez pas fractionner, il serait élégant de pouvoir référencer les variables à formater par leur nom et pas par leur position. Ceci peut être fait en utilisant une extension des formats du C en utilisant la forme %(name)format, par exemple.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print 'Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d' % table
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
C'est particulièrement utile en combinaison avec la fonction intégrée vars(), qui renvoie un dictionnaire contenant toutes les variables locales.
open() renvoie un objet de type fichier, et est utilisée plus généralement avec deux arguments: "open(nomfichier, mode)".
>>> f=open('/tmp/fichiertravail', 'w')
>>> print f
<open file '/tmp/fichiertravail', mode 'w' at 80a0960>
Le premier argument est une chaîne de caractères contenant le nom du fichier. Le deuxième argument est une autre chaîne de caractères contenant quelques caractères décrivant la manière d'utiliser le fichier. mode vaut 'r' quand le fichier doit être seulement lu, 'w' pour seulement écrit (un fichier déjà existant avec le même nom sera effacé), et 'a' ouvre le fichier en ajout; les données écrites dans le fichier seront automatiquement ajoutées à la fin. 'r+' ouvre le fichier pour la lecture et l'écriture. L'argument mode est facultatif; 'r' sera pris par défaut s'il est omis.
Sur Windows et Macintosh, 'b' ajouté au mode ouvre fichier en mode binaire, donc il y a aussi des modes comme 'rb', 'wb', et 'r+b'. Windows fait la distinction entre fichier texte et binaire ; les caractères de fin de ligne dans des fichiers texte sont automatiquement modifiés légèrement quand des données sont lues ou écrites. Cette modification imperceptible des données du fichier marche très bien pour des fichiers textes ASCII, mais elle altèrera des données binaires comme dans des fichiers JPEG ou .EXE. Faites très attention à utiliser le mode binaire en lisant et en écrivant de tels fichiers. (notez que la sémantique précise du mode texte sur le Macintosh dépend de la bibliothèque C utilisée.)
Le reste des exemples dans cette section supposera qu'un objet fichier appelé f a déjà été créé.
Pour lire le contenu d'un fichier, appeler f.read(taille), qui lit une certaine quantité de données et les retourne en tant que chaîne de caractères. taille est un argument numérique facultatif. Quand taille est omis ou négatif, le contenu entier du fichier sera lu et retourné; c'est votre problème si le fichier est deux fois plus grand que la mémoire de votre machine. Autrement, au plus taille octets sont lus et retournés. Si la fin du fichier a été atteinte, f.read()renverra une chaîne de caractères vide ("").
>>> f.read() 'Ceci est le fichier entier.\012' >>> f.read() ''
f.readline() lit une seule ligne à partir du fichier; un caractère de fin de ligne (\n) est laissé à l'extrémité de la chaîne de caractères lue, et est seulement omis sur la dernière ligne du fichier si le fichier ne se termine pas par une fin de ligne. Ceci rend la valeur de retour non ambiguë; si f.readline() renvoie une chaîne de caractères vide, la fin du fichier a été atteinte, alors qu'une fin de ligne est représentée par '\n', une chaîne de caractères contenant seulement une seule fin de ligne.
>>> f.readline() 'Ceci est la première ligne du fichier.\012' >>> f.readline() 'Deuxième ligne du fichier\012' >>> f.readline() ''
f.readlines() utilise f.readline() de façon répétitive, et retourne une liste contenant toutes les lignes de données du fichier.
>>> f.readlines() ['Ceci est la première ligne du fichier.\012', 'Deuxième ligne du fichier\012']
f.write(chaine) écrit le contenu de chaine dans le fichier, en retournant None.
>>> f.write('Voici un test\n')
f.tell() renvoie un nombre entier donnant la position actuelle dans le fichier associé à l'objet fichier, mesurée en octets depuis le début du fichier. Pour changer la position dans l'objet fichier, employez "f.seek(decalage, point_depart)". La position est calculée en ajoutant decalage à un point de référence; le point de référence est choisi par l'argument point_depart. Une valeur de 0 pour point_depart fait démarrer au début du fichier, 1 utilise la position courante du fichier, et 2 utilise la fin de fichier comme point de référence. point_depart peut être omis et prend alors 0 pour valeur par défaut comme point de référence.
>>> f=open('/tmp/fichiertravail', 'r+')
>>> f.write('0123456789abcdef')
>>> f.seek(5) # Saute jusqu'au 5ème octet dans le fichier
>>> f.read(1)
'5'
>>> f.seek(-3, 2) # Saute jusqu'au 3ème octet avant la fin
>>> f.read(1)
'd'
Quand vous en avez terminé avec un fichier, appeler f.close()pour le fermer et libérer toutes les ressources système utilisées par le fichier ouvert. Après avoir appelé f.close(), les tentatives d'utiliser l'objet fichier échoueront automatiquement.
>>> f.close() >>> f.read() Traceback (innermost last): File "<stdin>", line 1, in ? ValueError: I/O operation on closed file
Les objets fichier ont quelques méthodes supplémentaires, telles que isatty() et truncate() qui sont moins fréquemment utilisées; consultez la Library Reference pour un guide complet des objets fichier.
Les chaînes de caractères peuvent facilement être écrites et lues dans un fichier. Les nombres demandent un peu plus d'effort, puisque la méthode read() renvoie seulement les chaînes de caractères, qui devront être passées vers une fonction comme string.atoi(), qui prend une chaîne de caractères comme '123' et renvoie sa valeur numérique 123. Cependant, quand vous voulez sauvegarder des types de données plus complexes comme des listes, des dictionnaires, ou des instances de classe, les choses deviennent beaucoup plus compliquées.
Plutôt que faire écrire et déboguer constamment par les utilisateurs le code pour sauvegarder des types de données complexes, Python fournit un module standard appelé pickle. C'est un module étonnant qui peut prendre presque n'importe quel objet Python (même quelques formes de code Python!), et le convertir en une représentation sous forme de chaîne de caractères; ce processus s'appelle pickling. Reconstruire l'objet à partir de sa représentation en chaîne de caractères s'appelle unpickling. Entre pickling et unpickling, la chaîne de caractères représentant l'objet a pu avoir été enregistrée dans un fichier ou des données, ou avoir été envoyée à une machine éloignée via une connexion réseau.
Si vous avez un objet x, et un objet fichier f ouvert en écriture, la voie la plus simple de ``pickler'' l'objet prend seulement une ligne de code:
pickle.dump(x, f)
Pour ``unpickler'' l'objet, si f est un objet fichier ouvert en lecture:
x = pickle.load(f)
(il y a d'autres variantes pour ceci, utilisées pour ``pickler'' beaucoup d'objets ou quand vous ne voulez pas écrire les données ``picklées'' dans un fichier; consultez la documentation complète pour pickle dans la Library Reference.)
pickle est le moyen standard pour enregistrer des objets Python et les réutiliser dans d'autres programmes ou dans une future invocation du même programme; le terme technique pour ceci est la persistance d'un objet. Puisque pickle est très largement répandu, beaucoup d'auteurs qui écrivent des extensions pour Python prennent soin de s'assurer que de nouveaux types de données tels que des matrices peuvent être correctement ``picklés'' et ``unpicklés''.