Tut Oriel Python

Tutoriel Python
Release 2.4.3
Guido van Rossum Fred L. Drake, Jr., editor
19 juillet 2006
Traduction franaise dirige par Olivier Berger Mise jour par Henri Garreta
Python Software Foundation E-mail: docs@python.org
Copyright c 2001-2005 Python Software Foundation. All Rights Reserved. Copyright c 2000 BeOpen.com. All Rights Reserved. Copyright c 1995-2000 Corporation for National Research Initiatives. All Rights Reserved. Copyright c 1991-1995 Stichting Mathematisch Centrum. All Rights Reserved. See the end of this document for complete license and permissions information.
Rsum Python est un langage de programmation facile utiliser et puissant. Il offre des structures de donnes puissantes de haut niveau et une approche simple mais relle de la programmation oriente-objet. La syntaxe lgante de python et le typage dynamique, ajouts sa nature interprte, en font un langage idal pour crire des scripts et pour le dveloppement rapide dapplications dans de nombreux domaines et sur la plupart des plates-formes. Linterprteur python et la vaste librairie standard sont librement disponible pour toutes les plates-formes principales sous forme de sources ou de binaires partir du site Web de Python, http ://www.python.org/, et peuvent tre distribus librement. Le mme site contient aussi des distributions et des pointeurs vers de nombreux modules Python provenant dautres fournisseurs, des programmes et des outils, et de la documentation supplmentaire. Linterprteur Python est facilement extensible par de nouvelles fonctions et de nouveaux types de donnes implments en C ou en C++ (ou dautres langages appelables depuis le C). Python convient galement comme langage dextension pour des logiciels congurables. Ce tutoriel introduit le lecteur de faon informelle aux concepts et caractristiques de base du langage et du systme Python. Il est utile davoir un interprteur Python disponible pour exprimenter directement, mais tous les exemples sont auto-porteurs, donc le tutoriel peut galement tre lu sans interprteur sous la main. Pour une description des objets et modules standards, voir le document Python Library Reference. Le Python Reference Manual donne une dnition plus formelle du langage. Pour crire des extensions en C ou C++, lire les manuels Extending and Embedding et Python/C API Reference. Il existe aussi plusieurs livres dcrivant Python en profondeur. Ce tutoriel nessaye pas dtre complet et de traiter chaque possibilit, ou mme toutes les caractristiques utilises couramment. A la place, il prsente bon nombre des caractristiques les plus remarquables de Python, et vous donnera une bonne ide de la couleur et du style du langage. Aprs lavoir lu, vous serez capable de lire et dcrire des programmes ou des modules en Python, et vous serez prts en apprendre plus sur les diffrents modules de bibliothques Python dcrits dans le Python Library Reference.
TABLE DES MATIRES
1 2
Pour vous mettre en apptit Utilisation de linterprteur Python 2.1 Lancement de linterprteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Linterprteur et son environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Une introduction informelle Python 3.1 Utiliser Python comme calculatrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Premiers pas vers la programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dautres outils de contrle dexcution 4.1 Instructions if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Instructions for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3 La fonction range() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4 Les instructions break et continue, et les clauses else dans les boucles 4.5 LInstruction pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.6 Dnition de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.7 Encore plus sur la dnition de fonctions . . . . . . . . . . . . . . . . . . . Structures de donnes 5.1 Plus de dtails sur les listes . . . . . . . 5.2 Linstruction del . . . . . . . . . . . . 5.3 N-uplets (tuples) et squences . . . . . . 5.4 Ensembles . . . . . . . . . . . . . . . . 5.5 Dictionnaires . . . . . . . . . . . . . . . 5.6 Techniques de boucles . . . . . . . . . . 5.7 Plus de dtails sur les conditions . . . . 5.8 Comparer les squences et dautres types Modules 6.1 Encore plus sur les modules 6.2 Modules standard . . . . . 6.3 La fonction dir() . . . . 6.4 Paquetages . . . . . . . . .
7 9 9 10 13 13 22 25 25 25 26 26 27 27 29 35 35 39 39 40 41 42 43 43 45 46 47 48 49 53 53 56 59 59 59 60 62
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
Entres et sorties 7.1 Un formatage de sortie plus fantaisiste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2 Lire et crire des chiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Erreurs et exceptions 8.1 Erreurs de syntaxe . . . . 8.2 Exceptions . . . . . . . . 8.3 Gestion des exceptions . 8.4 Dclencher des exceptions
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
8.5 8.6 9
Exceptions dnies par lutilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dnir les actions de nettoyage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
62 64 65 65 65 67 69 71 72 72 73 74 75 76 77 77 77 78 78 78 78 79 79 80 80 81 81 83 83 84 85 85 86 87 87 88 91 93 93 93 93 95 97 99
Classes 9.1 Un mot sur la terminologie . . . . . . . . . 9.2 Les portes et les espaces de noms en Python 9.3 Une premire approche des classes . . . . . 9.4 Quelques remarques . . . . . . . . . . . . . 9.5 Hritage . . . . . . . . . . . . . . . . . . . 9.6 Variables prives . . . . . . . . . . . . . . . 9.7 En vrac . . . . . . . . . . . . . . . . . . . . 9.8 Les exceptions sont des classes aussi . . . . 9.9 Itrateurs . . . . . . . . . . . . . . . . . . . 9.10 Gnrateurs . . . . . . . . . . . . . . . . . . 9.11 Expressions gnrateurs . . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
10 Petit tour dans la bibliothque standard 10.1 Interface avec le systme dexploitation . . . . . . . . 10.2 Fichiers et jokers . . . . . . . . . . . . . . . . . . . . 10.3 Arguments de la ligne de commande . . . . . . . . . 10.4 Redirection de la sortie et terminaison du programme . 10.5 Appariement de chanes . . . . . . . . . . . . . . . . 10.6 Mathmatiques . . . . . . . . . . . . . . . . . . . . . 10.7 Accs Internet . . . . . . . . . . . . . . . . . . . . 10.8 Dates et heures . . . . . . . . . . . . . . . . . . . . . 10.9 Compression de donnes . . . . . . . . . . . . . . . . 10.10 Mesure des performances . . . . . . . . . . . . . . . 10.11 Contrle de qualit . . . . . . . . . . . . . . . . . . . 10.12 Les piles sont fournies avec lappareil . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
11 Petit tour dans la bibliothque standard - Deuxime partie 11.1 Mise en forme des sorties . . . . . . . . . . . . . . . . 11.2 Modles . . . . . . . . . . . . . . . . . . . . . . . . . 11.3 Travail avec des enregistrements binaires . . . . . . . . 11.4 Multi-threading . . . . . . . . . . . . . . . . . . . . . . 11.5 Journalisation . . . . . . . . . . . . . . . . . . . . . . . 11.6 Rfrences faibles . . . . . . . . . . . . . . . . . . . . 11.7 Outils pour travailler avec des listes . . . . . . . . . . . 11.8 Arithmtique dcimale virgule ottante . . . . . . . . 12 Et maintenant ? A Edition dentre interactive et substitution historique A.1 Edition de ligne . . . . . . . . . . . . . . . . . . A.2 Substitution historique . . . . . . . . . . . . . . . A.3 Dnition des touches . . . . . . . . . . . . . . . A.4 Commentaire . . . . . . . . . . . . . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
B Arithmtique virgule ottante : problmes et limites B.1 Erreur de reprsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
C Historique et licence 101 C.1 Histoire de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 C.2 Terms and conditions for accessing or otherwise using Python . . . . . . . . . . . . . . . . . . . 102 C.3 Licenses and Acknowledgements for Incorporated Software . . . . . . . . . . . . . . . . . . . . 104 D Glossaire 111
ii
CHAPITRE
UN
Pour vous mettre en apptit

Si vous avez jamais crit un long script shell, vous connaissez probablement ce sentiment : vous aimeriez ajouter encore une autre fonctionnalit, mais il est dj tellement lent, et tellement gros, et si compliqu ; ou bien la fonctionnalit requiert un appel systme ou une autre fonction qui est accessible seulement en C. . . Habituellement, le problme rsoudre nest pas sufsamment grave pour justier une rcriture du script en C ; peut-tre que le problme requiert des chanes de caractres de longueur variable ou dautres types de donnes (comme des listes tries de noms de chiers) qui sont faciles faire en shell mais ncessitent beaucoup deffort dimplmentation en C, ou peut-tre ntes-vous pas sufsamment familier avec le C. Une autre situation : peut-tre devez-vous travailler avec plusieurs bibliothques C, et le cycle habituel en C crire, compiler, tester, re-compiler est trop lent. Vous avez besoin de dvelopper du logiciel plus rapidement. Ou alors, peut-tre avez-vous crit un programme qui pourrait utiliser un langage dextension, et vous ne voulez pas dnir un langage, crire et mettre au point un interprteur pour lui, puis le lier votre application. Dans toutes ces situations, Python pourrait tre le langage quil vous faut. Python est simple demploi, mais cest un vrai langage de programmation, qui offre bien plus de structure et de de possibilits que le shell pour des programmes volumineux. Dautre part, il offre galement beaucoup plus de vrication derreurs que le C, et, tant un langage de trs haut niveau, il contient des types de donnes de haut niveau intgrs, comme des tableaux redimensionnables et des dictionnaires, qui vous demanderaient des jours implmenter efcacement en C. Grce ses types de donnes plus gnraux, Python est applicable un domaine de problmes beaucoup plus large que Awk ou mme Perl, et de nombreuses choses sont au moins aussi faciles en Python que dans ces langages. Python vous permet de sparer vos programmes en modules qui peuvent tre rutiliss dans dautres programmes en Python. Il est fourni avec une vaste collection de modules standard que vous pouvez utiliser comme base pour vos programmes ou comme exemples pour sinitier la programmation en Python. Il y a aussi des modules intgrs qui fournissent des fonctionnalits comme les entres/sorties vers les chiers, les appels systmes, les sockets, et mme des interfaces avec les toolkits dInterface Homme Machine comme Tk. Python est un langage interprt, ce qui peut vous faire gagner un temps considrable pendant la ralisation de programmes car aucune compilation ou dition de liens nest ncessaire. Linterprteur peut tre utilis de faon interactive, ce qui facilite lexprimentation avec les possibilits du langage, lcriture de programmes jetables, ou le test de fonctions pendant le dveloppement ascendant de vos logiciels. Cest aussi une calculatrice de bureau assez pratique. Python permet dcrire des programmes trs compacts et lisibles. Les programmes crits en Python sont typiquement beaucoup plus courts que leurs quivalents en C, pour plusieurs raisons : les types de donnes de haut niveau vous permettent de raliser des oprations complexes en une seule instruction ; le regroupement des instructions se fait par indentation, sans accolades de dbut/n ; il nest pas ncessaire de dclarer les variables ou les arguments. Python est extensible : si vous savez programmer en C, il est facile dajouter une nouvelle fonction intgre ou un module dans linterprteur, soit pour raliser les oprations critiques vitesse maximum, soit pour linker les programmes en Python des bibliothques qui ne sont disponibles que sous forme binaire (comme une bibliothque graphique propritaire). Une fois que vous serez accro, vous pourrez linker linterprteur Python dans votre application crite en C et lutiliser comme langage dextension ou de commande pour cette application.
Au passage, le langage est nomm daprs lmission de la BBC Monty Pythons Flying Circus et na rien voir avec de vilains reptiles. Faire rfrence des dialogues des Monty Python dans la documentation nest pas seulement autoris, cest encourag ! Maintenant que vous tes tout excit par Python, vous voudrez lexaminer plus en dtail. Puisque la meilleure faon dapprendre un langage est de lutiliser, vous tes invit le faire ds maintenant. Dans le chapitre suivant, les lments ncessaires lutilisation de linterprteur sont expliqus. Ce sont des informations plutt rbarbatives, mais essentielles pour pouvoir tester les exemples donns plus loin. Le reste de ce tutoriel introduit les diffrentes caractristiques du langage et du systme Python travers des exemples, en commenant par les expressions, instructions et types de donnes simples, puis les fonctions et modules, et enn en survolant des concepts avancs comme les exceptions et les classes dnies par lutilisateur.
Chapitre 1. Pour vous mettre en apptit
CHAPITRE
DEUX
Utilisation de linterprteur Python

2.1 Lancement de linterprteur
Linterprteur Python est habituellement install lemplacement /usr/local/bin/python sur les machines Unix sur lesquelles il est disponible ; placer /usr/local/bin dans le path de votre shell U NIX permet de le lancer en tapant la commande
python
sous le shell. Puisque le choix du rpertoire dans lequel est install linterprteur est une option dinstallation, dautres endroits sont possibles ; vriez avec votre gourou Python local ou votre administrateur systme. (Par exemple, /usr/local/python est un autre emplacement populaire.) Tapez le caractre de n-de-chier (Control-D sur U NIX, Control-Z sur DOS ou Windows) linvite (prompt) principale pour quitter linterprteur avec un code de retour de zro. Si a ne marche pas, vous pouvez quitter linterprteur en tapant les commandes suivantes : import sys ; sys.exit(). Les fonctions ddition de ligne de linterprteur ne sont habituellement pas trs sophistiques. Sur U NIX, celui qui a install linterprteur peut avoir activ le support de la bibliothque GNU Readline, qui ajoute une dition interactive plus labore et des fonctions dhistorique. Peut-tre la vrication la plus rapide pour savoir si ldition de ligne de commande est supporte consiste taper Control-P au premier prompt afch par Python. Si a fait un bip, vous disposez de ldition de ligne de commande ; voir lAnnexe A pour une introduction aux touches. Si rien ne semble se passer, ou si ^P est afch, ldition de ligne de commande nest pas disponible ; vous pourrez seulement utiliser backspace pour enlever des caractres de la ligne courante. Linterprteur fonctionne en quelque sorte comme le shell U NIX : lorsquil est lanc avec lentre standard connecte un priphrique tty, il lit et excute les commandes interactivement ; lorsquil est lanc avec un nom de chier en argument ou avec un chier comme entre standard, il lit et excute un script depuis ce chier. Une deuxime faon de lancer linterprteur est python -c commande [arg] ..., ce qui excute les instructions dans commande, de faon analogue loption -c du shell. Puisque les instructions en Python contiennent souvent des espaces ou dautres caractres qui sont spciaux pour le shell, il est conseill de mettre entirement entre guillemets (doubles quotes) la commande. Notez quil y a une diffrence entre python fichier et python <fichier. Dans le second cas, les requtes en entre du programme, comme les appels input() et raw_input(), sont effectues depuis chier. Puisque ce chier a dj t lu jusqu la n par linterprteur avant que le programme ne commence sexcuter, le programme rencontrera immdiatement une n-de-chier. Dans le premier cas (qui est habituellement ce quon souhaite) les requtes sont satisfaites par lventuel chier ou priphrique qui est connect lentre standard de linterprteur Python. Lorsquun chier script est utilis, il est parfois utile de pouvoir lancer le script et de passer ensuite en mode interactif. Cela peut tre fait en passant en paramtre -i avant le script. (Cela ne marche pas si le script est lu depuis lentre standard, pour la mme raison explique dans le paragraphe prcdent.)
2.1.1
Passage de paramtres
Lorsquils sont connus de linterprteur, le nom du script et les paramtres supplmentaires sont passs au script dans la variable sys.argv, qui est une liste de chanes. Sa longueur est dau moins un ; quand aucun script ou arguments nest donn, sys.argv[0] est une chane vide. Lorsque le nom du script donn est - (cest dire lentre standard), sys.argv[0] est positionn -. Quand -c commande est utilis, sys.argv[0] est positionn -c. Les options trouves aprs -c commande ne sont pas retires par le traitement des options de linterprteur Python mais laisses dans sys.argv pour tre traites par la commande.
2.1.2
Mode interactif
Quand les commandes sont lues depuis un terminal, linterprteur fonctionne en mode interactif. Dans ce mode, il demande la commande suivante avec le prompt principal, habituellement trois signes suprieur >>> ; pour les lignes de continuation, il questionne avec le prompt secondaire, par dfaut trois points (... ). Linterprteur imprime un message de bienvenue spciant son numro de version et une notice de copyright avant dafcher le prompt principal :
python Python 1.5.2b2 (#1, Feb 28 1999, 00:02:06) [GCC 2.8.1] on sunos5 Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam >>>
Les lignes de continuation sont ncessaires lorsquon saisit une construction sur plusieurs lignes. Comme exemple, voici une instruction if :
>>> le_monde_est_plat = 1 >>> if le_monde_est_plat: ... print "Gaffe pas tomber par dessus bord!" ... Gaffe pas tomber par dessus bord!
2.2
2.2.1
Linterprteur et son environnement

Gestion des erreurs
Quand une erreur survient, linterprteur imprime un message derreur et une trace de ltat de la pile. En mode interactif, il retourne alors au prompt principal ; lorsque lentre se fait depuis un chier, il termine lexcution avec un code de sortie diffrent de zro aprs avoir imprim la trace de pile. (Les exceptions gres par une clause except dans une instruction try ne sont pas des erreurs dans ce contexte ; voir 8.2.) Certaines erreurs sont fatales dans tous les cas et causent une sortie avec un code diffrent de zro ; cela se produit pour les aberrations internes et certains cas de saturation mmoire. Tous les messages derreur sont crits sur la sortie derreur standard ; lafchage normal des commandes excutes est effectu sur la sortie standard. Taper le caractre dinterruption (habituellement Control-C ou DEL) au prompt principal ou secondaire annule la saisie et revient au prompt principal.1 Taper le caractre dinterruption pendant lexcution dune commande dclenche lexception KeyboardInterrupt, qui peut tre gre par une instruction try.
2.2.2
Scripts Python excutables
Sur les systmes U NIX la BSD, les scripts Python peuvent tre rendus directement excutables, comme les scripts shell, en plaant la ligne
1 Un
problme avec la bibliothque GNU Readline peut empcher cela.
10
Chapitre 2. Utilisation de linterprteur Python
#! /usr/bin/env python
(en supposant que linterprteur est dans le PATH de lutilisateur au lancement du script) et rendant le chier excutable. Le # ! doit correspondre aux deux premiers caractres du chier.
2.2.3
Encodage du chier source
Dans les chiers sources Python il est possible dutiliser des encodages diffrents de lASCII. La meilleure faon de le faire consiste mettre une ligne de commentaire spciale aprs la ligne #! pour dnir lencodage du chier source : # -*- coding: encoding -*Avec cette dclaration, tous les caractres dans le chier source seront traits comme ayant lencodage encoding, et il sera possibe dcrire directement des chanes littrales Unicode dans lencodage choisi. La liste des encodages possibles peut tre trouve dans Python Library Reference, dans la section sur les codecs. Par exemple, pour crire des chanes littrales Unicode incluant le symbole montaire Euro, lencodage ISO-885915 peut tre utilis, le symbole de Euro ayant le valeur ordinale 164. Le script suivant imprime la valeur 8364 (le code Unicode correspondant au symbole Euro) puis termine : # -*- coding: iso-8859-15 -*currency = u"= " C print ord(currency) Si votre diteur est capable denregistrer des chiers en UTF-8 avec une marque UTF-8 byte order mark (ou BOM), vous pouvez utiliser cela au lieu dune dclaration dencodage. IDLE accepte cette possibilit si la case Options/General/Default Source Encoding/UTF-8 est coche. Notez que cette signature nest pas comprise dans les anciennes livraisons de Python (2.2 et plus anciennes), et nest pas non plus comprise par le systme dexploitation pour les chiers script avec des lignes #! (utilises uniquement sur des systmes U NIX). En utilisant UTF-8 (soit travers cette signature, soit au moyen dune dclaration dencodage), les caractres de la plupart des langues du monde peuvent gurer simultanment dans les chanes littrales et les commentaires. Lemploi de caractres non ASCII dans les identicateurs nest pas autoris. Pour afcher tous ces caractres correctement votre diteur doit reconnatre que le chier est UTF-8 et il doit utiliser une police de caractres qui supporte tous les caractres dans le chier.
2.2.4
Le chier de dmarrage interactif
Quand vous utilisez Python de faon interactive, il est souvent pratique que certaines commandes standard soient excutes chaque fois que linterprteur est lanc. Vous pouvez faire cela en donnant la variable denvironnement PYTHONSTARTUP la valeur du nom dun chier contenant vos commandes de dmarrage. Cela est analogue lutilisation du .prole pour les shells U NIX. Ce chier est seulement lu avant les sessions interactives, non pas lorsque Python lit ses commandes dans un script, ni lorsque /dev/tty est fourni comme source explicite pour les commandes (ce qui pour le reste se comporte comme une session interactive). Il est excut dans le mme espace de noms que celui o sont excutes les commandes interactives, de sorte que les objets quil dnit ou importe peuvent tre utiliss directement dans la session interactive. Vous pouvez aussi changer les invites sys.ps1 et sys.ps2 dans ce chier. Si vous voulez lire un chier de lancement additionnel depuis le rpertoire courant, vous pouvez programmer cela dans le chier de dmarrage global en utilisant du code similaire if os.path.isfile(.pythonrc.py) : execfile(.pythonrc.py). Si vous voulez utiliser le chier de dmarrage dans un script, vous devez le faire explicitement dans le script :
2.2. Linterprteur et son environnement
11
import os filename = os.environ.get(PYTHONSTARTUP) if filename and os.path.isfile(filename): execfile(filename)
12
Chapitre 2. Utilisation de linterprteur Python
CHAPITRE
TROIS
Une introduction informelle Python

Dans les exemples suivants, la saisie et lafchage seront distingus par la prsence ou labsence dinvites (>>> et ... ) : pour reproduire lexemple, vous devez taper tout ce qui suit linvite, quand celle-ci apparat ; les lignes qui ne commencent pas par une invite correspondent lafchage effectu par linterprteur. Notez quune invite secondaire seule sur une ligne signie que vous devez taper une ligne vide ; cela marque la n des commandes sur plusieurs lignes. De nombreux exemples de ce manuel, mme ceux qui sont saisis linvite interactive, contiennent des commentaires. Les commentaires en Python commencent par un caractre dise, #, et continuent jusqu la n de la ligne physique. Un commentaire peut se trouver au dbut dune ligne derrire un espace ou du code, mais pas lintrieur dune chane de caractres litrale. Un caractre dise lintrieur dune chane est juste un caractre dise. Quelques exemples :
# voici le premier commentaire SPAM = 1 # et voici le deuxime commentaire # ... et maintenant un troisime! STRING = "# Ceci nest pas un commentaire."
3.1
Utiliser Python comme calculatrice
Essayons quelques commandes Python simples. Lancez linterprteur et attendez lapparition du prompt principal, >>>. (a ne devrait pas tre trs long.)
3.1.1
Nombres
Linterprteur fonctionne comme une simple calculatrice : vous pouvez y taper une expression et il va en afcher la valeur. La syntaxe des expression est naturelle : les oprateurs +, -, * et / marchent exactement comme dans la plupart des langages (par exemple Pascal ou C) ; les parenthses peuvent tre utilises pour les regrouper. Par exemple :
13
>>> 4 >>> ... 4 >>> 4 >>> 5 >>> ... 2 >>> -3
2+2 # Ceci est un commentaire 2+2 2+2 # et un commentaire sur la mme ligne que le code
(50-5*6)/4 # La division des entiers retourne lentier immdiatement infrieur: 7/3 7/-3
Comme en C, le signe gale (=) est utilis pour affecter une valeur une variable. La valeur dune affectation nest pas afche :
>>> largeur = 20 >>> hauteur = 5*9 >>> largeur * hauteur 900
Une valeur peut tre affecte plusieurs variables simultanment :

>>> >>> 0 >>> 0 >>> 0 x = y = z = 0 x y z # Mettre zro x, y et z
Il y a un support complet des nombres virgule ottante ; les oprateurs en prsence de types doprandes mlangs convertissent les oprandes entiers en virgule ottante :
>>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5
>>> 1j * 1J (-1+0j) >>> 1j * complex(0,1) (-1+0j) >>> 3+1j*3 (3+3j) >>> (3+1j)*3 (9+3j) >>> (1+2j)/(1+1j) (1.5+0.5j)
Les nombres complexes sont toujours reprsents comme deux nombres en virgule ottante, les parties relle et imaginaire. Pour extraire ces parties dun nombre complexe z, utilisez z.real et z.imag.
14
Chapitre 3. Une introduction informelle Python
>>> a=1.5+0.5j >>> a.real 1.5 >>> a.imag 0.5
Les fonctions de conversion en virgule ottante et en entier (float(), int() et long()) ne marchent pas pour les nombres complexes il ny a pas une faon correcte et unique de convertir un nombre complexe en un nombre rel. Utilisez abs(z) pour obtenir sa norme (en ottant) ou z.real pour sa partie relle.
>>> a=3.0+4.0j >>> float(a) Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: cant convert complex to float; use e.g. abs(z) >>> a.real 3.0 >>> a.imag 4.0 >>> abs(a) # sqrt(a.real**2 + a.imag**2) 5.0 >>>
En mode interactif, la dernire expression afche est affecte la variable _. Quand vous voulez utiliser Python comme calculatrice, cest plus pratique pour continuer les calculs, par exemple :
>>> tva = 12.5 / 100 >>> prix = 100.50 >>> prix * tva 12.5625 >>> prix + _ 113.0625 >>> round(_, 2) 113.06 >>>
Cette variable doit tre utilise en lecture seule par lutilisateur. Ne lui affectez pas une valeur de faon explicite vous auriez alors cr une variable locale indpendante, avec le mme nom, masquant la variable intgre et son comportement magique.
3.1.2
Chanes de caractres
En plus des nombres, Python peut aussi manipuler des chanes, qui peuvent tre exprimes de diffrentes faons. Elles peuvent tre incluses entre simples quotes (apostrophes) ou doubles quotes (guillemets) :
>>> spam eggs spam eggs >>> n\est-ce pas "nest-ce pas" >>> "nest-ce pas" "nest-ce pas" >>> "Oui," dit-il. "Oui," dit-il. >>> "\"Oui,\" dit-il." "Oui," dit-il. >>> "N\est-ce pas," repondit-elle. "N\est-ce pas," repondit-elle.
3.1. Utiliser Python comme calculatrice
15
Notez1 que les chanes admettent ou non les caractres accentus en mode intractif suivant votre plate-forme. Si les commandes sont lues depuis un chier, la situation est lgrement diffrente : en gnral vous pourrez, mais les caractres accentus risquent dtre interprts diffremment si vous transfrez vos chiers entre des plate-formes diffrentes. Pour ces questions de portabilit, les identicateurs en Python sont limits au code ASCII 7 bits. Vous ne pourrez pas (en mode intractif ou pas) utiliser des lettres accentues dans les noms de variables, fonctions, modules, classes, etc. Les textes dans les chanes peuvent se poursuivre sur plusieurs lignes de plusieurs faons. Des lignes de continuation peuvent tre utilises, avec un antislash comme dernier caractre sur la ligne pour indiquer que la prochaine ligne est une continuation logique de la ligne :
salut = "Ceci est une chane plutot longue contenant\n\ plusieurs lignes de texte exactement comme on le ferait en C.\n\ Notez que les blancs au dbut de la ligne sont\ significatifs." print salut
Notez que les retours chariot ncessiteraient toujours dtre intgrs dans la chane en utilisant \n ; le retour chariot qui suit lantislash de n est supprim. Cet exemple safcherait de la faon suivante :
Ceci est une chane plutot longue contenant plusieurs lignes de texte excatement comme on le ferait en C. Notez que les blancs au dbut de la ligne sont significatifs.
Si nous dnissons les caractres de la chane comme une chane raw (brute), par contre, les squences \n ne sont pas converties en caractres de retour chariot, mais lantislash de n de ligne, et le retour chariot du source sont tous les deux inclus dans la chane comme donnes. Ainsi, lexemple :
salut = r"Ceci est une chaine assez longue contenant\n\ plusieurs lignes de texte comme vous pourriez vraiment le faire en C." print salut
afcherait :
Ceci est une chaine assez longue contenant\n\ plusieurs lignes de texte comme vous pourriez vraiment le faire en C.
Ou bien, les chanes peuvent tre entoures par un couple de triple-quotes correspondantes : """ ou . Les ns de lignes nont pas besoin dtre prxes lorsquon utilise les triple-quotes, mais elles seront incluses dans la chane.
print """ Usage: trucmuche [OPTIONS] -h -H hte """
Affiche cette notice dusage hte auquel il faut se connecter
produit lafchage suivant :

1 NDT : Ce paragraphe absent de ldition originale a t ajout par Daniel Calvelo Aros lintention des utilisateurs de Python francophones.
16
Usage: trucmuche [OPTIONS] -h -H hte
Affiche cette notice dusage hte auquel il faut se connecter
Linterprteur afche le rsultat des oprations sur les chanes de la mme faon qu la saisie : entre quotes, et avec quotes et autres caractres bizarres prxs par un antislash, pour afcher leur valeur exacte. La chane sera dlimite par des doubles quotes si elle contient une simple quote et aucune double quote, sinon, elle sera dlimite par des simples quotes. (Linstruction print, dcrite plus loin, peut tre utilise pour crire des chanes sans quotes ni caractres prxs.) Les chanes peuvent tre concatnes (accoles) avec loprateur +, et rptes avec * :
>>> word = Help + A >>> word HelpA >>> < + word*5 + > <HelpAHelpAHelpAHelpAHelpA>
Deux chanes de texte cte cte sont automatiquement concatnes ; la premire ligne ci-dessus aurait pu tre crite mot = Help A ; cela fonctionne seulement avec deux chanes de texte, pas avec des expressions quelconques de type chane.
>>> import string >>> cha ine chaine >>> string.strip(cha) + ine chaine >>> string.strip(cha) ine File "<stdin>", line 1, in ? string.strip(cha) ine ^ SyntaxError: invalid syntax
# # #
<<<-
Cest ok Cest ok Ca cest faux
Les chanes peuvent tre dcomposes (indexes) ; comme en C, le premier caractre dune chane est en position (index) 0. Il ny a pas de type caractre spcique ; un caractre est simplement une chane de taille un. Comme en Icon, les sous-chanes peuvent tre spcies avec la notation de dcoupage (slice) : deux indices spars par deux-points.
>>> mot[4] A >>> mot[0:2] He >>> mot[2:4] lp
A la diffrence des chanes de caractres en C, les chanes Python ne peuvent tre modies. Faire une affectation lemplacement dun indice dans la chane aboutit une erreur :
17
>>> mot[0] = x Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: object doesnt support item assignment >>> mot[:1] = Splat Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: object doesnt support slice assignment
Cependant, il est facile et efcace de crer une nouvelle chane avec un contenu combin :
>>> x + mot[1:] xelpA >>> Splat + mot[4] SplatA
Les indices de dcoupage ont des valeurs par dfaut utiles ; un premier index non-dni prend pour valeur par dfaut zro, un second index omis prend pour valeur par dfaut la taille de la chane quon est en train de dcouper.
>>> mot[:2] He >>> mot[2:] lpA # Les deux premiers caractres # Tout sauf les deux premiers caractres
Voici un invariant utile des oprations de dcoupage : s[ :i] + s[i :] gale s.

>>> mot[:2] + mot[2:] HelpA >>> mot[:3] + mot[3:] HelpA
Les indices de dcoupage errons sont grs de faon lgante : un index qui est trop grand est remplac par la taille de la chane, un index de n infrieur lindice de dbut retourne une chane vide.
>>> mot[1:100] elpA >>> mot[10:] >>> mot[2:1]
Les indices peuvent tre des nombres ngatifs, pour compter partir de la droite. Par exemple :
>>> mot[-1] A >>> mot[-2] p >>> mot[-2:] pA >>> mot[:-2] Hel # Le dernier caractre # Lavant dernier caractre # Les deux derniers caractres # Tout sauf les deux derniers caractres
Mais notez que -0 est vraiment la mme chose que 0, donc a ne compte pas partir de la droite !
18
>>> mot[-0] H
# (puisque -0 gale 0)
Les indices de dcoupage ngatifs hors limites sont tronqus, mais nessayez pas ceci avec des indices daccs des lments uniques (sans dcoupage) :
>>> mot[-100:] HelpA >>> mot[-10] # erreur Traceback (most recent call last): File "<stdin>", line 1, in ? IndexError: string index out of range
La meilleure faon de se rappeler comment marchent les dcoupages est de penser aux indices comme pointant entre les caractres, avec le bord gauche du premier caractre numrot 0. Alors le bord droit du dernier caractre dune chane de n caractres porte lindex n, par exemple :
+---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1
La premire ligne de nombres donne la position des indices 0...5 dans la chane ; la seconde ligne donne les indice ngatifs correspondants. Le dcoupage de i j consiste en tous les caractres entre les extrmits tiquetes i et j, respectivement. Pour les indices non ngatifs, la longueur dune tranche est la diffrence entre ses indices, si les deux sont lintrieur des limites. Par exemple, la longueur de mot[1:3] est 2. La fonction intgre len() retourne la longueur dune chane :
>>> s = supercalifragilisticexpialidocious >>> len(s) 34
Voir aussi : Types squences (http://docs.python.org/lib/typesseq.html) Les chanes et les chanes Unicode dcrites la prochaine section sont des exemples de types squences et supportent les oprations communes supportes par de tels types. Mthodes des chanes (http://docs.python.org/lib/string-methods.html) Les chanes et les chanes Unicode disposent dun nombre important de mthodes effectuant des transformations basiques et des recherches. Mise en forme de chanes (http://docs.python.org/lib/typesseq-strings.html) Les oprations de mise en forme appeles lorsque des chanes et des chanes Unicode sont les oprandes gauches de loprateur % sont dcrites plus en dtail dans cette page.
3.1.3
Chanes Unicode
A partir de Python 2.0, un nouveau type de donnes destin stocker du texte est disponible pour les programmeurs : lobjet Unicode. Il peut tre utilis pour stocker et manipuler des donnes Unicode (voir http ://www.unicode.org/) et sintgre bien avec les objets chanes en fournissant des conversions automatiques l o cest ncessaire. Unicode offre lavantage de fournir un numro pour chaque caractre de chaque criture utilise dans les textes 3.1. Utiliser Python comme calculatrice 19
modernes et anciens. Auparavant, il ny avait que 256 numros possibles pour les caractres dcriture et les textes taient donc typiquement associs une page de codes qui ralisait lassociation entre le numros et les caractres dcriture. Cela conduisait beaucoup de confusion, spcialement en ce qui concerne linternationalisation (crite dhabitude comme i18n i + caractres 18 + n) des logiciels. Unicode rsout ces problmes en dnissant une page de codes pour toutes les critures. Crer des chanes Unicode en Python est exactement aussi simple que de crer des chanes normales :
>>> uBonjour ! uBonjour !
Le u minuscule devant les guillemets indique quon souhaite crer une chane Unicode. Si vous dsirez placer des caractres spciaux dans la chane, vous pouvez le faire en utilisant lencodage Python Echappement-Unicode. Lexemple suivant montre comment faire :
>>> uSalut\u0020tout le monde ! uSalut tout le monde !
La squence dchappement \u0020 indique quil faut insrer le caractre Unicode dont la valeur ordinale est 0x0020 (le caractre espace) lendroit indiqu. Les autres caractres sont interprts en utilisant leurs valeurs numriques respectives directement comme des numros Unicode. Si vous avez des textes de chanes en encodage standard Latin-1 qui est utilis dans de nombreux pays occidentaux, vous trouverez pratique que les 256 premiers caractres de lUnicode soient les mmes que les 256 caractres de Latin-1. Pour les experts, il y a aussi un mode brut exactement comme pour les chanes normales. Vous devez insrer ur avant louverture de la chane pour que Python utilise lencodage Raw-Unicode-Escape (chappement brutUnicode). Il nappliquera la conversion \uXXXX ci-dessus que sil y a un nombre impair dantislash avant le petit u.
>>> urSalut\u0020tout le monde ! uSalut tout le monde ! >>> urSalut\\u0020tout le monde ! uSalut\\\\u0020tout le monde !
Le mode brut est extrmement utile lorsquil sagit de saisir de nombreux antislash, comme a peut tre ncessaire dans les expressions rationnelles. En dehors de ces encodages standards, Python fournit tout un ensemble dautres moyens de crer des chanes Unicode sur la base dun encodage connu. La fonction unicode() intgre fournit un accs tous les codecs (COdeurs et DECodeurs) Unicode enregistrs. Certains des encodages les mieux connus que ces codecs peuvent convertir sont Latin-1, ASCII, UTF-8 et UTF-16. Les deux derniers sont des encodages longueur variable qui permettent de stocker chaque caractres Unicode sur un ou plusieurs octets. Lencodage par dfaut est normalement dni ASCII, ce qui utilise les caractres de lintervale 0 127 et rejette tout autre caractre avec une erreur. Quand une chane Unicode est afche, crite dans un chier, ou convertie avec str(), la conversion survient en utilisant lencodage par dfaut.
20
>>> u"abc" uabc >>> str(u"abc") abc >>> u"" u\xe4\xf6\xfc >>> str(u"") Traceback (most recent call last): File "<stdin>", line 1, in ? UnicodeError: ASCII encoding error: ordinal not in range(128)
Pour convertir une chane Unicode vers une chane 8-bit en utilisant un encodage spcique, les objets Unicode fournissent une mthode encode() qui prend un argument, le nom de lencodage. Les noms en minuscules sont prfrs pour les encodages.
>>> u"".encode(utf-8) \xc3\xa4\xc3\xb6\xc3\xbc
Si vous avez des donnes dans un encodage spcique et souhaitez produire une chane Unicode correspondante, vous pouvez utiliser la fonction unicode() avec le nom de lencodage comme second argument.
>>> unicode(\xc3\xa4\xc3\xb6\xc3\xbc, utf-8) u\xe4\xf6\xfc
3.1.4
Listes
Python connat un grand nombre de types de donnes composites, utilises pour regrouper un ensemble de valeurs. La plus riche en possibilits est la liste, qui peut tre crite comme une liste de valeurs (lments) entre crochets et spars par des virgules. Les lments dune liste nont pas ncessairement le mme type.
>>> a = [spam, eggs, 100, 1234] >>> a [spam, eggs, 100, 1234]
Comme les indices des chanes, les indices des listes commencent 0, et les listes peuvent tre dcoupes, concatnes, et ainsi de suite :
>>> a[0] spam >>> a[3] 1234 >>> a[-2] 100 >>> a[1:-1] [eggs, 100] >>> a[:2] + [bacon, 2*2] [spam, eggs, bacon, 4] >>> 3*a[:3] + [Boe!] [spam, eggs, 100, spam, eggs, 100, spam, eggs, 100, Boe!]
A la diffrence des chanes, qui sont non-modiables, il est possible de changer les lments individuels dune liste :
21
>>> a [spam, eggs, 100, 1234] >>> a[2] = a[2] + 23 >>> a [spam, eggs, 123, 1234]
Laffectation dans des tranches est aussi possible, et cela peut mme changer la taille de la liste :
>>> # Remplacer certains lments: ... a[0:2] = [1, 12] >>> a [1, 12, 123, 1234] >>> # En enlever certains: ... a[0:2] = [] >>> a [123, 1234] >>> # En insrer ... a[1:1] = [bletch, xyzzy] >>> a [123, bletch, xyzzy, 1234] >>> a[:0] = a # Insre (une copie de) soi-mme au dbut >>> a [123, bletch, xyzzy, 1234, 123, bletch, xyzzy, 1234]
La fonction intgre len() sapplique aussi aux listes :

>>> len(a) 8
Il est possible demboter des listes (crer des listes contenant dautres listes), par exemple :
>>> >>> >>> 3 >>> [2, >>> 2 >>> >>> [1, >>> [2, q = [2, 3] p = [1, q, 4] len(p) p[1] 3] p[1][0] p[1].append(xtra) p [2, 3, xtra], 4] q 3, xtra] # See section 5.1
Notez que dans lexemple prcdent, p[1] et q se rfrent rellement au mme objet ! Nous reviendrons plus tard sur la smantique des objets.
3.2
Premiers pas vers la programmation
Bien sr, nous pouvons utiliser Python pour des tches plus compliques que dajouter deux et deux. Par exemple, nous pouvons crire une sous-squence de la suite de Fibonacci de la faon suivante :
22
>>> ... ... >>> ... ... ... 1 1 2 3 5 8
# Suite de Fibonacci # La somme de deux lments dfinit le suivant a, b = 0, 1 while b < 10: print b a, b = b, a+b
Cet exemple introduit plusieurs fonctionnalits nouvelles. La premire ligne contient une affectation multiple : les variables a et b prennent simultanment les nouvelles valeurs 0 et 1. Sur la dernire ligne laffectation multiple est utilise nouveau, montrant que les expressions en partie droite sont dabord toutes values avant quaucune affectation ne se fasse. La boucle while sexcute tant que la condition (ici : b < 10) reste vraie. En Python, comme en C, toute valeur entire diffrente de zro est vraie ; zro est faux. La condition pourrait aussi tre une chane ou une valeur de type liste, en fait nimporte quelle squence ; nimporte quoi avec une longueur diffrente de zro est vrai, les squences vides correspondent faux. Le test utilis dans lexemple est une simple comparaison. Les oprateurs de comparaison standard sont crits de la mme faon quen C : <, >, ==, <=, >= et !=. Le corps de la boucle est indent : lindentation est le moyen par lequel Python regroupe les instructions. Python ne fournit pas (encore) une fonction ddition de ligne intelligente, donc vous devez insrer une tabulation ou un espace pour chaque ligne indente. En pratique vous prparerez les saisies plus compliques avec un diteur de texte ; la plupart des diteurs de texte ont une fonction dauto-indentation. Lorsquune instruction compose est entre en mode interactif, elle doit tre suivie dune ligne vide pour indiquer quelle est termine (car linterprteur ne peut pas deviner si vous avez tap la dernire ligne). Linstruction print crit la valeur de la ou des expressions qui lui sont donnes. Elle diffre de la simple criture de lexpression (comme tout--lheure dans les exemples de la calculatrice) dans la mesure o elle accepte plusieurs expressions et chanes. Les chanes sont imprimes sans quotes, et un espace est insr entre les lments, ce qui vous permet de les afcher dans un format plus sympathique, comme ceci :
>>> i = 256*256 >>> print La valeur de i est, i La valeur de i est 65536
Une virgule nale empche le retour chariot aprs lafchage :

>>> a, b = 0, 1 >>> while b < 1000: ... print b, ... a, b = b, a+b ... 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
Notez que linterprteur insre un retour chariot avant dimprimer le prompt suivant si la ligne na pas t complte.
3.2. Premiers pas vers la programmation
23
24
CHAPITRE
QUATRE
Dautres outils de contrle dexcution

A part linstruction while que lon vient de dcouvrir, Python comprend les instructions de contrle dexcution habituelles connues dans dautres langages, avec quelques adaptations.
4.1
Instructions if
Peut-tre linstruction la plus connue est-elle linstruction if. Par exemple :

>>> >>> ... ... ... ... ... ... ... ... ... x = int(raw_input("Entrez un entier : ")) if x < 0: x = 0 print Ngatif chang en zro elif x == 0: print Zro elif x == 1: print Un seul else: print Plus
Il peut y avoir aucune ou plusieurs sections elif, et la section else est optionnelle. Le mot-cl elif est une abrviation de else if, et est utile pour viter une indentation excessive. Une squence if . . . elif . . . elif . . . est un substitut pour les instructions switch ou case quon trouve dans dautres langages.
4.2
Instructions for
Linstruction for en Python diffre un petit peu de ce que vous avez pu utiliser en C ou en Pascal. Au lieu ditrer toujours dans une progression arithmtique de nombres (comme en Pascal), ou de laisser lutilisateur compltement libre dans les tests et les pas ditration (comme en C), linstruction for de Python itre parmi les lments de nimporte quelle squence (une liste ou une chane), dans lordre o ils apparaissent dans la squence. Par exemple (aucun jeu de mots volontaire) :
>>> # Mesurer quelques chanes: ... a = [chat, fentre, dfenestrer] >>> for x in a: ... print x, len(x) ... chat 4 fentre 7 dfenestrer 11
Il nest pas prudent de modier la squence sur laquelle on itre dans la boucle (cela peut seulement arriver pour 25
les types de squences modiables, tels que les listes). Si vous avez besoin de modier la liste sur laquelle vous itrez (par exemple, pour dupliquer des lments slectionns), vous devez itrer sur une copie. La notation de dcoupage rend cela particulirement pratique :
>>> for x in a[:]: # fait une copie de la liste entire par dcoupage ... if len(x) > 8: a.insert(0, x) ... >>> a [dfenestrer, chat, fentre, dfenestrer]
4.3
La fonction range()
Si vous avez besoin ditrer sur une squence de nombres, la fonction intgre range() vient point. Elle gnre des listes contenant des progressions arithmtiques :
>>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Le nombre de n qui lui est pass nest jamais dans la liste gnre ; range(10) gnre une liste de 10 valeurs, exactement les indices des lments dune squence de longueur 10. Il est possible de faire commencer lintervalle un autre nombre, ou de spcier un incrment diffrent (mme ngatif) :
>>> range(5, 10) [5, 6, 7, 8, 9] >>> range(0, 10, 3) [0, 3, 6, 9] >>> range(-10, -100, -30) [-10, -40, -70]
Pour parcourir les indices dune squence, combinez range() et len() comme ci-dessous :
>>> a = [Marie, avait, un, petit, mouton] >>> for i in range(len(a)): ... print i, a[i] ... 0 Marie 1 avait 2 un 3 petit 4 mouton
4.4
Les instructions break et continue, et les clauses else dans les boucles
Linstruction break, comme en C, sort de la plus petite boucle for ou while englobante. Linstruction continue, galement emprunte au C, continue sur la prochaine itration de la boucle. Les instructions de boucle ont une clause else ; elle est excute lorsque la boucle se termine par puisement de la liste (avec for) ou quand la condition devient fausse (avec while), mais pas quand la boucle est interrompue par une instruction break. Cela est expliqu dans la boucle suivante, qui recherche des nombres premiers :
26
Chapitre 4. Dautres outils de contrle dexcution
>>> for n in range(2, 10): ... for x in range(2, n): ... if n % x == 0: ... print n, gale, x, *, n/x ... break ... else: ... # la boucle sest termine sans trouver de facteur ... print n, est un nombre premier ... 2 est un nombre premier 3 est un nombre premier 4 gale 2 * 2 5 est un nombre premier 6 gale 2 * 3 7 est un nombre premier 8 gale 2 * 4 9 gale 3 * 3
4.5
LInstruction pass
Linstruction pass ne fait rien. Elle peut tre utilise lorsquune instruction est requise syntaxiquement mais que le programme ne ncessite aucune action. Par exemple :
>>> while 1: ... pass # Attente active dune interruption au clavier ...
4.6
Dnition de fonctions
Nous pouvons crer une fonction qui crit la srie de Fibonacci jusqu une limite quelconque :
>>> ... ... ... ... ... ... >>> ... 1 1 def fib(n): # crit la srie de Fibonacci jusqu n """Affiche une suite de Fibonacci jusqu n.""" a, b = 0, 1 while b < n: print b, a, b = b, a+b # Maintenant on appelle la fonction qui vient juste dtre dfinie fib(2000) 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
Le mot-cl def dbute la dnition dune fonction. Il doit tre suivi par le nom de la fonction et une liste entre parenthses de paramtres formels. Les instructions qui forment le corps de la fonction commencent sur la ligne suivante, indente par une tabulation. La premire instruction du corps de la fonction peut ventuellement tre un texte dans une chane de caractres ; cette chane est la chane de documentation de la fonction, ou docstring. Il y a des outils qui utilisent les docstrings pour gnrer automatiquement de la documentation papier, ou pour permettre lutilisateur de naviguer interactivement dans le code ; cest une bonne technique que dinclure les docstrings dans le code que vous crivez, donc essayez de vous y habituer. Lexcution dune fonction gnre une nouvelle table de symboles, utilise pour les variables locales de la fonction. Plus prcisment, toutes les affectations de variables dans une fonction stockent la valeur dans la table de symboles locale ; alors que les rfrences des variables regardent en premier dans la table de symboles locale, puis dans
4.5. LInstruction pass
27
la table de symboles globale, et enn dans la table des noms intgrs. Ainsi, on ne peut affecter directement une valeur aux variables globales lintrieur dune fonction ( moins de les dclarer avec une instruction global), bien quon puisse y faire rfrence. Les vrais paramtres (arguments) dun appel de fonction sont introduits dans la table de symboles locale de la fonction appele quand elle est appele ; ainsi, les arguments sont passs en utilisant un passage par valeur.1 Quand une fonction appele appelle son tour une autre fonction, une nouvelle table de symboles locaux est cre pour cet appel. La dnition dune fonction introduit le nom de la fonction dans la table de symboles courante. La valeur du nom de la fonction a un type qui est reconnu par linterprteur comme une fonction dnie par lutilisateur. Cette valeur peut tre affecte un autre nom qui peut alors tre utilis aussi comme une fonction. Cela permet de disposer dun mcanisme gnral de renommage :
>>> fib <function object at 10042ed0> >>> f = fib >>> f(100) 1 1 2 3 5 8 13 21 34 55 89
Vous pourriez objecter que fib nest pas une fonction mais une procdure. En Python, comme en C, les procdures sont juste des fonctions qui ne retournent pas de valeur. En fait, techniquement parlant, les procdures retournent bien une valeur, bien quelle soit plutt dcevante. Cette valeur est appele None (cest un nom intgr). La valeur None nest normalement pas afche par linterprteur si elle devait tre la seule valeur crite. Vous pouvez le vrier si vous y tenez vraiment :
>>> print fib(0) None
Ecrire une fonction qui retourne une liste des nombres de la suite de Fibonacci, au lieu de les imprimer, est trs simple :
>>> ... ... ... ... ... ... ... ... >>> >>> [1, def fib2(n): # retourne la srie de Fibonacci jusqu n """Retourne une liste contenant la srie de Fibonacci jusqu n""" resultat = [] a, b = 0, 1 while b < n: resultat.append(b) # voir ci-dessous a, b = b, a+b return resultat f100 = fib2(100) # on lappelle f100 # crire le rsultat 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Cet exemple, comme dhabitude, dmontre quelques nouvelles caractristiques de Python : Linstruction return termine une fonction en renvoyant une valeur. return sans une expression en argument renvoie None. Parvenir jusquau bout de la procdure renvoie galement None. Linstruction result.append(b) appelle une mthode de lobjet result. Une mthode est une fonction qui appartient un objet et est nomme obj.nommethode, o obj est un objet (cela pourrait tre une expression), et nommethode est le nom dune mthode qui est dnie daprs le type de lobjet. Diffrents types dnissent diffrentes mthodes. Les mthodes de types diffrents peuvent avoir le mme nom sans que cela soit source dambiguts. (Il est possible de
1 En ralit, passage par rfrence dobjet serait une meilleure description, puisque si un objet modiable est pass, lappelant verra tous les changements que lappel y effectue (les lments insrs dans une liste).
28
dnir vos propres types dobjets et mthodes, en utilisant des classes, de la faon dcrite en 9.) La mthode append() montre prcdemment, est dnie pour les objets listes ; elle ajoute un nouvel lment la n de la liste. Dans cet exemple, cest quivalent result = result + [b], mais en plus performant.
4.7
Encore plus sur la dnition de fonctions
Il est aussi possible de dnir des fonctions nombre darguments variable. Il y a trois faons de faire, qui peuvent tre combines.
4.7.1
Valeurs dargument par dfaut
La technique la plus utile consiste spcier une valeur par dfaut pour un ou plusieurs arguments. Cela cre une fonction qui peut tre appele avec moins darguments quil nen a t dni.
def demande_ok(question, tentatives=4, plainte=Oui ou non, svp!): while 1: ok = raw_input(question) if ok in (o, ou, oui): return 1 if ok in (n, no, non, niet): return 0 tentatives = tentatives - 1 if tentatives < 0: raise IOError, utilisateur refusenik print plainte
Cette fonction peut tre appele soit comme ceci : demande_ok(Etes vous sr de vouloir quitter ?) ou comme ceci : demande_ok(OK pour crasement du fichier ?, 2). Les valeurs par dfaut sont values au moment de la dnition de la fonction dans la porte de dnition, ainsi
i = 5 def f(arg=i): print arg i = 6 f()
afchera 5. Avertissement important : La valeur par dfaut est value seulement une fois. Cela est important lorsque la valeur par dfaut est un objet modiable comme une liste ou un dictionnaire. Par exemple, la fonction suivante accumule les arguments qui lui sont passs au fur et mesure des appels :
def f(a, L=[]): L.append(a) return L print f(1) print f(2) print f(3)
Cela afchera
[1] [1, 2] [1, 2, 3]
4.7. Encore plus sur la dnition de fonctions
29
Si vous ne voulez pas que la valeur par dfaut soit partage entre des appels successifs, vous pouvez plutt crire la fonction comme ceci :
def f(a, L=None): if L is None: L = [] L.append(a) return L
4.7.2
Arguments mot-cl
Les fonctions peuvent aussi tre appeles en utilisant des arguments mots-cls de la forme motcle = valeur. Par exemple, la fonction suivante :
def perroquet(voltage, etat=c\est du solide, action=voom, type=Bleu Norvgien): print "-- Ce perroquet ne fera pas", action, print "si vous le mettez sous", voltage, "Volts." print "-- Beau plumage, le", type print "-- Ca", etat, "!"
pourrait tre appele de lune des faons suivantes :

perroquet(1000) perroquet(action = VOOOOOM, voltage = 1000000) perroquet(un millier, etat = fait bouffer les pissenlits par la racine) perroquet(un milion, vous dgoute de la vie, de bonds)
mais les appels suivants seraient tous invalides :

perroquet() perroquet(voltage=5.0, rend mort) perroquet(110, voltage=220) perroquet(acteur=John Cleese) # # # # manque un argument obligatoire un argument non-mot-cl suit un mot-cl doublon de valeurs pour un argument mot-cl inconnu
En gnral, une liste darguments doit tre constitue de tous les arguments de position, suivis de tous les arguments mots-cls, o ces mots-cls doivent tre choisis parmi les noms des paramtres formels. Il nest pas important quun paramtre formel ait une valeur par dfaut ou non. Aucun argument ne peut recevoir une valeur plus dune fois les noms de paramtre formel correspondant aux arguments de position ne peuvent tre utiliss comme mots-cls dans les mmes appels.
>>> def function(a): ... pass ... >>> function(0, a=0) Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: keyword parameter redefined
Quand un paramtre formel de la forme **nom est prsent en dernire position, il reoit un dictionnaire contenant tous les arguments mots-cls dont les mots-cls ne correspondent pas un paramtre formel. Cela peut tre combin avec un paramtre formel de la forme *nom (dcrit dans la sous-section suivante) qui reoit un tuple contenant les arguments positionnels au-del de la liste de paramtres formels. (*nom doit tre plac avant **nom.) Par exemple, nous dnissons une fonction comme ceci : 30 Chapitre 4. Dautres outils de contrle dexcution
def fromagerie(type, *arguments, **motcles): print "-- Avez-vous du", type, ? print "-- Je suis dsol, plus personne na de", type for arg in arguments: print arg print -*40 cles = motcles.keys() cles.sort() for mc in cles : print mc, :, motcles[mc]
Elle pourrait tre appele comme ceci :

fromagerie(Camembert, "Il est trs coulant, monsieur.", "Il est vraiment trs, TRES coulant, monsieur.", client=John Cleese, proprietaire=Michael Palin, sketch=Sketch de la Fromagerie )
et bien sr, elle crirait :

-- Avez-vous du Camembert ? -- Je suis dsol, plus personne na de Camembert Il est trs coulant, monsieur. Il est vraiment trs, TRES coulant, monsieur. ---------------------------------------client : John Cleese proprietaire : Michael Palin sketch : Sketch de la Fromagerie
Notez que la mthode sort() de la liste de des mots-cls des noms darguments est appele avant dimprimer le contenu du dictionnaire motcles ; si cela nest pas fait, lordre dans lequel les arguments sont imprims nest pas dni.
4.7.3
Listes darguments arbitraires
Finalement, loption la moins frquemment utilise est de spcier quune fonction peut tre appele avec un nombre darguments arbitraire. Ces arguments seront rcuprs dans un tuple. Avant le nombre variable darguments, zro ou plus arguments normaux pourraient tre prsents.
def fprintf(fichier, format, *args): fichier.write(format % args)
4.7.4
Listes darguments dballer
La situation inverse se produit lorsque les arguments sont dans une liste ou un n-uplet mais doivent tre dballs en vue dune fonction qui requiert des arguments positionnels spars. Par exemple, la fonction intgre range() attend deux arguments spars start et stop. Si ces derniers ne sont pas disponibles sparment, crivez lappel de la fonction avec loprateur * an de dballer les arguments depuis une liste ou un n-uplet :
>>> [3, >>> >>> [3, range(3, 6) 4, 5] args = [3, 6] range(*args) 4, 5] # appel normal avec des arguments spars
# appel avec des arguments dballs depuis une liste
31
De la mme manire, les dictionnaires peuvent fournir des arguments mot-cl si on utilise loprateur ** :
>>> def parrot(voltage, state=a stiff, action=voom): ... print "-- This parrot wouldnt", action, ... print "if you put", voltage, "volts through it.", ... print "Es", state, "!" ... >>> d = {"voltage": "four million", "state": "bleedin demised", "action": "VOOM"} >>> parrot(**d) -- This parrot wouldnt VOOM if you put four million volts through it. Es bleedin demised !
4.7.5
Les formes lambda
Suite la demande populaire, quelques caractristiques trouves habituellement dans les langages de programmation fonctionnelle et dans Lisp ont t ajoutes Python. Avec le mot-cl lambda, de petites fonctions anonymes peuvent tre cres. Voici une fonction qui retourne la somme de ses deux arguments : lambda a, b : a+b. Les formes Lambda peuvent tre utilises chaque fois quun objet fonction est requis. Elles sont limites syntaxiquement une expression unique. Smantiquement, elles sont juste de lenrobage syntaxique pour une dnition de fonction normale. Comme les dnitions de fonctions imbriques, les formes lambda peuvent faire rfrence des variables de la porte qui les contient :
>>> ... ... >>> >>> 42 >>> 43 def fabrique_incrementeur(n): return lambda x, incr=n: x+incr f = fabrique_incrementeur(42) f(0) f(1)
4.7.6
Chanes de documentation (Docstrings)
Il existe des conventions mergentes propos du contenu et du formatage des chanes de documentation. La premire ligne devrait toujours tre un rsum concis des objectifs de lobjet. An dtre bref, il ne devrait pas rpter explicitement le nom ou le type de lobjet, puisque ces informations sont disponibles par dautres moyens (sauf si le nom se trouve tre un verbe dcrivant lutilisation dune fonction). Cette ligne devrait toujours commencer par une lettre majuscule et nir par une virgule. Sil y a dautres lignes dans la chane de documentation, la deuxime ligne devrait tre vide, sparant visuellement le rsum du reste de la description. Les lignes suivantes devraient constituer un ou plusieurs paragraphes dcrivant les conventions dappel des objets, ses effets de bord, etc. Linterprteur python ne supprime pas lindentation des chanes de texte multilignes en Python, donc les outils qui traitent la documentation doivent supprimer lindentation. Cela peut se faire en utilisant la convention suivante. La premire ligne non-vide aprs la premire ligne de la chane dtermine la quantit dindentation pour toute la chane de documentation. (On ne peut pas utiliser la premire ligne puisquelle est gnralement adjacente aux quotes ouvrantes de la chane donc son indentation nest pas apparente dans le texte de la chane.) Les espaces quivalents cette indentation sont ensuite supprims du dbut de toutes les lignes de la chane. Des lignes indentes de faon moins importante ne devraient pas apparatre, mais si elles le font, tous leurs espaces en dbut de ligne devraient tre supprims. Lquivalence de lespacement devrait tre teste aprs lexpansion des tabulations ( 8 espaces, normalement). Voici un exemple de docstring multi-ligne :
32
>>> def ma_fonction(): ... """Ne fait rien, mais le documente. ... ... Non, vraiment, elle ne fait rien. ... """ ... pass ... >>> print ma_fonction.__doc__ Ne fait rien, mais le documente. Non, vraiment, elle ne fait rien.
33
34
CHAPITRE
CINQ
Structures de donnes
Ce chapitre dcrit avec plus de dtail quelques lments que vous avez dj tudi, et ajoute aussi quelques nouveauts.
5.1
Plus de dtails sur les listes
Le type de donnes liste possde dautres mthodes. Voici toutes les mthodes des objets listes : append(x) Equivalent a.insert(len(a), x). extend(L) Rallonge la liste en ajoutant la n tous les lments de la liste donne ; quivaut a[len(a):] = L. insert(i, x) Insre un lment une position donne. Le premier argument est lindice de llment avant lequel il faut insrer, donc a.insert(0, x) insre au dbut de la liste, et a.insert(len(a), x) est quivalent a.append(x). remove(x) Enlve le premier lment de la liste dont la valeur est x. Il y a erreur si cet lment nexiste pas. pop([i ]) Enlve llment prsent la position donne dans la liste, et le renvoie. Si aucun indice nest spci, a.pop() renvoie le dernier lment de la liste. Llment est aussi supprim de la liste. index(x) Retourne lindice dans la liste du premier lment dont la valeur est x. Il y a erreur si cet lment nexiste pas. count(x) Renvoie le nombre de fois que x apparat dans la liste. sort() Trie les lments lintrieur de la liste. reverse() Renverse lordre des lments lintrieur de la liste. Un exemple qui utilise toutes les mthodes des listes :
35
>>> a = [66.6, 333, 333, 1, 1234.5] >>> print a.count(333), a.count(66.6), a.count(x) 2 1 0 >>> a.insert(2, -1) >>> a.append(333) >>> a [66.6, 333, -1, 333, 1, 1234.5, 333] >>> a.index(333) 1 >>> a.remove(333) >>> a [66.6, -1, 333, 1, 1234.5, 333] >>> a.reverse() >>> a [333, 1234.5, 1, 333, -1, 66.6] >>> a.sort() >>> a [-1, 1, 66.6, 333, 333, 1234.5]
5.1.1
Utiliser les listes comme des piles
Les mthodes des listes rendent trs facile lutilisation dune liste comme une pile, o le dernier lment ajout est le premier lment rcupr (LIFO, last-in, rst-out). Pour ajouter un lment au sommet de la pile, utilisez la mthode append(). Pour rcuprer un lment du sommet de la pile, utilisez pop() sans indice explicite. Par exemple :
>>> >>> >>> >>> [3, >>> 7 >>> [3, >>> 6 >>> 5 >>> [3, pile = [3, 4, 5] pile.append(6) pile.append(7) pile 4, 5, 6, 7] pile.pop() pile 4, 5, 6] pile.pop() pile.pop() pile 4]
5.1.2
Utiliser les listes comme des les
Vous pouvez aussi utiliser facilement une liste comme une le, o le premier lment ajout est le premier lment retir (FIFO, rst-in, rst-out). Pour ajouter un lment la n de la le, utiliser append(). Pour rcuprer un lment du devant de la le, utilisez pop() avec 0 pour indice. Par exemple ;
36
Chapitre 5. Structures de donnes
>>> file = ["Eric", "John", "Michael"] >>> file.append("Terry") # Terry arrive >>> file.append("Graham") # Graham arrive >>> file.pop(0) Eric >>> file.pop(0) John >>> file [Michael, Terry, Graham]
5.1.3
Outils de programmation fonctionnelle
Il y a trois fonctions intgres qui sont trs pratiques avec les listes : filter(), map(), et reduce(). filter(fonction, sequence) renvoit une liste (du mme type, si possible) contenant les seul lments de la squence pour lesquels fonction(element) est vraie. Par exemple, pour calculer quelques nombres premiers :
>>> def f(x): return x % 2 != 0 and x % 3 != 0 ... >>> filter(f, range(2, 25)) [5, 7, 11, 13, 17, 19, 23]
map(fonction, sequence) appelle fonction(element) pour chacun des lments de la squence et renvoie la liste des valeurs de retour. Par exemple, pour calculer les cubes :
>>> def cube(x): return x*x*x ... >>> map(cube, range(1, 11)) [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
Plusieurs squences peuvent tre passes en paramtre ; la fonction doit alors avoir autant darguments quil y a de squences et est appele avec les lments correspondants de chacune des squences (ou None si lune des squences est plus courte que lautre). Si None est pass en tant que fonction, une fonction retournant ses arguments lui est substitue. En combinant ces deux cas spciaux, on voit que map(None, liste1, liste2) est une faon pratique de transformer un couple de liste en une liste de couples. Par exemple :
>>> seq = range(8) >>> def carre(x): return x*x ... >>> map(None, seq, map(carre, seq)) [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]
reduce(fonction, sequence) renvoie une valeur unique construite par lappel de la fonction binaire fonction sur les deux premiers lments de la squence, puis sur le rsultat et llment suivant, et ainsi de suite. Par exemple, pour calculer la somme des nombres de 1 10 :
>>> def ajoute(x,y): return x+y ... >>> reduce(ajoute, range(1, 11)) 55
5.1. Plus de dtails sur les listes
37
Sil y a seulement un lment dans la squence, sa valeur est renvoye ; si la squence est vide, une exception est dclenche. Un troisime argument peut tre transmis pour indiquer la valeur de dpart. Dans ce cas, la valeur de dpart est renvoye pour une squence vide, et la fonction est dabord applique la valeur de dpart et au premier lment de la squence, puis au rsultat et llment suivant, et ainsi de suite. Par exemple,
>>> def somme(seq): ... def ajoute(x,y): return x+y ... return reduce(ajoute, seq, 0) ... >>> somme(range(1, 11)) 55 >>> somme([]) 0
5.1.4
List Comprehensions
Les list comprehensions fournissent une faon concise de crer des listes sans avoir recours map(), filter() et/ou lambda. La dnition de liste qui en rsulte a souvent tendance tre plus claire que des listes construites avec ces outils. Chaque list comprehension consiste en une expression suivie dune clause for, puis zro ou plus clauses for ou if. Le rsultat sera une liste rsultant de lvaluation de lexpression dans le contexte des clauses for et if qui la suivent. Si lexpression svalue en un tuple, elle doit tre mise entre parenthses.
>>> fruitfrais = [ banane, myrtille , fruit de la passion ] >>> [projectile.strip() for projectile in fruitfrais] [banane, myrtille, fruit de la passion] >>> vec = [2, 4, 6] >>> [3*x for x in vec] [6, 12, 18] >>> [3*x for x in vec if x > 3] [12, 18] >>> [3*x for x in vec if x < 2] [] >>> [{x: x**2} for x in vec] [{2: 4}, {4: 16}, {6: 36}] >>> [[x,x**2] for x in vec] [[2, 4], [4, 16], [6, 36]] >>> [x, x**2 for x in vec] # erreur - parenthses obligatoires pour les tuples File "<stdin>", line 1, in ? [x, x**2 for x in vec] ^ SyntaxError: invalid syntax >>> [(x, x**2) for x in vec] [(2, 4), (4, 16), (6, 36)] >>> vec1 = [2, 4, 6] >>> vec2 = [4, 3, -9] >>> [x*y for x in vec1 for y in vec2] [8, 6, -18, 16, 12, -36, 24, 18, -54] >>> [x+y for x in vec1 for y in vec2] [6, 5, -7, 8, 7, -5, 10, 9, -3] >>> [vec1[i]*vec2[i] for i in range(len(vec1))] [8, 12, -54]
38
5.2
Linstruction del
Il y a un moyen denlever un lment dune liste en ayant son indice au lieu de sa valeur : linstruction del. Cela peut aussi tre utilis pour enlever des tranches dans une liste (ce que lon a fait prcdemment par remplacement de la tranche par une liste vide). Par exemple :
>>> a [-1, 1, 66.6, 333, 333, 1234.5] >>> del a[0] >>> a [1, 66.6, 333, 333, 1234.5] >>> del a[2:4] >>> a [1, 66.6, 1234.5]
del peut aussi tre utilis pour supprimer des variables compltes :
>>> del a
Faire par la suite rfrence au nom a est une erreur (au moins jusqu ce quune autre valeur ne lui soit affecte). Nous trouverons dautres utilisations de del plus tard.
5.3
N-uplets (tuples) et squences
Nous avons vu que les listes et les chanes ont plusieurs proprits communes, telles que lindexation et les oprations de dcoupage. Elles sont deux exemples de types de donnes de type squence. Puisque Python est un langage qui volue, dautres types de donnes de type squence pourraient tre ajouts. Il y a aussi un autre type de donnes de type squence standard : le tuple (n-uplet). Un n-uplet consiste en un ensemble de valeurs spares par des virgules, par exemple :
>>> t = 12345, 54321, salut! >>> t[0] 12345 >>> t (12345, 54321, salut!) >>> # Les Tuples peuvent tre imbriqus: ... u = t, (1, 2, 3, 4, 5) >>> u ((12345, 54321, salut!), (1, 2, 3, 4, 5))
Comme vous pouvez le voir, lafchage, les tuples sont toujours entre parenthses, de faon ce que des tuples de tuples puissent tre interprts correctement ; ils peuvent tre saisis avec ou sans parenthses, bien que des parenthses soient souvent ncessaires (si le tuple fait partie dune expression plus complexe). Les tuples ont plein dutilisations. Par exemple, les couples de coordonnes (x, y), les enregistrements des employs dune base de donnes, etc. Les tuples, comme les chanes, sont non-modiables : il est impossible daffecter individuellement une valeur aux lments dun tuple (bien que vous puissiez simuler quasiment cela avec le dcoupage et la concatnation). Un problme particulier consiste crer des tuples contenant 0 ou 1 lment : la syntaxe reconnat quelques subtilits pour y arriver. Les tuples vides sont construits grce des parenthses vides ; un tuple avec un lment est construit en faisant suivre une valeur dune virgule (il ne suft pas de mettre une valeur seule entre parenthses). Moche, mais efcace. Par exemple :
5.2. Linstruction del
39
>>> empty = () >>> singleton = salut, >>> len(empty) 0 >>> len(singleton) 1 >>> singleton (salut,)
# <-- notez la virgule en fin de ligne
Linstruction t = 12345, 54321, salut ! est un exemple d emballage en tuple (tuple packing) : les valeurs 12345, 54321 et salut ! sont emballes ensemble dans un tuple. Lopration inverse est aussi possible :
>>> x, y, z = t
Cela est appel, fort judicieusement, dballage de tuple (tuple unpacking). Le dballage dun tuple ncessite que la liste des variables gauche ait un nombre dlments gal la longueur du tuple. Notez que des affectations multiples ne sont en ralit quune combinaison demballage et dballage de tuples !
5.4
Ensembles
Python comporte galement un type de donnes pour reprsenter des ensembles. Un set est une collection (non range) sans lments dupliqus. Les emplois basiques sont le test dappartenance et llimination des entre dupliques. Les objets ensembles supportent les oprations mathmatiques comme lunion, lintersection, la diffrence et la diffrence symtrique. Voici une dmonstration succincte :
>>> basket = [apple, orange, apple, pear, orange, banana] >>> fruits = set(basket) # create a set without duplicates >>> fruits set([orange, pear, apple, banana]) >>> orange in fruits # fast membership testing True >>> crabgrass in fruits False >>> # Demonstrate set operations on unique letters from two words ... >>> a = set(abracadabra) >>> b = set(alacazam) >>> a # unique letters in a set([a, r, b, c, d]) >>> a - b # letters in a but not in b set([r, d, b]) >>> a | b # letters in either a or b set([a, c, r, d, b, m, z, l]) >>> a & b # letters in both a and b set([a, c]) >>> a ^ b # letters in a or b but not both set([r, d, b, m, z, l])
40
5.5
Dictionnaires
Un autre type de donnes intgr Python est le dictionnaire. Les dictionnaires sont parfois trouvs dans dautres langages sous le nom de mmoires associatives ou tableaux associatifs. A la diffrence des squences, qui sont indexes par un intervalle numrique, les dictionnaires sont indexs par des cls, qui peuvent tre de nimporte quel type non-modiable ; les chanes et les nombres peuvent toujours tre des cls. Les tuples peuvent tre utiliss comme cls sils ne contiennent que des chanes, des nombres ou des tuples. Vous ne pouvez pas utiliser des listes comme cls, puisque les listes peuvent tre modies en utilisant leur mthode append(). Il est prfrable de considrer les dictionnaires comme des ensembles non ordonns de couples cl :valeur, avec la contrainte que les cls soient uniques ( lintrieur dun mme dictionnaire). Un couple daccolades cre un dictionnaire vide : {}. Placer une liste de couples cl :valeur spars par des virgules lintrieur des accolades ajoute les couples initiaux cl :valeur au dictionnaire ; cest aussi de cette faon que les dictionnaires sont afchs. Les oprations principales sur un dictionnaire sont le stockage dune valeur laide dune certaine cl et lextraction de la valeur en donnant la cl. Il est aussi possible de dtruire des couples cl :valeur avec del. Si vous stockez avec une cl dj utilise, lancienne valeur associe cette cl est oublie. Cest une erreur dextraire une valeur en utilisant une cl qui nexiste pas. La mthode keys() dun objet de type dictionnaire retourne une liste de toutes les cls utilises dans le dictionnaire, dans un ordre quelconque (si vous voulez quelle soit trie, appliquez juste la mthode sort() la liste des cls). Pour savoir si une cl particulire est dans le dictionnaire, utilisez la mthode has_key() du dictionnaire. Voici un petit exemple utilisant un dictionnaire :
>>> tel = {jack: 4098, sape: 4139} >>> tel[guido] = 4127 >>> tel {sape: 4139, guido: 4127, jack: 4098} >>> tel[jack] 4098 >>> del tel[sape] >>> tel[irv] = 4127 >>> tel {guido: 4127, irv: 4127, jack: 4098} >>> tel.keys() [guido, irv, jack] >>> tel.has_key(guido) True
Le constructeur dict() construit des dictionnaires directement partir de listes de paires cl-valeur ranges comme des n-uplets. Lorsque les paires forment un motif, les list list comprehensions peuvent spcier de manire compacte la liste de cls-valeurs.
>>> dict([(sape, 4139), (guido, 4127), (jack, 4098)]) {sape: 4139, jack: 4098, guido: 4127} >>> dict([(x, x**2) for x in (2, 4, 6)]) # use a list comprehension {2: 4, 4: 16, 6: 36}
Plus loin dans ce tutoriel nous tudierons les expressions gnrateurs qui sont loutil idal pour fournir des paires cl-valeur au constructeur dict(). Lorsque les cls sont de simples chanes il est parfois plus simple de spcier les paires en utilisant des arguments mot-cl :
>>> dict(sape=4139, guido=4127, jack=4098) {sape: 4139, jack: 4098, guido: 4127}
5.5. Dictionnaires
41
5.6
Techniques de boucles
Lorsquon boucle sur un dictionnaire, les cls et les valeurs correspondantes peuvent tre obtenues en mme temps en utilisant la mthode iteritems()
>>> knights = {gallahad: the pure, robin: the brave} >>> for k, v in knights.iteritems(): ... print k, v ... gallahad the pure robin the brave
Lorsquon boucle sur une squence, lindice donnant la position et la valeur correspondante peuvent tre obtenus en mme temps en utilisant la fonction enumerate().
>>> for i, v in enumerate([tic, tac, toe]): ... print i, v ... 0 tic 1 tac 2 toe
Pour boucler sur deux squences, ou plus, en mme temps, les lments peuvent tre apparis avec la fonction zip().
>>> questions = [name, quest, favorite color] >>> answers = [lancelot, the holy grail, blue] >>> for q, a in zip(questions, answers): ... print What is your %s? It is %s. % (q, a) ... What is your name? It is lancelot. What is your quest? It is the holy grail. What is your favorite color? It is blue.
Pour boucler lenvers sur une squence, spciez dabord la squence lendroit, ensuite appelez la fonction reversed().
>>> for i in reversed(xrange(1,10,2)): ... print i ... 9 7 5 3 1
Pour boucler sur une squence comme si elle tait trie, utilisez la fonction sorted() qui retourne une liste nouvelle trie tout en laissant la source inchange.
42
>>> basket = [apple, orange, apple, pear, orange, banana] >>> for f in sorted(set(basket)): ... print f ... apple banana orange pear
5.7
Plus de dtails sur les conditions
Les conditions utilises dans les instructions while et if peuvent contenir dautres oprateurs en dehors des comparaisons. Les oprateurs de comparaison in et not in vrient si une valeur apparat (ou non) dans une squence. Les oprateurs is et is not vrient si deux objets sont rellement le mme objet ; cela se justie seulement pour les objets modiables comme les listes. Tous les oprateurs de comparaison ont la mme priorit, qui est plus faible que celle de tous les oprateurs numriques. Les comparaisons peuvent tre enchanes. Par exemple, a < b == c teste si a est strictement infrieur b et de plus si b est gal c. Les comparaisons peuvent tre combines avec les oprateurs Boolens and (et) et or (ou), et le rsultat dune comparaison (ou de nimporte quel autre expression Boolenne) peut tre invers avec not (pas). Ces oprateurs ont encore une fois une priorit infrieure celle des oprateurs de comparaison ; et entre eux, not a la plus haute priorit, et or la plus faible, de sorte que A and not B or C est quivalent (A and (not B)) or C. Bien sr, les parenthses peuvent tre utilises pour exprimer les compositions dsires. Les oprateurs Boolens and et or sont des oprateurs dits court-circuit : leurs arguments sont valus de gauche droite, et lvaluation sarrte ds que le rsultat est trouv. Par exemple, si A et C sont vrais mais que B est faux, A and B and C nvalue pas lexpression C. En gnral, la valeur de retour dun oprateur court-circuit, quand elle est utilise comme une valeur gnrale et non comme un Boolen, est celle du dernier argument valu. Il est possible daffecter le rsultat dune comparaison ou une autre expression Boolenne une variable. Par exemple,
>>> chaine1, chaine2, chaine3 = , Trondheim, Hammer Dance >>> non_null = chaine1 or chaine2 or chaine3 >>> non_null Trondheim
Notez quen Python, au contraire du C, les affectations ne peuvent pas tre effectues lintrieur des expressions. Les programmeurs C ronchonneront peut-tre, mais cela vite une classe de problmes quon rencontre dans les programmes C : crire = dans une expression alors quil fallait ==.
5.8
Comparer les squences et dautres types
Les objets de type squence peuvent tre compars dautres objets appartenant au mme type de squence. La comparaison utilise lordre lexicographique : les deux premiers lments sont dabord compars, et sils diffrent cela dtermine le rsultat de la comparaison ; sils sont gaux, les deux lments suivants sont compars, et ainsi de suite, jusqu ce que lune des deux squences soit puise. Si deux lments comparer sont eux-mmes des squences du mme type, la comparaison lexicographique est reconsidre rcursivement. Si la comparaison de tous les lments de deux squences les donne gaux, les squences sont considres comme gales. Si une squence est une sous-squence initiale de lautre, la squence la plus courte est la plus petite (infrieure). Lordonnancement lexicographique pour les chanes utilise lordonnancement ASCII pour les caractres. Quelques exemples de comparaisons de squences du mme type : 5.7. Plus de dtails sur les conditions 43
(1, 2, 3) < (1, 2, 4) [1, 2, 3] < [1, 2, 4] ABC < C < Pascal < Python (1, 2, 3, 4) < (1, 2, 4) (1, 2) < (1, 2, -1) (1, 2, 3) == (1.0, 2.0, 3.0) (1, 2, (aa, ab)) < (1, 2, (abc, a), 4)
Notez que la comparaison dobjets de types diffrents est licite. Le rsultat est dterministe mais arbitraire : les types sont tris selon leur nom. Ainsi une liste (list) est toujours infrieure une chane (string), une chane (string) est toujours infrieure un n-uplet (tuple), etc. Les types numriques mlangs sont compars en fonction de leur valeur numrique, ainsi 0 est gal 0.0, etc.1
1 On ne doit pas se er aux rgles de comparaison pour des objets de types diffrents ; elles pourraient changer dans une version ultrieure du langage.
44
CHAPITRE
SIX
Modules
Si vous quittez linterprteur de Python et le lancez nouveau, les dnitions que vous avez faites (fonctions et variables) sont perdues. Par consquent, si vous voulez crire un programme plus long, vous feriez mieux dutiliser la place un diteur de texte pour prparer le source pour linterprteur et de le lancer avec ce chier comme entre. Cela sappelle crer un script. Quant votre programme devient plus long, vous pouvez vouloir le couper en plusieurs chiers pour une maintenance plus facile. Vous pouvez galement vouloir utiliser dans plusieurs programmes une fonction pratique que vous avez crite sans copier sa dnition dans chaque programme. Pour supporter cela, Python offre un moyen de mettre des dnitions dans un chier et de les utiliser dans un script ou dans un session interactive de linterprteur. Un tel chier sappelle un module ; les dnitions dun module peuvent tre importes dans un autre module ou dans le module principal (la collection de variables laquelle vous avez accs dans un script excut depuis le plus haut niveau et dans le mode calculatrice). Un module est un chier contenant des dnitions et des instructions Python. Le nom de chier est le nom du module auquel est ajout le sufxe .py. Dans un module, le nom du module (comme chane de caractres) est disponible comme valeur de la variable globale __name__. Par exemple, employez votre diteur de texte prfr pour crer un chier appel bo.py dans le rpertoire courant avec le contenu suivant :
# Module nombres de Fibonacci def fib(n): # crit la srie de Fibonacci jusqu n a, b = 0, 1 while b < n: print b, a, b = b, a+b def fib2(n): # retourne la srie de Fibonacci jusqu n result = [] a, b = 0, 1 while b < n: result.append(b) a, b = b, a+b return result
Maintenant lancez linterprteur Python et importez ce module avec la commande suivante :

>>> import fibo
Cela ncrit pas les noms des fonctions dnies dans fibo directement dans la table de symboles actuelle ; cela y insre seulement le nom de module fibo. En utilisant le nom de module vous pouvez accder aux fonctions :
45
>>> fibo.fib(1000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ fibo
si vous avez lintention dutiliser souvent une fonction, vous pouvez laffecter un nom local :
>>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6.1
Encore plus sur les modules
Un module peut contenir des instructions excutables aussi bien que des dnitions de fonction. Ces instructions sont destines initialiser le module. On les excute seulement la premire fois que le module est import quelque part.1 Chaque module a sa propre table de symboles prive, qui est utilise comme table de symbole globale par toutes les fonctions dnies dans le module. Ainsi, lauteur dun module peut utiliser des variables globales dans le module sans sinquiter des dsaccords accidentels avec les variables globales dun utilisateur. Dautre part, si vous savez que ce que vous faites, vous pouvez accder aux variables globales dun module avec la mme notation que celle employe pour se rfrer ses fonctions, nommodule.nomelem. Les modules peuvent importer dautres modules. Il est dusage mais pas obligatoire de placer toutes les instructions import au dbut dun module (ou dun script). Les noms du module import sont placs dans la table globale de symboles du module importateur. Il y a une variante de linstruction import qui importe des noms dun module directement dans la table de symboles du module importateur. Par exemple :
>>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Cela nintroduit pas dans la table de symboles locale le nom du module duquel les lments imports sont issus (ainsi dans lexemple, fibo nest pas dni). Il y a mme une variante pour importer tous les noms quun module dnit :
>>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Cela importe tous les noms except ceux qui commencent par un tiret-bas (_).
6.1.1
Le chemin de recherche du module
Quand un module nomm spam est import, linterprteur recherche un chier nomm spam.py dans le rpertoire courant, et puis dans la liste de rpertoires indique par la variable denvironnement PYTHONPATH. Elle a la mme syntaxe que la variable du shell PATH, cest--dire, une liste de noms de rpertoire. Quand PYTHON1 En fait, les dnitions de fonctions sont aussi des instructions qui sont excutes ; lexcution insre le nom de la fonction dans la table de symboles globale du module.
46
Chapitre 6. Modules
PATH nest pas renseign, ou quand le chier ny est pas trouv, la recherche continue dans un chemin daccs par dfaut, dpendant de linstallation ; sur U NIX, cest habituellement . :/usr/local/lib/python. En fait, les modules sont recherchs dans la liste de rpertoires donne par la variable sys.path qui est initialise partir du rpertoire contenant le script dentre (ou le rpertoire actuel), PYTHONPATH et le chemin par dfaut, dpendant de linstallation. Cela permet aux programmes Python qui savent ce quils font de modier ou de remplacer le chemin daccs aux modules. Notez que puisque le rpertoire contenant le script en cours dexcution est sur le chemin de recherche, il est important que le script nait pas le mme nom quun module standard, ou bien Python essaiera de charger le script comme module quand ce module sera import. Cela provoquera en gnral une erreur. Voyez la section 6.2, Modules standards. pour plus dinformations.
6.1.2
Fichiers compils de Python
Pour acclrer de manire importante le temps de lancement des petits programmes qui utilisent beaucoups de modules standard, si un chier appel spam.pyc existe dans le rpertoire o spam.py se trouve, il est suppos contenir une version du module spam dj compile en byte-code Lheure de modication de la version de spam.py employe pour crer spam.pyc est enregistre dans spam.pyc, et le chier est ignor si ceux-ci ne saccordent pas. Normalement, vous navez rien faire pour crer le chier spam.pyc. Toutes les fois que spam.py est compil avec succs, une tentative est faite pour crire la version compile sur spam.pyc. Il ny a pas derreur si cette tentative choue ; si pour une raison quelconque le chier nest pas crit compltement, le chier spam.pyc rsultant sera identi comme incorrect et ainsi ignor plus tard. Le contenu du chier spam.pyc est indpendant de la plate-forme, ainsi un rpertoire de module de Python peut tre partag par des machines darchitectures diffrentes. Quelques trucs pour les experts : Quand linterprteur de Python est appel avec lindicateur -O, du code optimis est produit et enregistr dans des chiers .pyo. Loptimiseur actuel naide pas beaucoup ; il retire seulement les instructions assert et des instructions SET_LINENO. Quand -O est utilis, tout le byte-code est optimis ; les chiers pyc sont ignors et des chiers py sont compils en byte-code optimis. Passer deux options -O en paramtres linterprteur Python (-OO) forcera le compilateur de bytecode effectuer des optimisations qui pouraient dans certains cas rares avoir pour rsultat des programmes ne fonctionnant pas correctement. Actuellement, seules les chanes __doc__ sont enleves du bytecode, ce qui a pour rsultat des chiers .pyo plus compacts. Puisque certains programmes pourraient sappuyer sur le fait que celles-ci soient disponibles, vous devriez utiliser cette option uniquement si vous savez ce que vous faites. Un programme ne fonctionne pas plus rapidement quand on le charge depuis un chier .pyc ou .pyo que quand on le charge depuis un .py ; la seule chose qui est plus rapide pour les chiers .pyc ou .pyo est la vitesse laquelle ils sont chargs. Quand un script est excut en donnant son nom sur la ligne de commande, le byte-code pour le script nest jamais crit dans un chier .pyc ou .pyo. Ainsi, le temps de dmarrage dune squence type peut tre rduit en dplaant la majeure partie de son code dans un module et en ayant un petit script damorce qui importe ce module. Il est possible d avoir un chier appel spam.pyc (ou spam.pyo quand -O est utilis) sans module spam.py dans le mme module. Cela peut tre employ pour distribuer une bibliothque de code Python sous une forme qui est moyennement difcile dcompiler. Le module compileall peut crer des chiers .pyc (ou des chiers .pyo quand -O est utilis) pour tous les modules prsents dans un rpertoire.
6.2
Modules standard
Python est livr avec une bibliothque de modules standard, dcrite dans un document spar, Python Library Reference (Library Reference ci-aprs). Quelques modules sont intgrs dans linterprteur ; ceux-ci permettent daccder des oprations qui ne font pas partie du noyau du langage mais sont nanmoins intgres, pour des 6.2. Modules standard 47
raisons defcacit ou pour permettre daccder aux primitives du systme dexploitation telles que les appels systme. La dnition de lensemble de ces modules standards est une option de conguration qui dpend aussi de la plate-forme sous-jacente. Par exemple, le module amoeba est seulement fourni sur les systmes qui supportent dune faon ou dune autre les primitives dAmoeba. Un module particulier mrite une certaine attention : sys, qui est intgr dans chaque interprteur de Python. Les variables sys.ps1 et sys.ps2 dnissent les chanes de caractres utilises en tant quinvites primaire et secondaire :
>>> import sys >>> sys.ps1 >>> >>> sys.ps2 ... >>> sys.ps1 = C> C> print Yuck! Yuck! C>
Ces deux variables sont seulement dnies si linterprteur est en mode interactif. La variable sys.path est une liste de chanes de caractres qui dterminent le chemin de recherche des modules pour linterprteur. Il est initialis un chemin par dfaut partir de la variable denvironnement PYTHONPATH, ou dune valeur par dfaut intgre au programme si PYTHONPATH nest pas renseign. Vous pouvez la modier en utilisant des oprations standard sur des listes :
>>> import sys >>> sys.path.append(/ufs/guido/lib/python)
6.3
La fonction dir()
La fonction intgre dir() est employe pour dcouvrir les noms quun module dnit. Elle renvoie une liste trie de chanes de caractres :
>>> import fibo, sys >>> dir(fibo) [__name__, fib, fib2] >>> dir(sys) [__displayhook__, __doc__, __excepthook__, __name__, __stderr__, __stdin__, __stdout__, _getframe, argv, builtin_module_names, byteorder, copyright, displayhook, exc_info, exc_type, excepthook, exec_prefix, executable, exit, getdefaultencoding, getdlopenflags, getrecursionlimit, getrefcount, hexversion, maxint, maxunicode, modules, path, platform, prefix, ps1, ps2, setcheckinterval, setdlopenflags, setprofile, setrecursionlimit, settrace, stderr, stdin, stdout, version, version_info, warnoptions]
Sans arguments, dir() numre les noms que vous avez dnis :
>>> a = [1, 2, 3, 4, 5] >>> import fibo, sys >>> fib = fibo.fib >>> dir() [__name__, a, fib, fibo, sys]
48
Chapitre 6. Modules
Notez quelle numre tous les types de noms : les variables, les modules, les fonctions, etc. dir() nnumre pas les noms des fonctions et des variables intgres. Si vous en voulez une liste, elles sont dnies dans le module standard __builtin__ :
>>> import __builtin__ >>> dir(__builtin__) [ArithmeticError, AssertionError, AttributeError, DeprecationWarning, EOFError, Ellipsis, EnvironmentError, Exception, FloatingPointError, IOError, ImportError, IndentationError, IndexError, KeyError, KeyboardInterrupt, LookupError, MemoryError, NameError, None, NotImplemented, NotImplementedError, OSError, OverflowError, OverflowWarning, ReferenceError, RuntimeError, RuntimeWarning, StandardError, StopIteration, SyntaxError, SyntaxWarning, SystemError, SystemExit, TabError, TypeError, UnboundLocalError, UnicodeError, UserWarning, ValueError, Warning, ZeroDivisionError, _, __debug__, __doc__, __import__, __name__, abs, apply, buffer, callable, chr, classmethod, cmp, coerce, compile, complex, copyright, credits, delattr, dict, dir, divmod, eval, execfile, exit, file, filter, float, getattr, globals, hasattr, hash, help, hex, id, input, int, intern, isinstance, issubclass, iter, len, license, list, locals, long, map, max, min, object, oct, open, ord, pow, property, quit, range, raw_input, reduce, reload, repr, round, setattr, slice, staticmethod, str, super, tuple, type, unichr, unicode, vars, xrange, zip]
6.4
Paquetages
Les paquetages sont un moyen de structurer lespace des noms de modules Python en utilisant les noms de modules points. Par exemple, le nom de module A.B dsigne un sous-module nomm B dans un module nomm A. Tout comme lutilisation des modules permet aux auteurs de diffrents modules de ne pas sinquiter au sujet des noms des variables globales de chacun des autres modules, lutilisation des noms de modules points dispense lauteur de paquetages multi-modules comme NumPy ou PIL de devoir sinquiter au sujet de leurs noms de modules. Supposez que vous vouliez concevoir une collection de modules (un paquetage) pour la manipulation uniforme des chiers de sons et des donnes de son. Il y a beaucoup de formats de chier de sons diffrents (habituellement reconnus par leur extension, par exemple : .wav, .ai, .au), ainsi vous pouvez avoir besoin de crer et mettre jour une collection grandissante de module pour la conversion entre les divers formats de chier. Il y a galement beaucoup doprations diffrentes que vous pourriez vouloir excuter sur des donnes de sons (comme le mixage, ajouter de lcho, appliquer une fonction dgalisation, crer un effet articiel de stro), ainsi en complment, vous crirez une srie interminable de modules pour raliser ces oprations. Voici une structure possible pour votre paquetage (exprim en termes de systme de chiers hirarchique) :
6.4. Paquetages
49
Sound/ __init__.py Formats/ __init__.py wavread.py wavwrite.py aiffread.py aiffwrite.py auread.py auwrite.py ... Effects/ __init__.py echo.py surround.py reverse.py ... Filters/ __init__.py equalizer.py vocoder.py karaoke.py ...
Paquetage de niveau suprieur Initialisation du paquetage sons Sous-paquetage pour la conversion des formats de fichiers
Sous-paquetage pour les effets sonores
Sous-paquetage pour les filtres
Quand on importe un paquetage, Python examine les rpertoires de sys.path la recherche du sous-rpertoire du paquetage. Les chiers __init__.py sont obligatoires pour que Python considre les rpertoires comme contenant des paquetages ; cela est fait pour empcher des rpertoires avec un nom commun, tel que string, de cacher involontairement les modules valides qui apparaissent plus tard dans le chemin de recherche de module. Dans le cas le plus simple, __init__.py peut juste tre un chier vide, mais doit pouvoir galement excuter du code dinitialisation pour le paquetage ou positionner la variable __all__, dcrite ci-dessous. Les utilisateurs du paquetage peuvent importer individuellement des modules du paquetage, par exemple :
import Sound.Effects.echo
Cela charge le sous-module Sound.Effects.echo. Il doit tre rfrenc avec son nom complet.
Sound.Effects.echo.echofilter(input, output, delay=0.7, atten=4)
Une autre solution pour importer le sous-module est :

from Sound.Effects import echo
Cela charge le sous-module echo, et le rend galement disponible sans son prxe de paquetage, ainsi il peut tre utilis comme suit :
echo.echofilter(input, output, delay=0.7, atten=4)
Une autre variante consiste encore importer la fonction ou la variable dsire directement :
from Sound.Effects.echo import echofilter
Encore une fois, cela charge le sous-module echo, et rend sa fonction echolter disponible directement :
echofilter(input, output, delay=0.7, atten=4)
50
Chapitre 6. Modules
Notez quen utilisant from paquetage import element, llment peut tre un sous-module (ou souspaquetage) du paquetage, ou un autre nom dni dans le paquetage, comme une fonction, une classe ou une variable. Linstruction import teste dabord si llment est dni dans le paquetage ; sinon, elle suppose que cest un module et essaye de le charger. Si elle ne le trouve pas, ImportError est dclench. Au contraire, en utilisant la syntaxe import element.souselement.soussouselement, chaque lment except le dernier doit tre un paquetage ; le dernier lment peut tre un module ou un paquetage mais ne peut pas tre une classe ou une fonction ou une variable dnie dans llment prcdent.
6.4.1
Importer * depuis un paquetage
Maintenant, quest-ce qui se produit quand lutilisateur crit from Sound.Effects import * ? Dans le meilleur des cas, on esprerait que cela sadresse dune faon ou dune autre au systme de chiers, trouve quels sous-modules sont prsents dans le paquetage, et les importe tous. Malheureusement, cette opration ne fonctionne pas trs bien sur des plate-formes Mac et Windows, o le systme de chiers na pas toujours des informations prcises sur la casse dun nom de chier ! Sur ces plate-formes, il ny a aucun moyen garanti de savoir si un chier ECHO.PY devrait tre import en tant que module echo, Echo ou ECHO. (Par exemple, Windows 95 a la fcheuse habitude de montrer tous les noms de chier avec une premire lettre en capitale.) La restriction de nom de chier DOS 8+3 ajoute un autre problme intressant pour les longs noms de modules. La seule solution est que lauteur de module fournisse un index explicite du module. Linstruction dimportation utilise la convention suivante : si le code __init__.py dun paquetage dnit une liste nomme __all__, celle-ci est utilise comme la liste des noms de modules qui doivent tre imports quand from paquetage import * est rencontr. Il appartient lauteur du paquetage de tenir cette liste jour quand une nouvelle version du paquetage est livre. Les auteurs de paquetage peuvent galement dcider de ne pas la supporter, sils ne souhaitent pas une utilisation dimportation par * de leur module. Par exemple, le chier Sounds/Effects/__init__.py pourrait contenir le code suivant :
__all__ = ["echo", "surround", "reverse"]
Cela signierait que from Sound.Effects import * importerait les trois sous-modules du paquetage Sound Si __all__ nest pas dni, linstruction from Sound.Effects import * nimporte pas dans lespace des noms actuel lensemble des sous-modules du paquetage Sound.Effects ; elle sassure seulement que le paquetage Sound.Effects a t import (probablement en excutant son code dinitialisation, __init__.py) et puis importe tous les noms dnis dans le module, quels quils soient. Cela inclut tout nom dni (et tout sousmodule charg explicitement) par __init__.py. Elle inclut galement tous les sous-modules du paquetage qui ont t chargs de faon explicite par des instructions dimportation prcdentes. Considrons ce code :
import Sound.Effects.echo import Sound.Effects.surround from Sound.Effects import *
Dans cet exemple, les modules echo et surround sont imports dans lespace des noms actuel parce quils sont dnis dans le paquetage Sound.Effects quand linstruction from...import est excute. (Cela fonctionne galement quand __all__ est dni.) Notez quen gnral la pratique de limportation par * dun module ou paquetage fait froncer les sourcils, puisquelle conduit souvent un code trs peu lisible. Cependant, il est correct de lemployer pour viter la saisie au clavier lors des sessions interactives, et parce que certains modules sont conus pour exporter seulement les noms qui correspondent certains motifs. Rappelez-vous, il ny a rien dincorrect utiliser from Paquetage import sous_module_specifique ! En fait, cest la notation recommande moins que le module importateur ne doive utiliser des sous-modules avec le mme nom, issus de paquetages diffrents.
6.4. Paquetages
51
6.4.2
Rfrences intra-paquetage
Les sous-modules doivent souvent se faire rfrence mututellement. Par exemple, le module surround pourrait utiliser le module echo. En fait, de telles rfrences sont si communes que linstruction import regarde dabord dans le paquetage contenant avant de regarder dans le chemin de recherche standard de module. Ainsi, le module surround peut simplement utiliser import echo ou from echo import echofilter. Si le module import nest pas trouv dans le paquetage actuel (le paquetage dont le module actuel est un sous-module), linstruction import recherche un module au niveau suprieur avec le nom donn. Quand des paquetages sont structurs dans des sous-paquetages (comme avec le paquetage Sound dans lexemple), il ny a aucun raccourci pour se rfrer des sous-modules des paquetages enfants de mmes parents le nom complet du sous-paquetage doit tre utilis. Par exemple, si le module Sound.Filters.vocoder doit utiliser le module echo du paquetage Sound.Effects, il peut utiliser from Sound.Effects import echo.
6.4.3
Paquetages dans des rpertoires multiples
Les paquetages possdent un attribut plus spcial, __path__. Celui-ci est initialis de manire tre une liste comportant le nom du rpertoire contenant les chiers __init__.py des paquetage, cette initialisation se faisant avant que le code contenu dans ces chiers soit excut. Cette variable peut tre modie ; faire cela affecte les recherches ultrieures de modules et de sous-paquetages contenus dans le paquetage. Cette possibilit nest pas souvent ncessaire, mais elle peut tre utilise pour tendre lensemble des modules qui se trouvent dans un paquetage.
52
Chapitre 6. Modules
CHAPITRE
SEPT
Entres et sorties
Il y a plusieurs manires de prsenter lafchage produit par un programme ; les donnes peuvent tre imprimes sous une forme humainement lisible, ou tre crites dans un chier pour un usage ultrieur. Ce chapitre prsentera certaines de ces possibilits.
7.1
Un formatage de sortie plus fantaisiste
Jusquici nous avons rencontr deux manires dafcher des valeurs : les instructions dexpression et linstruction print. (Une troisime manire est dutiliser la mthode write() des objets chier ; le chier de sortie standard peut tre rfrenc par sys.stdout. Voyez le manuel Library Reference pour plus dinformations.) Vous souhaiterez souvent avoir plus de contrle sur le formatage de vos sorties que dimprimer simplement des valeurs spares par des espaces. Il y a deux manires de formater vos sorties ; la premire manire est de faire toutes les manipulations de chanes de caractres vous-mme ; en utilisant les oprations de concatnation et de dcoupage de chanes de caractres, vous pouvez crer nimporte quel format que vous puissiez imaginer. Le module standard string contient quelques oprations utiles pour remplir des chanes de caractres une largeur de colonne donne ; celles-ci seront discutes sous peu. La deuxime manire est dutiliser loprateur % avec une chane de caractres comme argument de gauche, % interprte largument de gauche comme une chane de formatage comme pour la fonction sprintf() du langage C appliquer largument de droite, et retourne une chane de caractres rsultant de cette opration de formatage. Il reste naturellement une question : comment convertissez-vous des valeurs en chanes de caractres ? Heureusement, Python a des moyens de convertir nimporte quelle valeur en chane de caractres : passez-la la fonction repr(), ou crivez juste la valeur entre des guillemets renverss (anti-quotes : , quivalent repr()). La fonction str() est faite pour renvoyer des reprsentatuons de valeurs qui sont assez faciles lire par les humains, alors que repr() est faite pour gnrer des reprsentations qui puissent tre lues par linterprteur (ou gnrer une SyntaxError sil ny a pas de syntaxe quivalente). Pour des objets qui nont pas de reprsentation particulire pour la consommation humaine, str() renverra la mme valeur que repr(). De nombreuses valeurs, comme les nombres ou les structures comme les listes et les dictionnaires, ont la mme reprsentation dans les deux fonctions. Les chanes et les nombres virgule ottante, en particulier, ont deux reprsentations distinctes. Quelques exemples :
53
>>> s = Salut, tout le monde. >>> str(s) Salut, tout le monde. >>> s "Salut, tout le monde." >>> str(0.1) 0.1 >>> 0.1 0.10000000000000001 >>> x = 10 * 3.25 >>> y = 200 * 200 >>> s = La valeur de x est + x + , et y est + y + ... >>> print s La valeur de x est 32.5, et y est 40000... >>> # Les anti-quotes marchent avec dautres types en dehors des nombres: ... p = [x, y] >>> ps = repr(p) >>> ps [32.4, 40000] >>> # Convertir une chane ajoute des quotes de chane et des antislash: ... salut = salut, monde\n >>> saluts = salut >>> print saluts salut, monde\n >>> # Largument des anti-quotes peut tre un tuple: ... x, y, (spam, eggs) "(32.5, 40000, (spam, eggs))"
Voici deux manires dcrire une table des carrs 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 prcdente ... 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 quun espace entre chaque colonne a t ajout cause de la faon dont print fonctionne : elle ajoute
54
Chapitre 7. Entres et sorties
toujours des espaces entre ses arguments.) Cet exemple prsente la fonction string.rjust(), qui justie droite une chane de caractres dans un champ dune largeur donne en la compltant avec des espaces du ct gauche. Il y a les fonctions semblables string.ljust() et string.center(). Ces fonctions ncrivent rien, elles renvoient juste une nouvelle chane de caractres. Si la chane de caractres dentre est trop longue, elles ne la tronquent pas, mais la renvoient sans changement ; cela gchera votre prsentation de colonne mais cest habituellement mieux que lalternative, qui serait de tricher au sujet dune valeur. (Si vous voulez vraiment la troncature vous pouvez toujours ajouter une opration de dcoupage, comme string.ljust(x, n)[0 :n].) Il y a une autre fonction, string.zfill(), qui complte une chane de caractres numrique du ct gauche avec des zros. Elle sait grer les signes positifs et ngatifs :
>>> import string >>> string.zfill(12, 5) 00012 >>> string.zfill(-3.14, 7) -003.14 >>> string.zfill(3.14159265359, 5) 3.14159265359
Lutilisation de loprateur % ressemble ceci :

>>> import math >>> print La valeur de PI est approximativement %5.3f. % math.pi La valeur de PI est approximativement 3.142.
Sil y a plus dun descripteur de format dans la chane de caractres, vous devez passer un tuple comme oprande de droite, comme dans cet 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 largument correspondant nest pas un objet chane de caractres, il est converti en chane de caractres en utilisant la fonction intgre str(). Utiliser * pour passer la largeur ou la prcision comme argument (entier) spar est possible. Les formats %n et %p du C ne sont pas supports. Si vous avez une chane de caractres de formatage vraiment longue que vous ne voulez pas fractionner, il serait lgant de pouvoir rfrencer les variables formater par leur nom et pas par leur position. Cela peut tre fait en utilisant la forme %(name)format, comme montr ici :
>>> table = {Sjoerd: 4127, Jack: 4098, Dcab: 8637678} >>> print Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d % table Jack: 4098; Sjoerd: 4127; Dcab: 8637678
Cest particulirement utile en combinaison avec la fonction intgre vars(), qui renvoie un dictionnaire contenant toutes les variables locales.
7.1. Un formatage de sortie plus fantaisiste
55
7.2
Lire et crire des chiers
open() renvoie un objet de type chier, et est utilise plus gnralement avec deux arguments : open(nomchier, mode).
>>> f=open(/tmp/fichiertravail, w) >>> print f <open file /tmp/fichiertravail, mode w at 80a0960>
Le premier argument est une chane de caractres contenant le nom du chier. Le deuxime argument est une autre chane de caractres contenant quelques caractres dcrivant la manire dutiliser le chier. mode vaut r quand le chier doit tre seulement lu, w pour seulement crit (un chier dj existant avec le mme nom sera effac), et a ouvre le chier en ajout ; les donnes crites dans le chier seront automatiquement ajoutes la n. r+ ouvre le chier pour la lecture et lcriture. Largument mode est facultatif ; r sera pris par dfaut sil est omis. Sur Windows et Macintosh, b ajout au mode ouvre chier en mode binaire, donc il y a aussi des modes comme rb, wb, et r+b. Windows fait la distinction entre chier texte et binaire ; les caractres de n de ligne dans des chiers texte sont automatiquement modis lgrement quand des donnes sont lues ou crites. Cette modication imperceptible des donnes du chier marche trs bien pour des chiers textes ASCII, mais elle altrera des donnes binaires comme dans des chiers JPEG ou .EXE. Faites trs attention utiliser le mode binaire en lisant et en crivant de tels chiers. (notez que la smantique prcise du mode texte sur le Macintosh dpend de la bibliothque C utilise.)
7.2.1
Mthodes des objets chiers
Le reste des exemples dans cette section supposera quun objet chier appel f a dj t cr. Pour lire le contenu dun chier, appeler f.read(taille), qui lit une certaine quantit de donnes et les retourne en tant que chane de caractres. taille est un argument numrique facultatif. Quand taille est omis ou ngatif, le contenu entier du chier sera lu et retourn ; cest votre problme si le chier est deux fois plus grand que la mmoire de votre machine. Autrement, au plus taille octets sont lus et retourns. Si la n du chier a t atteinte, f.read() renverra une chane de caractres vide ("").
>>> f.read() Ceci est le fichier entier.\n >>> f.read()
f.readline() lit une seule ligne partir du chier ; un caractre de n de ligne (\n) est laiss lextrmit de la chane de caractres lue, et est seulement omis sur la dernire ligne du chier si le chier ne se termine pas par une n de ligne. Cela rend la valeur de retour non ambigu ; si f.readline() renvoie une chane de caractres vide, la n du chier a t atteinte, alors quune n de ligne est reprsente par \n, une chane de caractres contenant seulement une seule n de ligne.
>>> f.readline() Ceci est la premire ligne du fichier.\n >>> f.readline() Deuxime ligne du fichier\n >>> f.readline()
f.readlines() renvoie une liste contenant toutes les lignes de donnes dans le chier. Si un paramtre optionnel sizehint est donn, alors elle lit le nombre doctets indiqu, plus autant doctets quil en faut pour complter la dernire ligne commence, et renvoie la liste des lignes ainsi lues. Cela est souvent utile pour permettre la lecture par lignes efcace, sans devoir charger entirement le chier en mmoire. La liste retourne est entirement faite de lignes compltes. 56 Chapitre 7. Entres et sorties
>>> f.readlines() [Ceci est la premire ligne du fichier.\n, Deuxime ligne du fichier\n]
Une approche alternative de la lecture de lignes est de boucler sur lobjet chier. Cela utilise moins de mmoire, est rapide et produit un code plus simple :
>>> for line in f: print line, Ceci est la premire ligne du fichier. Deuxime ligne du fichier
Cette mthode alternative est plus simple, mais elle ne permet pas un contrle n. Puisque les deux approches grent diffremment la mise en tampon des lignes, elles ne doivent pas tre mlanges. f.write(chaine) crit le contenu de chaine dans le chier, en retournant None.
>>> f.write(Voici un test\n)
Pour crire quelque chose dautre quune chane il est ncessaire de commencer par le convertir en chane :
>>> value = (the answer, 42) >>> s = str(value) >>> f.write(s)
f.tell() renvoie un nombre entier donnant la position actuelle dans le chier associ lobjet chier, mesure en octets depuis le dbut du chier. Pour changer la position dans lobjet chier, employez f.seek(decalage, point_depart). La position est calcule en ajoutant decalage un point de rfrence ; le point de rfrence est choisi par largument point_depart. Une valeur de 0 pour point_depart fait dmarrer au dbut du chier, 1 utilise la position courante du chier, et 2 utilise la n de chier comme point de rfrence. point_depart peut tre omis et prend alors 0 pour valeur par dfaut comme point de rfrence.
>>> >>> >>> >>> 5 >>> >>> d f=open(/tmp/fichiertravail, r+) f.write(0123456789abcdef) f.seek(5) # Saute jusquau 6me octet dans le fichier f.read(1) f.seek(-3, 2) # Saute jusquau 3me octet avant la fin f.read(1)
Quand vous en avez termin avec un chier, appeler f.close() pour le fermer et librer toutes les ressources systme utilises par le chier ouvert. Aprs avoir appel f.close(), les tentatives dutiliser lobjet chier choueront automatiquement.
>>> f.close() >>> f.read() Traceback (most recent call last): File "<stdin>", line 1, in ? ValueError: I/O operation on closed file
Les objets chier ont quelques mthodes supplmentaires, telles que isatty() et truncate() qui sont moins frquemment utilises ; consultez la Library Reference pour un guide complet des objets chier.
7.2. Lire et crire des chiers
57
7.2.2
Le module pickle
Les chanes de caractres peuvent facilement tre crites et lues dans un chier. Les nombres demandent un peu plus deffort, puisque la mthode read() renvoie seulement les chanes de caractres, qui devront tre passes vers une fonction comme int(), qui prend une chane de caractres comme 123 et renvoie sa valeur numrique 123. Cependant, quand vous voulez sauvegarder des types de donnes plus complexes comme des listes, des dictionnaires, ou des instances de classe, les choses deviennent beaucoup plus compliques. Plutt que faire crire et dboguer constamment par les utilisateurs le code pour sauvegarder des types de donnes complexes, Python fournit un module standard appel pickle. Cest un module tonnant qui peut prendre presque nimporte quel objet Python (mme quelques formes de code Python !), et le convertir en une reprsentation sous forme de chane de caractres ; ce processus sappelle pickling. Reconstruire lobjet partir de sa reprsentation en chane de caractres sappelle unpickling. Entre pickling et unpickling, la chane de caractres reprsentant lobjet a pu avoir t enregistre dans un chier ou des donnes, ou avoir t envoye une machine loigne via une connexion rseau. Si vous avez un objet x, et un objet chier f ouvert en criture, la voie la plus simple de pickler lobjet prend seulement une ligne de code :
pickle.dump(x, f)
Pour unpickler lobjet, si f est un objet chier ouvert en lecture :

x = pickle.load(f)
(il y a dautres variantes pour cela, utilises pour pickler beaucoup dobjets ou quand vous ne voulez pas crire les donnes pickles dans un chier ; consultez la documentation complte pour pickle dans la Library Reference.) pickle est le moyen standard pour enregistrer des objets Python et les rutiliser dans dautres programmes ou dans une future invocation du mme programme ; le terme technique pour cela est la persistance dun objet. Puisque pickle est trs largement rpandu, beaucoup dauteurs qui crivent des extensions pour Python prennent soin de sassurer que de nouveaux types de donnes tels que des matrices peuvent tre correctement pickls et unpickls.
58
Chapitre 7. Entres et sorties
CHAPITRE
HUIT
Erreurs et exceptions
Jusquici nous avons peine mentionn les messages derreur, mais si vous avez essay les exemples vous en avez certainement crois. Il y a (au moins) deux types distincts derreurs : les erreurs de syntaxe et les exceptions.
8.1
Erreurs de syntaxe
Les erreurs de syntaxe, ou erreurs dinterprtation, sont peut-tre les formes de messages derreur les plus courantes que vous rencontrerez pendant votre apprentissage de Python :
>>> while 1 print Bonjour File "<stdin>", line 1, in ? while 1 print Bonjour ^ SyntaxError: invalid syntax
Linterprteur afche la ligne o lerreur a eu lieu, et une petite che qui marque le premier point de la ligne o lerreur a t dtecte. Lerreur est cause par le (ou du moins dtecte au) lexme qui prcde la che : dans lexemple, lerreur est dtecte au mot-cl print, vu quil manque un deux-points ( :) juste avant. Un nom et un numro de ligne de chier sont aussi donns pour que vous sachiez o aller regarder si les commandes proviennent dun script.
8.2
Exceptions
Mme lorsquune instruction ou une expression est syntaxiquement correcte, elle peut provoquer une erreur lorsquon essaye de lexcuter. Les erreurs dtectes lexcution sont appeles exceptions et ne sont pas fatales : vous allez bientt apprendre les grer dans des programmes Python. Nanmoins, la plupart des exceptions nest pas gre par un programme et entrane des messages derreur comme ci-dessous :
>>> 10 * (1/0) Traceback (most recent call last): File "<stdin>", line 1, in ? ZeroDivisionError: integer division or modulo >>> 4 + spam*3 Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: spam >>> 2 + 2 Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: illegal argument type for built-in operation
59
La dernire ligne du message derreur indique ce qui sest pass. Les exceptions peuvent tre de plusieurs types, le type est crit dans le message : dans lexemple, les types sont ZeroDivisionError (erreur de division par zro), NameError (erreur de nom) et TypeError (erreur de type). La chane de caractres afche comme type de lexception est le nom intgr pour lexception qui a eu lieu. Cest le cas pour toutes les exceptions intgres, mais pas forcment pour les exceptions dnies par lutilisateur (mme si cest une convention utile). Les noms des exceptions standard sont des identiants intgrs (et non des mots-cls rservs). Le reste de la ligne contient des dtails, dont linterprtation dpend du type de lexception. La partie prcdant le message derreur afche le contexte dans lequel lexception a eu lieu, sous forme de trace de la pile. En gnral, elle contient une trace de pile avec des lignes de code source ; toutefois, les lignes lues depuis lentre standard ne seront pas afches. La Python Library Reference donne la liste des exceptions intgres et leur signication.
8.3
Gestion des exceptions
Il est possible dcrire des programmes qui prennent en charge des exceptions spciques. Regardez lexemple suivant, qui interroge lutilisateur jusqu ce quun entier valide ait t saisi, mais lui permet dinterrompre le programme en utilisant Control-C ou une autre combinaison de touches reconnue par le systme dexploitation (il faut savoir quune interruption produite par lutilisateur est signale en levant lexception KeyboardInterrupt).
>>> while 1: ... try: ... x = int(raw_input("Veuillez entrer un nombre: ")) ... break ... except ValueError: ... print "Aille! Ce ntait pas un nombre valide. Essayez encore..." ...
Linstruction try fonctionne ainsi : Dabord, la clause dessai (clause try : les instructions entre les mots-cls try et except) est excute. Sil ne se produit pas dexception, la clause dexception (clause except) est ignore, et lexcution du try est termine. Si une exception se produit un moment de lexcution de la clause dessai, le reste de la clause try est ignor. Puis si son type correspond lexception donne aprs le mot-cl except, la clause except est excute, puis lexcution reprend aprs linstruction try. Si une exception se produit qui ne correspond pas lexception donne dans la clause except, elle est renvoye aux instructions try extrieures ; sil ny a pas de prise en charge, il sagit dune exception non gre et lexcution est arrte avec un message, comme vu prcdemment. Une instruction try peut avoir plus dune clause dexception, de faon dnir des gestionnaires dexception diffrents pour des exceptions diffrentes. Au plus une clause dexception sera excute. Dans une clause dexception ne seront gres que les exceptions survenant dans la clause dessai correspondante, et non pas celles provenant dautres clauses dexception. Une clause dexception peut nommer plusieurs exceptions dans une liste parenthse, par exemple :
... except (RuntimeError, TypeError, NameError): ... pass
La dernire clause dexception peut omettre le(s) nom(s) dexception, et sert alors de passe-partout. Utilisez cela avec une prcaution extrme : il est facile de cacher de cette faon une vraie erreur de programmation !
60
Chapitre 8. Erreurs et exceptions
import string, sys try: f = open(monfichier.txt) c = f.readline() i = int(string.strip(c)) except IOError, (errno, strerror): print "Erreur(s) E/S: c" (errno, strerror) except ValueError: print "Na pas pu convertir la donne en entier." except: print "Erreur non prvue:", sys.exc_info()[0] raise
Linstruction try. . .except admet une clause par dfaut (clause else) qui doit suivre toutes les clauses dexception. Elle est utile pour placer le code qui doit tre excut si la clause dessai ne dclenche pas dexception. Par exemple :
for arg in sys.argv[1:]: try: f = open(arg, r) except IOError: print impossible douvrir, arg else: print arg, comporte, len(f.readlines()), lignes f.close()
Lutilisation de la clause else est meilleure que lajout dun code supplmentaire la clause try parce quelle vite dintercepter de faon accidentelle une exception qui na pas t dclenche par le code qui est protg par linstruction try . . . except. Quand une exception survient, elle peut avoir une valeur associe, appele aussi largument de lexception. La prsence et le type de largument dpendent du type de lexception. La clause dexception peut spcier une variable aprs le nom de lexcption (ou la liste). La variable sera lie une instance de lexception, avec les arguments rangs dans instance.args. Par commodit, linstance de lexception dnit __getitem__ et __str__, ainsi les arguments peuvent tre accds ou imprims directement sans avoir rfrencer .args.
>>> try: ... raise Exception(spam, eggs) ... except Exception, inst: ... print type(inst) # the exception instance ... print inst.args # arguments stored in .args ... print inst # __str__ allows args to printed directly ... x, y = inst # __getitem__ allows args to be unpacked directly ... print x =, x ... print y =, y ... <type instance> (spam, eggs) (spam, eggs) x = spam y = eggs
Si une exception a un argument, celui-ci sera afch dans la dernire partie (dtail) du message pour une exception non gre. Les clauses dexception ne prennent pas en charge uniquement les exceptions qui surviennent dans la clause
8.3. Gestion des exceptions
61
dessai, mais aussi celles qui surviennent dans les fonctions appeles (mme de faon indirecte) dans la clause dessai. Par exemple :
>>> def ceci_ne_marche_pas(): ... x = 1/0 ... >>> try: ... ceci_ne_marche_pas() ... except ZeroDivisionError, detail: ... print Gestion derreur lexcution:, detail ... Gestion derreur lexcution: integer division or modulo
8.4
Dclencher des exceptions
Linstruction raise permet au programmeur de dclencher une exception. Par exemple :

>>> raise NameError, Coucou Traceback (innermost last): File "<stdin>", line 1, in ? NameError: Coucou
Le premier argument de raise nomme lexception qui doit tre dclenche. Le second argument (optionnel) spcie largument de lexception. Si vous avez besoin de dterminer si une exception est leve mais ne souhaitez pas la trater, une forme plus simple de linstruction raise permet de re-dclencher lexception :
>>> try: ... raise NameError, SalutToi ... except NameError: ... print Une exception au vol! ... raise ... Une exception au vol! Traceback (most recent call last): File "<stdin>", line 2, in ? NameError: SalutToi
8.5
Exceptions dnies par lutilisateur
Les programmes peuvent nommer leurs propres exceptions en crant une nouvelle classe dexception. Les exceptions devraient typiquement tre drives de la classe Exception, soit directement, soit indirectement. Par exemple :
62
>>> class MonErreur(Exception): ... def __init__(self, valeur): ... self.valeur = valeur ... def __str__(self): ... return self.valeur ... >>> try: ... raise MonErreur(2*2) ... except MonErreur, e: ... print Mon exception sest produite, valeur:, e.valeur ... Mon exception sest produite, valeur: 4 >>> raise MonErreur, zut! Traceback (most recent call last): File "<stdin>", line 1, in ? __main__.MonErreur: zut!
Dans cet exemple, la mthode __init__ de Exception a t surcharge. Le nouveau comportement cre simplement lattribut valeur. Cela remplace le comportement par dfaut qui est de crer lattribut args. Des classes dexceptions peuvent tre dnies qui font tout ce que dautres classes peuvent faire, mais sont gnralement gardes assez simples, offrant souvent seulement un certain nombre dattributs qui permettent de donner des informations sur lerreur qui soient extraits par les gestionaires pour cette exception. Quand on cre un module qui peut dclencher plusieurs erreurs distinctes, une pratique courante est de crer une classe de base pour les exceptions dnies par ce module, et des sous-classes de celle-ci pour crer des classes dexceptions spciques pour diffrentes conditions derreurs :
class Erreur(Exception): """Classe de base pour les exceptions dans ce module.""" pass class EntreeErreur(Erreur): """Exception dclenche pour les erreurs dans lentre. Attributs: expression -- expression dentre sur laquelle lerreur sest produite message -- explication de lerreur """ def __init__(self, expression, message): self.expression = expression self.message = message class TransitionErreur(Erreur): """Dclenche quand une opration tente deffectuer une transition dtat qui nest pas autorise. Attributs: precedent -- tat au dbut de la transition suivant -- nouvel tat essay message -- explication de pourquoi cette transition spcifique nest pas autorise """ def __init__(self, self.precedent self.suivant = self.message = precedent, suivant, message): = precedent suivant message
La plupart des exceptions sont dnies avec des noms qui se terminent en Error, de faon similaire au nommage des exceptions standard.
8.5. Exceptions dnies par lutilisateur
63
Plusieurs modules standard dnissent leurs propres exceptions pour rapporter les erreurs qui peuvent survenir dans les fonctions quils dnissent. Plus dinformations au sujet des classes sont donnes dans le chapitre 9, Classes.
8.6
Dnir les actions de nettoyage
Linstruction try admet une autre clause optionnelle qui permet de dnir les actions de nettoyage qui doivent tre excutes imprativement. Par exemple :
>>> try: ... raise KeyboardInterrupt ... finally: ... print Adieu, monde! ... Adieu, monde! Traceback (most recent call last): File "<stdin>", line 2, in ? KeyboardInterrupt
Une clause de nalisation (clause nally) est excute quune exception ait eu lieu ou non dans la clause dessai. Si une exception a t dclenche, elle est dclenche nouveau aprs lexcution de la clause de nalisation. La clause de nalisation est aussi excute en sortant lorsque linstruction try est interrompue par les instructions break ou return. Le code dans la clause nally est utile pour librer des ressources externes (telles que des chiers ou des connections rseau), indpendamment du fait que lutilisation de la ressource ait t russie. Une instruction try doit avoir ou bien une ou plusieurs clauses dexception, ou bien une clause de nalisation, mais pas les deux.
64
CHAPITRE
NEUF
Classes
Le mcanisme de classe en Python permet dintroduire les classes avec un minimum de syntaxe et smantique nouvelles. Cest un mlange des mcanismes de classe de C++ et Modula-3. Comme les modules, les classes en Python ninstallent pas de barrire absolue entre la dnition et lutilisateur, mais appellent plutt la politesse de lutilisateur pour viter leffraction de la dnition. Les caractristiques les plus importantes des classes sont pleinement prsentes : le mcanisme dhritage permet la multiplicit des classes de base, une classe drive peut surcharger nimporte quelle mthode de sa ou ses classes de base, une mthode peut appeler une mthode de sa classe de base avec le mme nom. Les objets peuvent contenir un nombre arbitraire de donnes prives. Dans la terminologie du C++, tous les membres dune classe (dont les donnes membres) sont publics, et toutes les fonctions membres sont virtuelles. Il ny a pas de constructeurs ou de destructeurs particuliers. Comme en Modula-3, il ny a pas de raccourcis pour faire rfrence aux membres dun objet partir de ses mthodes : une mthode est dclare avec un premier argument explicite qui reprsente lobjet, qui est fourni implicitement lappel. Comme en Smalltalk, les classes sont elles-mmes des objets, mais dans un sens plus large : en Python, tous les types de donnes sont des objets. Cela fournit la smantique pour limportation et le renommage. Mais, comme en C++ et en Modula-3, les types intgrs ne peuvent pas tre utiliss comme classes de base pour des extensions par lutilisateur. En plus, comme en C++ mais contrairement Modula-3, la plupart des oprateurs intgrs qui ont une syntaxe particulire (oprateurs arithmtiques, indiage, etc.) peuvent tre rednis pour des instances de classe.
9.1
Un mot sur la terminologie
A dfaut dune terminologie universellement accepte pour parler des classes, jutiliserai loccasion des termes de Smalltalk et C++. (Jutiliserais volontiers des termes de Modula-3, puisque sa smantique oriente objet est plus proche de celle de Python que celle de C++, mais jimagine que peu de lecteurs ont entendu parler de ce langage.) Les objets possdent une individualit, et des noms multiples (dans des portes multiples) peuvent tre lis au mme objet. Cela sappelle aliasing dans dautres langages. On ne le remarque pas de prime abord dans Python, et on peut lignorer pour le traitement des types de base non modiables (nombres, chanes de caractres, tuples). Nanmoins, laliasing a un effet (voulu !) sur la smantique du code Python qui met en jeu des objets modiables comme listes, dictionnaires et la plupart des types reprsentant des entits lexception du programme (chiers, fentres, etc.). Cela est mis prot dans les programmes, puisque les alias se comportent comme des pointeurs plusieurs points de vue. Par exemple, le passage en paramtre dun objet nest pas coteux puisque seul un pointeur est transmis par limplmentation ; et si une fonction modie un objet reu en argument, lappelant verra la modication ce qui limine le besoin davoir deux mcanismes de passage darguments comme en Pascal.
9.2
Les portes et les espaces de noms en Python
Avant dintroduire les classes, je dois vous dire quelques mots sur les rgles de porte en Python. Les dnitions de classe jouent astucieusement avec les espaces de noms, et vous devez savoir comment fonctionnent les portes et les espaces de noms pour comprendre ce qui se passe. En fait, la connaissance de ce sujet est utile tout programmeur Python avanc.
65
Dabord quelques dnitions. Un espace de noms (name space) est une relation entre des noms et des objets. La plupart des espaces de noms sont actuellement implments comme des dictionnaires, mais cela nest pas visible (sauf sur les performances peut-tre) et pourrait changer dans le futur. Quelques exemples despaces de noms : lensemble des noms intgrs (les fonctions telles que abs(), et les noms dexception intgrs) ; les noms globaux dans un module ; les noms locaux au cours dun appel de fonction. En un sens, lensemble des attributs dun objet constitue aussi un espace de noms. La chose importante savoir sur les espaces de noms est quil ny a absolument aucune relation entre les noms contenus dans les diffrents espaces de noms ; par exemple, deux modules diffrents peuvent dnir tous les deux une fonction maximise sans confusion possible les utilisateurs des modules doivent prxer par le nom du module lutilisation. Au passage, jutilise le mot attribut (attribute) pour nimporte quel nom qui suit un point par exemple, dans lexpression z.real, real est un attribut de lobjet z. Strictement parlant, les rfrences des noms dans des modules sont des attributs ; dans lexpression nommod.nomfonc, nommod est un objet module et nomfonc en est un attribut. Dans ce cas, il y a un rapport direct entre les attributs du module et les noms globaux dnis dans le module : ils partagent le mme espace de noms !1 Les attributs peuvent tre en lecture seule ou bien modiables. Dans ce cas, on peut affecter des valeurs des attributs. Les attributs dun module sont modiables : vous pouvez faire nommod.la_reponse = 42. Les attributs modiables peuvent aussi tre effacs avec linstruction del. Par exemple, del nommod.la_reponse enlvera lattribut la_reponse de lobjet nomm par nommod. Les espaces de noms sont crs des moments diffrents et ont des dures de vie diffrentes. Lespace de noms qui contient les noms intgrs est cr au lancement de linterprteur Python, et nest jamais effac. Lespace de noms global pour un module est cr quand la dnition du module est charge ; normalement, les espaces de noms des modules vivent jusqu la mort de linterprteur. Les instructions excutes linvocation de linterprteur par le niveau suprieur, quelles soient lues depuis un chier ou entres de faon interactive, sont considres comme faisant partie dun module appel __main__, elles ont donc leur propre espace de noms global. (En fait, les noms intgrs font aussi partie dun module appel __builtin__.) Lespace de noms local une fonction est cr quand celle-ci est appele et il est effac quand la fonction se termine ou dclenche une exception qui nest pas gre dans la fonction. (En fait, oubli dcrit mieux ce qui se passe vraiment.) Evidemment, les appels rcursifs ont chacun leur propre espace de noms. Une porte (scope) est une rgion textuelle dun programme Python dans laquelle un espace de noms est directement accessible. Directement accessible veut dire quune rfrence non qualie un nom cherchera ce nom dans cet espace de noms. Bien quelles soient dtermines statiquement, les portes sont utilises dynamiquement. A nimporte quel moment de lexcution, exactement trois portes imbriques sont utilises (exactement trois espaces de noms sont accessibles directement) : la porte immdiate, qui est explore en premier, contient les noms locaux, la porte intermdiaire, explore ensuite, contient les noms globaux du module courant, et la porte extrieure (explore en dernier) correspond lespace de noms contenant les noms intgrs. Si un nom est dclar global alors les rfrences et affectations le concernant sont directement adresses la porte qui contient les noms globaux du module. En labsence dune telle dclaration, toutes les variables trouves ailleurs que dans la porte la plus intrieure sont en lecture seulement (une tentative daffectation une telle variable crera simplement une nouvelle variable locale dans la porte la plus intrieure, laissant inchange la variable extrieure qui a le mme nom). Normalement, la porte locale fait rfrence aux noms de la fonction courante (textuellement). En dehors des fonctions, la porte locale fait rfrence au mme espace de noms que la porte globale : lespace de noms du module. Les dnitions de classe placent encore un autre espace de noms dans la porte locale. Il est important de voir que les portes sont dtermines de faon textuelle : la porte globale dune fonction dnie dans un module est lespace de noms de ce module, peu importe do ou travers quel alias cette fonction est appele. Dun autre ct, la recherche de noms elle-mme est effectue dynamiquement, l excution toutefois, la dnition du langage tend voluer vers la rsolution statique de noms, au moment de la compilation, alors ne vous basez pas sur la rsolution dynamique de noms ! (En fait, les variables locales sont dj dtermines
1 Sauf pour une chose. Les objets module possdent un attribut secret en lecture exclusive qui sappelle __dict__ et qui renvoie le dictionnaire utilis pour implmenter lespace de noms du module ; le nom __dict__ est un attribut mais pas un nom global. Evidemment, lutiliser casse labstraction de l implmentation des espaces de noms, et son usage doit tre restreint des choses telles que les dbogueurs post-mortem.
66
Chapitre 9. Classes
de faon statique.) Un point titilleux de Python est que les affectations se font toujours dans la porte immdiate. Laffectation ne copie pas de donnes elle ne fait quaffecter un nom un objet. Cela est vrai aussi de leffacement : linstruction del x enlve le lien vers x de lespace de noms rfrenc par la porte locale. En fait, toute opration qui introduit de nouveaux noms utilise la porte locale : en particulier, les instructions dimportation et les dnitions de fonction lient le nom du module ou de la fonction la porte locale. (Linstruction global peut tre utilise pour indiquer que certaines variables vivent dans la porte globale.)
9.3
Une premire approche des classes
Les classes introduisent un peu de syntaxe nouvelle, trois nouveaux types dobjet, et quelques points de smantique supplmentaires.
9.3.1
Syntaxe de la dnition de classe
La forme la plus simple de dnition de classe ressemble ceci :

class NomClasse: <instruction-1> . . . <instruction-N>
Les dnitions de classe, comme les dnitions de fonction (instructions def) doivent tre excutes pour entrer en effet. (Vous pourriez placer une dnition de classe dans une branche dune instruction if, ou lintrieur dune fonction.) Dans la pratique, les instructions lintrieur dune dnition de classe seront souvent des dnitions de fonction, mais dautres instructions sont acceptes, et parfois savrent utiles plus de dtails sur le sujet ci-dessous. Les dnitions de fonction lintrieur dune classe ont normalement une forme particulire de liste darguments, dicte par les conventions dappel de mthode cela aussi est expliqu plus loin. A lentre dune dnition de fonction, un nouvel espace de noms est cr et utilis comme porte locale ainsi, toute affectation de variables rentre dans cet espace de noms. En particulier, les dnitions de fonctions y rattachent le nom des nouvelles fonction. Lorsque la dnition de la classe est acheve de faon normale (par la n), un objet classe (class object) est cr. Il sagit essentiellemnt dun enrobage autour du contenu de lespace de noms cr par la dnition de classe ; nous verrons davantage de caractristiques des objets classes dans la section suivante. La porte locale dorigine (celle en cours avant le dbut de la dnition de classe) est rinstalle, et lobjet classe est li ici au nom donn dans len-tte de la dnition de classe (NomClasse dans lexemple).
9.3.2
Objets classes
Les objets classe admettent deux sortes doprations : la rfrenciation des attributs et linstanciation. Les rfrences aux attributs (attribute references) utilisent la syntaxe standard utilise pour toutes les rfrences dattribut en Python : obj.nom. Les noms dattribut valides sont ceux qui taient dans lespace de noms de la classe quand lobjet classe a t cr. Donc, si la dnition de classe ressemble :
9.3. Une premire approche des classes
67
class MaClasse: "Une classe simple pour exemple i = 12345 def f(self): return bonjour
alors MaClasse.i et MaClasse.f sont des rfrences dattribut valides, qui renvoient un entier et un objet fonction, respectivement. On peut affecter une valeur aux attributs de classe, donc vous pouvez changer la valeur de MaClasse.i par affectation. __doc__ est un attribut valide, en lecture exclusive, qui renvoie la docstring correspondant la classe : "Une classe simple pour exemple"). Linstantiation de classe utilise la notation dappel de fonction. Faites comme si lobjet classe tait une fonction sans paramtres qui renvoie une instance nouvelle de la classe. Par exemple, (avec la classe prcdente) :
x = MaClasse()
cre une nouvelle instance de la classe et affecte cet objet la variable locale x. Lopration dinstanciation (appeller un objet classe) cre un objet vide. De nombreuses classes aiment crer les objets dans un tat initial connu. Ainsi une classe peut dnir une mthode spciale nomme __init__(), comme ceci :
def __init__(self): self.donnee = []
Quand une classe dnit une mthode __init__(), linstanciation de la classe appelle automatiquement __init__() pour linstance de la classe nouvellement cre. Ainsi, dans cet exemple, une instance nouvelle, initialise, peut tre obtenue par :
x = MaClasse()
Bien-sr, la mthode __init__() peut avoir des arguments pour offrir plus de souplesse. Dans ce cas, les arguments fournis loprateur dinstanciation de la classe sont passs __init__(). Par exemple,
>>> class Complexe: ... def __init__(self, partiereelle, partieimaginaire): ... self.r = partiereelle ... self.i = partieimaginaire ... >>> x = Complexe(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)
9.3.3
Objets instances
Que peut-on faire avec les objets instances ? Les seules oprations acceptes par des objets instance sont des rfrences leurs attributs. Il y a deux sortes de noms dattributs valides. Jappellerai la premire donnes attributs (data attributes). Ils correspondent aux variables dinstance (instance variables) en Smalltalk, et aux donnes membres (data members) en C++. Les donnes attributs nont pas besoin dtre dclares ; comme les variables locales, elles apparaissent lorsquon leur affecte une valeur pour la premire fois. Par exemple, si x est linstance de MaClasse cre prcdemment, le morceau de code suivant afchera la valeur 16, sans laisser de trace :
68
Chapitre 9. Classes
x.compteur = 1 while x.compteur < 10: x.compteur = x.compteur * 2 print x.compteur del x.compteur
La seconde sorte de rfrence dattribut accepte par les objets instance sont les mthodes (methods). Une mthode est une fonction qui appartient un objet. (En Python, le terme mthode nest pas exclusif aux instances de classe : dautres types dobjet peuvent avoir des mthodes. Par exemple, les objets liste ont des mthodes appeles append, insert, remove, sort, etc. Nanmoins, dans ce qui suit, nous allons utiliser le terme mthode pour dsigner exclusivement les mthodes dun objet instance de classe, sauf mention explicite.) Les noms de mthodes valides pour un objet instance dpendent de sa classe. Par dnition, tous les attributs dune classe qui sont des fonctions (dnies par lutilisateur) dnissent des mthodes correspondantes pour les instances. Ainsi, dans notre exemple, x.f est une rfrence valide une mthode, puisque MaClasse.f est une fonction, mais x.i ne lest pas, vu que MaClasse.i ne lest pas. Toutefois x.f nest pas la mme chose que MaClasse.f cest un objet mthode (method object), et non pas un objet fonction.
9.3.4
Objets mthodes
Dhabitude, une mthode est appele de faon directe :

x.f()
Dans notre exemple, cela renverrait la chane salut monde. Or, il nest pas ncessaire dappeler une mthode tout de suite : x.f est un objet mthode, il peut tre rang quelque part et tre appel plus tard, par exemple :
xf = x.f while 1: print xf()
continuera afcher bonjour jusqu la n des temps. Que se passe-t-il exactement lorsquune mthode est appele ? Vous avez peut-tre remarqu que x.f() a t appele sans argument ci-dessus, alors que la dnition de fonction pour f en spciait un. Quest-il arriv largument ? On se doute bien que Python dclenche une exception quand une fonction qui requiert un argument est appele sans argument mme si largument nest pas effectivement utilis. . . En fait, vous avez peut-tre devin la rponse : la particularit des mthodes est que lobjet est pass comme premier argument la fonction. Dans notre exemple, lappel x.f() est lquivalent exact de MaClasse.f(x). En gnral, appeler une mthode avec une liste de n arguments quivaut appeler la fonction correspondante avec une liste darguments qui est le rsultat de linsertion de lobjet avant le premier argument. Si vous navez toujours pas compris comment fonctionnent les mthodes, un regard sur limplmentation va peuttre clarier les choses. Lorsquun attribut dune instance est rfrenc et quil nest pas une donne attribut, une recherche est entame dans sa classe. Si le nom correspond un attribut de classe valide qui est un objet fonction, un objet mthode est cr en empaquetant (des pointeurs sur) lobjet instance et lobjet fonction trouv dans un objet abstrait : cest lobjet mthode. Lorsque lobjet mthode est appel avec une liste darguments, il est depaquet, une nouvelle liste darguments est construite partir de lobjet instance et de la liste darguments originelle, puis lobjet fonction est appel avec cette nouvelle liste darguments.
9.4
Quelques remarques
Les donnes attributs crasent les mthodes de mme nom ; pour viter des conits de noms accidentels, qui peuvent causer des bogues difciles trouver dans des programmes consquents, il est sage dutiliser une conven9.4. Quelques remarques 69
tion qui minimise les chances de conit. Des conventions possibles comprennent la mise en majuscules les noms des mthodes, prxer les noms des donnes attributs avec une mme courte chane de caractres (peut-tre un simple tiret-bas), ou utiliser des verbes pour les mthodes et des substantifs pour les donnes. Les donnes attributs peuvent tre rfrences par des mthodes aussi bien que par les utilisateurs ordinaires (clients) dun objet. Autrement dit, les classes ne sont pas utilisables pour implmenter des types abstraits purs. En fait, rien dans Python ne permet dassurer le secret des donnes tout est bas sur des conventions. (Dun autre ct, limplmentation de Python, crite en C, peut cacher compltement les dtails dimplmentation et de contrle daccs un objet si besoin est ; cela peut tre utilis par les extensions de Python crites en C.) Les clients doivent utiliser les donnes attributs avec prcaution ils peuvent bouleverser des invariants entretenus par les mthodes en crasant leurs donnes attributs. Notez bien que les clients peuvent rajouter des donnes attributs de leur cru un objet instance sans affecter la validit des mthodes, pourvu que les conits de noms soient vits l encore, une convention de nommage peut viter bien des migraines. Il ny a pas de raccourci pour faire rfrence des donnes attributs (ou dautres mthodes !) partir dune mthode. Je trouve que cela augmente en fait la lisibilit des mthodes : il ny a aucune chance de confondre les variables locales et les variables dinstance lorsquon examine une mthode. Par convention, le premier argument dune mthode est souvent appel self. Ce nest quune convention : le mot self na absolument aucun sens spcial pour Python. (Remarquez, tout de mme, que si votre code ne suit pas la convention, il peut se rvler moins lisible par dautres programmeurs Python, et il est aussi concevable quun explorateur de classes soit crit, qui se base sur cette convention.) Tout objet fonction qui est aussi un attribut dune classe dnit une mthode pour les instances de cette classe. Il nest pas ncessaire que la dnition de la fonction soit textuellement comprise dans la dnition de la classe : affecter un objet fonction une variable locale dans la classe marche aussi. Par exemple :
# Fonction dfinie en dehors de la classe def f1(self, x, y): return min(x, x+y) class C: f = f1 def g(self): return bonjour h = g
Maintenant, f, g et h sont tous trois des attributs de la classe C qui font rfrence des objets fonctions, et par consquent ils sont tous les trois des mthodes des instances de C h quivaut exactement g. Remarquez que cette pratique ne sert souvent qu embrouiller le lecteur du programme. Les mthodes peuvent appeler dautres mthodes en utilisant les attributs mthodes de largument self :
class Sac: def vider(self): self.donnees = [] def ajouter(self, x): self.donnees.append(x) def ajouterdoublon(self, x): self.ajouter(x) self.ajouter(x)
Les mthodes peuvent faire rfrence des noms globaux de la mme faon que les fonctions ordinaires. La porte globale associe une mthode est celle du module qui contient la dnition de la classe. (La classe elle-mme ne sert jamais de porte globale !) Alors quon trouve rarement de bonnes raisons pour utiliser des donnes globales dans une mthode, il y a plusieurs utilisations lgitimes de la porte globale : ne serait-ce que le fait que les fonctions et les modules imports dans la porte globale peuvent tre utiliss par les mthodes, de mme que les fonctions et les classes qui y sont dnies. Dhabitude, la classe qui contient la mthode est elle-mme dnie dans cette porte globale, et dans la section suivante nous allons voir quelques bonnes raisons pour lesquelles une
70
Chapitre 9. Classes
mthode pourrait vouloir faire rfrence sa propre classe !
9.5
Hritage
Bien sr, une caractristique du langage ne serait pas digne du mot classe si elle ne permettait pas lhritage. La syntaxe pour dnir une classe drive ressemble ceci :
class NomClasseDerivee(NomClasseDeBase): <instruction-1> . . . <instruction-N>
Le nom NomClasseDeBase doit tre dni dans une porte contenant la dnition de la classe drive. A la place dun nom de classe de base, une autre expression arbitraire est accepte. Cela est utile lorsque la classe de base est dnie dans un autre module,
class NomClasseDerivee(nommod.NomClasseDeBase):
Lexcution dune dnition de classe drive se droule comme pour une classe de base. Quand lobjet classe est construit, la classe de base est mmorise. Cela est employ dans la rsolution des rfrences dattribut : si lattribut demand nest pas trouv dans la classe, il est recherch dans la classe de base. Cette rgle est employe rcursivement si la classe de base est elle-mme drive depuis une autre classe. Il ny a rien de spcial dans linstantiation dune classe drive : NomClasseDerivee() cre une nouvelle instance de la classe. Les rfrences aux mthodes sont rsolues ainsi : lattribut est recherch dans la classe correspondante, en descendant la chane des classes de base si besoin est, et la rfrence la mthode est valide si cette recherche aboutit un objet fonction. Les classe drives peuvent rednir les mthodes de leurs classes de base. Puisque les mthodes ne jouissent pas de privilges particuliers lorsquelles appellent dautres mthodes du mme objet, la mthode dune classe de base qui appelle une autre mthode dnie dans la mme classe de base peut en dnitive appeler une mthode dune classe drive qui a redni cette mthode. (Pour les programmeurs C++ : toutes les mthodes en Python sont des fonctions virtuelles.) Une mthode dune classe drive qui rednit une fonction peut en fait vouloir tendre et non pas remplacer la mthode de la classe de base de mme nom. Il y un moyen simple dappeler la mthode de la classe de base directement : simplement appelez NomClasseDeBase.nommethode(self, arguments). Cela peut parfois savrer utile pour les clients aussi. (Remarquez que a ne marche que si la classe de base est dnie ou importe dans la porte globale.)
9.5.1
Hritage multiple
Python supporte aussi une forme limite dhritage multiple. Une dnition de classe avec plusieurs classes de base ressemble :
class NomClasseDerivee(Base1, Base2, Base3): <instruction-1> . . . <instruction-N>
9.5. Hritage
71
La seule rgle permettant dexpliquer la smantique de lhritage multiple est la rgle de rsolution utilise pour les rfrences aux attributs. La rsolution se fait en profondeur dabord, de gauche droite. Donc, si un attribut nest pas trouv dans NomClasseDerivee, il est cherch dans Base1, puis (rcursivement) dans les classes de base de Base1, et seulement sil ny est pas trouv, il est recherch dans Base2, et ainsi de suite. (Pour certains la recherche en largeur dabord chercher dans Base2 est Base3 avant les classes de base de Base1 semble plus naturelle. Pourtant, cela ncessite que vous sachiez si un attribut particulier de Base1 est dni dans Base1 ou dans une de ses classes de base avant de pouvoir considrer les conits de nom avec Base2. La rgle en profondeur dabord ne fait pas de diffrence entre les attributs directs et hrits de Base1.) Il est clair que lutilisation banalise de lhritage multiple est un cauchemar de maintenance, tant donn que Python se base sur des conventions pour viter les conits de noms accidentels. Un problme bien connu de lhritage multiple est celui dune classe drive de deux autres classes qui ont une mme classe de base en commun. Sil reste facile de voir ce qui se passe dans ce cas (linstance aura une seule copie des variables dinstance ou des donnes attributs utiliss par la classe de base commune), il nest pas clair que cette smantique soit utile de quelque faon que ce soit.
9.6
Variables prives
Il y a un support limit pour des identicateurs privs dans une classe. Tout identicateur de la forme __spam (au moins deux tirets-bas au dbut, au plus un tiret-bas la n) est maintenant textuellement remplac par _nomclasse__spam, o nomclasse est le nom de classe courant, duquel les tirets-bas de dbut on t enlevs. Ce brouillage (mangling) est ralis indpendamment de la position syntaxique de lidenticateur, donc il peut tre utilis pour dnir des variables de classe et dinstance prives, des mthodes, des globales, et mme pour enregistrer des variables dinstance prives de cette classe dans des instances dautres classes. Le nom brouill peut tre tronqu sil dpasse 255 caractres. En dehors des classes, ou lorsque le nom de la classe ne contient que des tirets-bas, le brouillage na pas lieu. Le brouillage de noms permet aux classes de dnir simplement des variables dinstance et des mthodes prives, sans avoir se proccuper des variables dinstance dnies par des classes drives, ou des problmes avec des variables dinstance dnies en dehors de la classe. Remarquez que les rgles de brouillage ont t dessines surtout pour viter des accidents ; il reste possible daccder ou de modier une variable considre comme prive. Cela peut tre utile dans des circonstances particulires telles que dans le dbogueur, et cest une des raisons pour lesquelles ce trou nest pas combl. (Petite bogue : driver une classe en utilisant le mme nom de classe permet lutilisation des variables prives de la classe de base.) Remarquez que le code pass en argument exec, eval() ou evalfile() ne considre pas le nom de classe de la classe appelante comme tant le nom de classe courant ; cest un effet similaire celui de linstruction global, limit du code qui a t compil en mme temps. La mme restriction sapplique getattr(), setattr() et delattr(), de mme quaux rfrences directes __dict__.
9.7
En vrac
Il est parfois utile de disposer dun type de donnes semblable au record du Pascal ou au struct du C, pour lier quelques donnes nommes. Une dnition de classe vide peut servir cela :
class Employe: pass john = Employe() # Cre un enregistrement vide dEmploye # Remplit les champs de lenregistrement john.nom = John Doe john.dept = computer lab john.salaire = 1000
Un bout de code Python qui attend des donnes dun certain type abstrait peut souvent recevoir la place une
72
Chapitre 9. Classes
classe qui simule les mthodes de ce type de donnes. Par exemple, si vous avez une fonction qui met en forme des donnes issues dun objet chier, vous pouvez dnir une classe avec des mthodes read() et readline() qui prend les donnes dun tampon et passer celui-ci comme argument. Les objets mthode dinstance possdent eux-mmes des attributs : m.im_self est lobjet duquel la mthode est instance, et m.im_func est lobjet fonction correspondant la mthode.
9.8
Les exceptions sont des classes aussi
Les exceptions dnies par lutilisateur sont construites comme des classes. En utilisant ce mcanisme, on peut dnir des hirarchies extensibles dexceptions. Il y a deux formes smantiques valides pour linstruction raise :
raise Classe, instance raise instance
Dans la premire forme, instance doit tre une instance de Classe ou dune de ses classes drives. La seconde forme est un raccourci pour
raise instance.__class__, instance
Une clause dexception peut lister des classes et des chanes de caractres. Une classe dans une clause dexception est compatible avec une exception si celle ci est la mme classe ou une classe qui en est drive (mais pas en sens inverse une clause dexception qui liste une classe drive nest pas compatible avec une classe de base). Par exemple, le code suivant afchera B, C, D, dans cet ordre :
class B: pass class C(B): pass class D(C): pass for c in [B, C, D]: try: raise c() except D: print "D" except C: print "C" except B: print "B"
Remarquez que si les clauses dexception avaient t inverses (except B en premier), le code aurait afch B, B, B cest la premire clause except qui convient qui est excute. Lorsquun message derreur est afch pour une exception non gre qui est une classe, le nom de la classe est afch, puis deux-points, un espace, et nalement, linstance convertie en chane de caractres travers la fonction intgre str().
9.8. Les exceptions sont des classes aussi
73
9.9
Itrateurs
A lheure quil est vous avez probablement remarqu que la plupart des conteneurs peuvent tre parcourus en utilisant une instruction for :
for element in [1, 2, 3]: print element for element in (1, 2, 3): print element for key in {one:1, two:2}: print key for char in "123": print char for line in open("myfile.txt"): print line
Ce style daccs est clair, concis et pratique. Lutilisation ditrateurs imprgne Python et lunie. En coulisse, linstruction for appelle iter() sur lobjet conteneur. Cette fonction renvoie un objet itrateur dnissant une mthode next() qui accde les lments dans le conteneur, un la fois. Lorsquil ny a plus dlments, iter() lve une exception StopIteration qui dit la boucle for de se terminer. Lexemple que voici montre comment cela fonctionne :
>>> s = abc >>> it = iter(s) >>> it <iterator object at 0x00A1DB50> >>> it.next() a >>> it.next() b >>> it.next() c >>> it.next() Traceback (most recent call last): File "<pyshell#6>", line 1, in -toplevel it. next() StopIteration
Ayant vu la mcanique quil y a derrire le protocole dun itrateur, il est facile dajouter un comportement ditrateur vos classes. Dnissez une mthode __iter__() qui renvoie un objet ayant une mthode next(). Si la classe dnit next(), alors __iter__() peut se limiter renvoyer self :
74
Chapitre 9. Classes
class Reverse: "Iterator for looping over a sequence backwards" def __init__(self, data): self.data = data self.index = len(data) def __iter__(self): return self def next(self): if self.index == 0: raise StopIteration self.index = self.index - 1 return self.data[self.index] >>> for char in Reverse(spam): ... print char ... m a p s
9.10
Gnrateurs
Les gnrateurs sont un outil simple et puissant pour crer des itrateurs. Ils sont crits comme des fonctions ordinaires mais utilisent linstruction yield chaque fois quils veulent renvoyer une donne. Chaque fois que next() est appel, le gnrateur reprend l o il stait interrompu (il mmorise les valeurs des donnes et quelle instruction a t excute en dernier). Lexemple suivant montre quel point il est trivial de crer un gnrateur :
def reverse(data): for index in range(len(data)-1, -1, -1): yield data[index] >>> for char in reverse(golf): ... print char ... f l o g
Tout ce qui peut tre fait avec des gnrateurs peut aussi tre fait avec des itrateurs bass sur des classes comme dcrit dans la section prcdente. Ce qui rend les gnrateurs si compacts est le fait que les mthodes (__iter__()) et (next()) sont cres automatiquement. Un autre point cl est que les variables locales et ltat de lexcution sont sauvs automatiquement entre les appels. Cela rend la fonction facile crire et beaucoup plus claire quune approche utilisant les variables dinstance comme self.index et self.data. En plus de la cration de mthodes et la sauvegarde de ltat automatiques, lorsque les gnrateurs terminent ils lvent automatiquement lexception StopIteration. Ensemble, ces particularits facilitent la cration ditrateurs sans plus deffort que lcriture dune fonction ordinaire.
9.10. Gnrateurs
75
9.11
Expressions gnrateurs
Certains gnrateurs simples peuvent tre cods succinctement comme des expressions qui utilisent une syntaxe similaire celle des list comprehensions mais avec des parenthses au lieu de crochets. Ces expressions sont destines aux situations o le gnrateur est immdiatement utilis par une fonction englobante. Les expressions gnrateurs sont plus compactes mais moins souples que les dnitions de gnrateurs compltes et ont tendance tre plus conomes en mmoire que les list comprehensions quivalentes. Exemples :
>>> sum(i*i for i in range(10)) 285 >>> xvec = [10, 20, 30] >>> yvec = [7, 5, 3] >>> sum(x*y for x,y in zip(xvec, yvec)) 260 # sum of squares
# dot product
>>> from math import pi, sin >>> sine_table = dict((x, sin(x*pi/180)) for x in range(0, 91)) >>> unique_words = set(word for line in page for word in line.split()) >>> valedictorian = max((student.gpa, student.name) for student in graduates) >>> data = golf >>> list(data[i] for i in range(len(data)-1,-1,-1)) [f, l, o, g]
76
Chapitre 9. Classes
CHAPITRE
DIX
Petit tour dans la bibliothque standard

10.1 Interface avec le systme dexploitation
Le module os fournit des tas de fonctions pour interagir ave le systme dexploitation :
>>> import os >>> os.system(time 0:02) 0 >>> os.getcwd() # Return the current working directory C:\\Python24 >>> os.chdir(/server/accesslogs)
Assurez-vous dutiliser le style "import os" au lieu de "from os import *". Cela amnerait os.open() faire de lombre la fonction intgre open() qui aopre de manire trs diffrente. Les fonctions intgres dir() et help() sont utiles comme aides interactives pour travailler avec de grand modules comme os :
>>> import os >>> dir(os) <returns a list of all module functions> >>> help(os) <returns an extensive manual page created from the modules docstrings>
Pour les tches courantes de gestion de chiers et rpertoires, la module shutil fournit une interface de haut niveau facile utiliser :
>>> import shutil >>> shutil.copyfile(data.db, archive.db) >>> shutil.move(/build/executables, installdir)
10.2
Fichiers et jokers
Le module glob fournit une fonction pour construire des listes de chiers partir de recherches avec jockers dans des rpertoires :
>>> import glob >>> glob.glob(*.py) [primes.py, random.py, quote.py]
77
10.3
Arguments de la ligne de commande
Les scripts utilitaires requirent souvent le traitement des arguments de la ligne de commande. Ces arguments sont stocks sous forme de liste dans lattribut argv du module sys. Par exemple, la sortie suivante rsulte de lexcution de demo.py one two three sur la ligne de commande :
>>> import sys >>> print sys.argv [demo.py, one, two, three]
Le module getopt traite sys.argv en utilisant les mmes conventions que la fonction UNIX getopt(). Un traitement de la ligne de commande plus puissant et exible est fourni par le module optparse.
10.4
Redirection de la sortie et terminaison du programme
Le module sys possde galement des attributs pour reprsenter stdin, stdout et stderr. Ce dernier est utile pour rendre les messages davertissent et derreur visibles mme lorsque stdout a t rdirig :
>>> sys.stderr.write(Warning, log file not found starting a new one\n) Warning, log file not found starting a new one
La manire la plus directe de terminer un script consiste utiliser sys.exit().
10.5
Appariement de chanes
Le module re fournit des outils dexpressions rgulires pour un traitement avanc des chanes. Pour des appariements et des traitements complexes, les expressions rgulires offrent ds solutions succinctes et optimises :
>>> import re >>> re.findall(r\bf[a-z]*, which foot or hand fell fastest) [foot, fell, fastest] >>> re.sub(r(\b[a-z]+) \1, r\1, cat in the the hat) cat in the hat
Lorsque seules des oprations simples sont requises, les mthodes des chanes sont prfrables car elles sont plus simples lire et dbugger :
>>> tea for too.replace(too, two) tea for two
10.6
Mathmatiques
Le module math donne accs aux fonctions mathmatiques virgule ottante de la bibliothque C sous-jacente :
78
Chapitre 10. Petit tour dans la bibliothque standard
>>> import math >>> math.cos(math.pi / 4.0) 0.70710678118654757 >>> math.log(1024, 2) 10.0
Le module random fournit des outils pour faire des slections alatoires :
>>> import random >>> random.choice([apple, pear, banana]) apple >>> random.sample(xrange(100), 10) # sampling without replacement [30, 83, 16, 4, 8, 81, 41, 50, 18, 33] >>> random.random() # random float 0.17970987693706186 >>> random.randrange(6) # random integer chosen from range(6) 4
10.7
Accs Internet
Il y a un certain nombre de modules pour accder Internet et pour traiter les protocoles de lInternet. Deux des plus simples sont urllib2 pour rcuprer des donnes depuis des url et smtplib pour envoyer du courrier :
>>> import urllib2 >>> for line in urllib2.urlopen(http://tycho.usno.navy.mil/cgi-bin/timer.pl): ... if EST in line: # look for Eastern Standard Time ... print line <BR>Nov. 25, 09:43:32 PM EST >>> import smtplib >>> server = smtplib.SMTP(localhost) >>> server.sendmail(soothsayer@example.org, jcaesar@example.org, """To: jcaesar@example.org From: soothsayer@example.org Beware the Ides of March. """) >>> server.quit()
10.8
Dates et heures
Le module datetime fournit des classes pour manipuler les dates et les heures aussi bien de manire simple que de manire complexe. Bien que larithmtique des dates et des heures est supporte, le centre dattention de limplmentation a t port sur lefcacit de lextraction des membres en vue de la mise en forme et du traitement de lafchage. Ce module supporte aussi les objets lis aux fuseaux horaires.
10.7. Accs Internet
79
# dates are easily constructed and formatted >>> from datetime import date >>> now = date.today() >>> now datetime.date(2003, 12, 2) >>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.") 12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December. # dates support calendar arithmetic >>> birthday = date(1964, 7, 31) >>> age = now - birthday >>> age.days 14368
10.9
Compression de donnes
Les formats communs pour archiver et compresser des donnes sont supports par des modules, dont : zlib, gzp, bz2, zipfile et tarfile.
>>> import zlib >>> s = witch which has which witches wrist watch >>> len(s) 41 >>> t = zlib.compress(s) >>> len(t) 37 >>> zlib.decompress(t) witch which has which witches wrist watch >>> zlib.crc32(s) 226805979
10.10
Mesure des performances
Certains utilisateurs de Python nourrissent un profond intrt pour la connaissance des performances relatives de diffrentes approches dun mme problme. Python fournit un outil de mesure qui rpond immdiatement ces questions. Par exemple, il peut tre tentant dutiliser lemballage et le dballage des n-uplets la place de lapproche traditionnelle pour changer des arguments. Le module timeit montre rapidement un modeste avantage en performances :
>>> from timeit import Timer >>> Timer(t=a; a=b; b=t, a=1; b=2).timeit() 0.57535828626024577 >>> Timer(a,b = b,a, a=1; b=2).timeit() 0.54962537085770791
Contrastant avec la nesse de la granularit de timeit, les modules profile et pstats fournissent des outils pour identier les sections critiques dans de larges blocs de code.
80
Chapitre 10. Petit tour dans la bibliothque standard
10.11
Contrle de qualit
Une approche de lcriture du logiciel de haute qualit consiste crire des tests pour chaque fonction au fur et mesure quelle est dveloppe et faire tourner ces tests frquemment durant le processus de dveloppement. Le module doctest fournit un outil pour examiner un module et valider les tests immergs dans las chanes de documentation du programme. La construction dun test est aussi simple que copier-coller un appel typique et son rsultat dans la chane de documentation. Cela amliora la documentation en donnant un exemple lutilisateur et permet au module doctest de sassurer que le code reste dle la documentation :
def average(values): """Computes the arithmetic mean of a list of numbers. >>> print average([20, 30, 70]) 40.0 """ return sum(values, 0.0) / len(values) import doctest doctest.testmod()
# automatically validate the embedded tests
Le module unittest nest pas un module doctest sans effort, mais il permet de maintenir dans un chier spar un plus vaste ensemble de tests.
import unittest class TestStatisticalFunctions(unittest.TestCase): def test_average(self): self.assertEqual(average([20, 30, 70]), 40.0) self.assertEqual(round(average([1, 5, 7]), 1), 4.3) self.assertRaises(ZeroDivisionError, average, []) self.assertRaises(TypeError, average, 20, 30, 70) unittest.main() # Calling from the command line invokes all tests
10.12
Les piles sont fournies avec lappareil
Python a une philosophie piles comprises. Cest dans la sophistication et la robustesse de ses paquetages les plus gros que cela se voit le mieux. Par exemple : Les modules xmlrpclib et SimpleXMLRPCServer font que limplmentation des appels de procdures loignes (RPC) est une tche presque triviale. Malgr les noms, aucune connaissance ou manipulation directe de XML nest ncessaire. Le paquetage email est une bibliothque pour grer les messages lectroniques, y compris les documents MIME et les autres documents bass sur la RFC-2822. Contrairement smtplib et poplib, qui envoient et reoivent effectivement des messages, le paquetage email a une bote outils complte pour construire ou dcoder des messages la structure complexe (ce qui inclut les attachements) et pour implmenter les protocoles Internet pour le codage et les enttes. Les paquetages xml.dom et xml.sax fournissent un support robuste pour analyser ces formats dchange de donnes trs rpandus. De mme, le module csv effectue des lectures et des critures directement dans un format de base de donnes commun. Ensemble, ces modules et paquetages simplient grandement lchange de donnes entre des applications Python et dautres outils. Linternationalisation est supporte par un certain nombre de modules, incluant les paquetages gettext, locale et codecs. 10.11. Contrle de qualit 81
82
CHAPITRE
ONZE
Petit tour dans la bibliothque standard Deuxime partie

Cette seconde visite guide concerne des modules plus avancs qui rpondent aux besoins de la programmation professionnelle. Ces modules apparaissent rarement dans les petits scripts.
11.1
Mise en forme des sorties
Le module repr fournit une version de repr() pour un afchage abrg de conteneurs volumineux ou profondment imbriqus :
>>> import repr >>> repr.repr(set(supercalifragilisticexpialidocious)) "set([a, c, d, e, f, g, ...])"
Le module pprint offre un contrle plus sophistiqu sur limpression dobjets intgrs aussi bien que dobjets dnis par lutilisateur, dune manire qui est lisible par linterprteur. Lorsque le rsultat est plus long quune ligne, limprimeur-enjoliveur ajoute des ns-de-ligne et une indentation pour rvler plus clairement la structure des donnes :
>>> import pprint >>> t = [[[[black, cyan], white, [green, red]], [[magenta, ... yellow], blue]]] ... >>> pprint.pprint(t, width=30) [[[[black, cyan], white, [green, red]], [[magenta, yellow], blue]]]
Le module textwrap formate les paragraphes de texte de sorte remplir une largeur dcran donne :
83
>>> import textwrap >>> doc = """The wrap() method is just like fill() except that it returns ... a list of strings instead of one big string with newlines to separate ... the wrapped lines.""" ... >>> print textwrap.fill(doc, width=40) The wrap() method is just like fill() except that it returns a list of strings instead of one big string with newlines to separate the wrapped lines.
Le module locale accde une base de donnes de formats de donnes spciques des cultures. Lattribut grouping des fonctions de formatage de locale fournit un moyen direct pour mettre en forme des nombres avec des sparateurs de groupes de chiffres :
>>> import locale >>> locale.setlocale(locale.LC_ALL, English_United States.1252) English_United States.1252 >>> conv = locale.localeconv() # get a mapping of conventions >>> x = 1234567.8 >>> locale.format("%d", x, grouping=True) 1,234,567 >>> locale.format("%s%.*f", (conv[currency_symbol], ... conv[int_frac_digits], x), grouping=True) $1,234,567.80
11.2
Modles
Le module string inclut une souple classe Template avec une syntaxe simplie adapte ldition par les utilisateurs naux. Cela permet que les utilisateurs personnalisent leurs applications sans devoir les altrer. Ce format utilise des noms garde-place forms par $ suivi dun identicateur Python valide (des caractres alphanumriques et des blancs souligns). En entourant ces noms par des accolades on leur permet dtre suivis de caractres alphanumriques sans espaces. En crivant $$ on cre un $ simple.
>>> from string import Template >>> t = Template(${village}folk send $$10 to $cause.) >>> t.substitute(village=Nottingham, cause=the ditch fund) Nottinghamfolk send $10 to the ditch fund.
La mthode substitute lve une erreur KeyError lorsquun garde-place nest pas fourni dans un ctionnaire ou dans un argument mot-cl. Pour des applications de style mailing-fusion, linformation fournie par lutilisateur peut tre incomplte et la mthode safe_substitute peut tre plus approprie elle laisse les garde-place inchangs lorsque la donne est omise :
>>> t = Template(Return the $item to $owner.) >>> d = dict(item=unladen swallow) >>> t.substitute(d) Traceback (most recent call last): . . . KeyError: owner >>> t.safe_substitute(d) Return the unladen swallow to $owner.
84
Chapitre 11. Petit tour dans la bibliothque standard - Deuxime partie
Les sous-classes des modles peuvent spcier un dlimiteur personnalis. Par exemple, un utilitaire de renommage pour un butineur de photos peut choisir dutiliser des signes pourcent pour des garde-place comme la date courante, le numro de srie de limage ou le format du chier :
>>> import time, os.path >>> photofiles = [img_1074.jpg, img_1076.jpg, img_1077.jpg] >>> class BatchRename(Template): ... delimiter = % >>> fmt = raw_input(Enter rename style (%d-date %n-seqnum %f-format): ) Enter rename style (%d-date %n-seqnum %f-format): Ashley_%n%f >>> t = BatchRename(fmt) >>> date = time.strftime(%d%b%y) >>> for i, filename in enumerate(photofiles): ... base, ext = os.path.splitext(filename) ... newname = t.substitute(d=date, n=i, f=ext) ... print %s --> %s % (filename, newname) img_1074.jpg --> Ashley_0.jpg img_1076.jpg --> Ashley_1.jpg img_1077.jpg --> Ashley_2.jpg
Une autre application pour ces modles est de sparer la logique du programme davec les dtails des divers formats de sortie. Il devient possible de substituer des modles personnaliss par des chiers XML, des rapports en texte plat ou des rapports web en HTML.
11.3
Travail avec des enregistrements binaires
Le module struct fournit les fonctions pack() et unpack() pour travailler avec des enregistrements ayant des formats binaires de longueurs variables. Lexemple suivant montre comment boucler travers linformation de tte dun chier zip (pour pack les codes "H" et "L" reprsentent des nombres sans signe de deux et quatre octets respectivement) :
import struct data = open(myfile.zip, rb).read() start = 0 for i in range(3): # show the first 3 file headers start += 14 fields = struct.unpack(LLLHH, data[start:start+16]) crc32, comp_size, uncomp_size, filenamesize, extra_size = fields start += 16 filename = data[start:start+filenamesize] start += filenamesize extra = data[start:start+extra_size] print filename, hex(crc32), comp_size, uncomp_size start += extra_size + comp_size # skip to the next header
11.4
Multi-threading
Le threading est une technique qui consiste dcoupler les tches qui ne sont pas squentiellement dpendantes. Les threads peuvent tre utiliss pour amliorer la ractivit dapplications qui acceptent des saisies de lutilisateur pendant que dautres tches sont effectues en arrire-plan. Un emploi apparent celui-l consiste faire tourner 11.3. Travail avec des enregistrements binaires 85
des entres/sorties en parallle avec des calculs dans un autre thread. Le code suivant montre comment le module de haut niveau threading peut faire tourner des tches en arrireplan pendant que le programme principal continue tourner :
import threading, zipfile class AsyncZip(threading.Thread): def __init__(self, infile, outfile): threading.Thread.__init__(self) self.infile = infile self.outfile = outfile def run(self): f = zipfile.ZipFile(self.outfile, w, zipfile.ZIP_DEFLATED) f.write(self.infile) f.close() print Finished background zip of: , self.infile background = AsyncZip(mydata.txt, myarchive.zip) background.start() print The main program continues to run in foreground. background.join() # Wait for the background task to finish print Main program waited until background was done.
Le principal d des applications multi-threaded est la coordination des threads qui partagent des donnes ou dautres ressources. A cet effet, le module threading fournit un certain nombre de primitives de synchronisation incluant des horloges, des vnements, des variables de condition et des smaphores. Bien que ces outils soient puissants, des erreurs de conception mineures peuvent tre lorigine de problmes difciles reproduire. Si bien que lapproche prfre de la coordination de tches consiste concentrer tous les accs une ressource donne dans un mme thread et utiliser le module Queue pour passer ce thread les requtes provenant des autres threads. Les applications qui utilisent des objets Queue pour la communication inter-threads et la coordination sont plus faciles concevoir, plus lisibles et plus ables.
11.5
Journalisation
Le module logging offre un systme complet et exible de journalisation. Dans lemploi le plus simple, les messages sont envoys un chier ou sys.stderr :
import logging logging.debug(Debugging information) logging.info(Informational message) logging.warning(Warning:config file %s not found, server.conf) logging.error(Error occurred) logging.critical(Critical error -- shutting down)
Cela produit la sortie suivante :

WARNING:root:Warning:config file server.conf not found ERROR:root:Error occurred CRITICAL:root:Critical error -- shutting down
Par dfaut, les messages dinformation et de debugging sont supprims et la sortie est envoye sur la sortie derreur standard. Dautres options de sortie comprennent le droutement de messages travers du courrier lectronique, des datagrammes, des sockets ou vers un serveur HTTP. De nouveaux ltres peuvent choisir les diffrents chemins selon la priorit du message : DEBUG, INFO, WARNING, ERROR et CRITICAL. 86 Chapitre 11. Petit tour dans la bibliothque standard - Deuxime partie
Le systme de journalisation peut tre congur directement depuis Python ou peut tre charg partir dun chier de conguration ditable par lutilisateur an de personnaliser la journaisation sans altrer lapplication.
11.6
Rfrences faibles
Python fait une gestion automatique de la mmoire (comptage de rfrences pour la plupart des objets et ramassemiettes pour liminer les cycles). Lorsque la dernire rfrence sur une mmoire est limine, cette dernire est rapidement libre. Cette approche est parfaite pour la plupart des applications. Cependant, dans certaines occasions il est ncessaire de suivre la trace de certains objets, mais uniquement lorsquils sont utiliss par quelque autre objet. Malheureusement, pour suivre la trace dun objet il faut avoir une rfrence dessus, ce qui rend lobjet permanent. Le module weakref fournit des outils pour pister des objets sans crer des rfrences dessus. Lorsque lobjet nest plus ncessaire, il est automatiquement enlev de la table de weakref et une action enregistre pour lobjet est dclenche. Les applications typiques de cela comprennent la mise en cache dobjets dont la cration est coteuse :
>>> import weakref, gc >>> class A: ... def __init__(self, value): ... self.value = value ... def __repr__(self): ... return str(self.value) ... >>> a = A(10) # create a reference >>> d = weakref.WeakValueDictionary() >>> d[primary] = a # does not create a reference >>> d[primary] # fetch the object if it is still alive 10 >>> del a # remove the one reference >>> gc.collect() # run garbage collection right away 0 >>> d[primary] # entry was automatically removed Traceback (most recent call last): File "<pyshell#108>", line 1, in -topleveld[primary] # entry was automatically removed File "C:/PY24/lib/weakref.py", line 46, in __getitem__ o = self.data[key]() KeyError: primary
11.7
Outils pour travailler avec des listes
Une grande partie des besoins des structures de donnes peuvent tre combls avec le type intgr liste. Parfois, cependant, il faut des implmentations alternatives des listes, ralisant dautres compromis propos des performances. Le module array fournit un objet array() qui est comme une liste mais contient uniquement des donnes homognes, mmorises avec plus de compacit. Lexemple suivant montre un tableau de nombres mmoriss comme des entiers sans signe cods sur deux octets (code "H") au lieu des 16 octets par lment pour une liste Python ordinaire dobjets int.
11.6. Rfrences faibles
87
>>> from array import array >>> a = array(H, [4000, 10, 700, 22222]) >>> sum(a) 26932 >>> a[1:3] array(H, [10, 700])
Le module collections fournit un objet deque() qui est comme une liste avec des oprations rapides pour ajouter un lment ( droite) ou en enlever un gauche, mais les recerches au milieu de la liste sont lentes. Ces objets conviennent bien limplmentation des queues et des recherches en largeur dans les arbres :
>>> from collections import deque >>> d = deque(["task1", "task2", "task3"]) >>> d.append("task4") >>> print "Handling", d.popleft() Handling task1 unsearched = deque([starting_node]) def breadth_first_search(unsearched): node = unsearched.popleft() for m in gen_moves(node): if is_goal(m): return m unsearched.append(m)
En plus des alternatives limplmentation des listes la bibliothque offre aussi des outils comme le module bisect avec des fonctions pour manipuler des listes tries :
>>> import bisect >>> scores = [(100, perl), (200, tcl), (400, lua), (500, python)] >>> bisect.insort(scores, (300, ruby)) >>> scores [(100, perl), (200, tcl), (300, ruby), (400, lua), (500, python)]
Le module heapq fournit des fonctions pour limplmentation de teas bass sur des listes ordinaires. La plus petite valeur est toujours conserve lemplacement zro. Cela est utile pour les applications qui accdent de manire rpte au plus petit lment mais ne veulent pas excuter un tri de liste complet :
>>> from heapq import heapify, heappop, heappush >>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0] >>> heapify(data) # rearrange the list into heap order >>> heappush(data, -5) # add a new entry >>> [heappop(data) for i in range(3)] # fetch the three smallest entries [-5, 0, 1]
11.8
Arithmtique dcimale virgule ottante
Le module decimal offre un type de donnes Decimal destin faire de larithmtique dcimale virgule ottante. Compare limplmentation intgre des nombres binaires en virgule ottante, float, cette nouvelle classe est particulirement utile aux applications nancires et aux autres usages qui requirent une reprsentation dcimale exacte, le contrle de la prcision, le contrle des arrondis, pour satisfaire les prescriptions lgales ou rglementaires, le reprage des chiffres dcimaux signicatifs et aussi les applications dont lutilisateur espre que les rsultats concideront avec ceux de calculs faits la main. 88 Chapitre 11. Petit tour dans la bibliothque standard - Deuxime partie
Par exemple, le calcul de 5% du prix dune communication tlphonique de 70 centimes donne des rsultats diffrents en nombres dcimaux virgule ottante et en nombre binaires virgules ottante. La diffrence devient signicative si les rsultats sont arrondis au centime le plus proche :
>>> from decimal import * >>> Decimal(0.70) * Decimal(1.05) Decimal("0.7350") >>> .70 * 1.05 0.73499999999999999
Le rsultat dcimal garde un zro la n, impliquant automatiquement un rsultat quatre chiffres aprs la virgule, ce qui correspond au produit de deux facteurs ayant deux chiffres aprs la virgule. Decimal reproduit les mathmatiques comme on les fait la main et vite les problmes qui peuvent survenir lorsque le binaire virgule ottante ne peut pas reprsenter exactement les quantits dcimales.
>>> Decimal(1.00) % Decimal(.10) Decimal("0.00") >>> 1.00 % 0.10 0.09999999999999995 >>> sum([Decimal(0.1)]*10) == Decimal(1.0) True >>> sum([0.1]*10) == 1.0 False
Le module Decimal fournit une arithmtique avec autant de prcision que ncessaire :
>>> getcontext().prec = 36 >>> Decimal(1) / Decimal(7) Decimal("0.142857142857142857142857142857142857")
11.8. Arithmtique dcimale virgule ottante
89
90
CHAPITRE
DOUZE
Et maintenant ?
La lecture de ce tutoriel aura probablement renforc votre intrt dans lutilisation de Python vous devriez tre impatient dappliquer Python la rsolution de vos problmes du monde rel. O pouvez-vous aller maintenant ? Vous devriez lire, ou au moins feuilleter, la Python Library Reference, qui offre un matriel de rfrence complet (quoique succinct) sur des types, des fonctions et des modules qui peuvent vous faire conomiser beaucoup de temps en crivant des programmes en Python. La distribution standard de Python inclut normment de code, en C comme en Python ; il y a des modules pour lire des botes aux lettres U NIX, rechercher des documents via HTTP, gnrer des nombres alatoires, interprter des options de ligne de commande, crire des programmes CGI, comprimer des donnes, et bien davantage ; parcourir la Library Reference devrait vous donner une ide de ce qui est disponible. Le site Web principal pour Python est http ://www.python.org ; vous y trouverez du code, de la documentation, et des liens vers des pages en rapport avec Python dans le Web. Ce site Web dispose de miroirs dans plusieurs endroits du monde, en Europe, au Japon et en Australie ; un miroir peut tre plus rapide daccs que le site principal, suivant votre position gographique. Un site plus informel est http ://starship.skyport.net, qui contient nombre de pages personnelles en rapport avec Python ; beaucoup de gens y ont plac des programmes tlchargeables. Pour des problmes ou des questions sur Python, vous pouvez poster dans le groupe de discussion comp.lang.python, ou crire la liste de diffusion python-list@cwi.nl. Le groupe et la liste sont en passerelle, donc les messages de lun passent automatiquement dans lautre. Il y a entre 35 et 45 messages par jour, avec des questions (et des rponses), des suggestions dapports nouveaux, et des annonces de nouveaux modules. Avant de poster, soyez sr davoir consult la liste de Foire Aux Questions (Frequently Asked Questions ou FAQ) situe http ://www.python.org/doc/FAQ.html, et davoir regard dans le rpertoire Misc/ de la distribution source de Python. La FAQ rpond plusieurs des questions qui reviennent sans cesse, et peut dj contenir la solution votre problme.
91
92
ANNEXE
Edition dentre interactive et substitution historique

Quelques versions de linterprteur Python supportent ldition de la ligne dentre courante et la substitution historique, des commodits semblables celles du shell Korn et du shell GNU Bash. Cela est implment en utilisant la librairie GNU Readline, qui supporte ldition la vi et la emacs. Cette librairie a sa propre documentation, que je ne dupliquerai pas ici ; toutefois, les bases peuvent tre vite expliques. Ce chapitre ne documente pas les capacits ddition du paquetage PythonWin de Mark Hammond ou lenvironnement bas sur Tk, IDLE, distribu avec Python. Le rappel dhistorique de ligne de commande qui fonctionne dans les fentres DOS sous NT et dautres variantes de DOS et Windows est encore un autre bestiau.
A.1
Edition de ligne
Si elle est supporte, ldition de ligne dentre est active lorsque linterprteur afche un prompt primaire ou secondaire. La ligne courante peut tre dite en utilisant les caractres de contrle conventionnels dEmacs. Les plus importants sont : C-A (Control-A) dplace le curseur en dbut de ligne, C-E en n de ligne, C-B dplace dune position vers la gauche, C-F vers la droite. Backspace efface le caractre gauche du curseur, C-D le caractre droite. C-K tue (efface) le reste de la ligne droite du curseur, C-Y rappelle la dernire chane tue. C-tiret-bas dfait le dernier changement ralis ; il peut tre rpt pour un effet cumul.
A.2
Substitution historique
La substitution historique fonctionne ainsi. Toutes les lignes dentre non-vides sont enregistres dans un tampon dhistorique, et lorsquun nouveau prompt est afch, vous tes dans une nouvelle ligne la n de ce tampon. C-P dplace dune ligne vers le haut (vers larrire) dans lhistorique, C-N vers le bas. Toute ligne de lhistorique peut tre dite ; un astrisque apparat en dbut de ligne avant le prompt pour indiquer que la ligne a t modie. Appuyer sur Entre passe la ligne courante linterprteur. C-R commence une recherche incrmentale en arrire ; C-S une recherche en avant.
A.3
Dnition des touches
Les associations des touches aux commandes et dautres paramtres de la bibliothque Readline peuvent tre rednis en plaant des commandes dinitialisation dans le chier $HOME/.inputrc. Les dnitions de raccourcis clavier ont la forme
nom-de-touche: nom-de-fonction
ou bien
93
"chane": nom-de-fonction
et les options sont modies avec

set nom-option valeur
Par exemple :
# Je prfre ldition la vi: set editing-mode vi # Edition sur une seule ligne: set horizontal-scroll-mode On # Redfinir quelques touches: Meta-h: backward-kill-word "\C-u": universal-argument "\C-x\C-r": re-read-init-file
Remarquez que laction lie a la tabulation en Python est dinsrer une tabulation, au lieu de laction par dfaut de Readline, qui est la compltion de noms. Si vous insistez, vous pouvez rednir cela avec
Tab: complete
dans le chier $HOME/.inputrc. (Bien sr, cela rend plus difcile lindentation des lignes de continuation. . .) La compltion automatique des noms de variable et de module est disponible en option. Pour lactiver dans le mode interactif de linterprteur, rajouter ceci votre chier $HOME/.pythonrc :
import rlcompleter, readline readline.parse_and_bind(tab: complete)
Cela lie la touche Tab la fonction de compltion, donc appuyer deux fois sur Tab afche les suggestions de compltion ; celles-ci sont cherches parmi les noms dinstructions, les variables locales actuelles et les noms de module disponibles. Pour des expressions avec un point comme string.a, la compltion sera ralise jusquau . puis les compltions correspondant aux attributs suivants seront suggres. Remarquez que cela peut amener excuter du code propre une application si un objet avec une mthode __getattr__() apparat dans lexpression. Un chier de dmarrage plus capable pourrait ressembler cet exemple. Notez que cela efface les noms quil cre une fois quils ne sont plus utiliss ; cest fait car le chier de dmarrage est excut dans le mme espace de noms que les commandes interactives, et enlever les noms vite de crer des effets de bord dans les environnement interactifs. Vous pourriez trouver pratique de garder certains des modules imports, comme os, qui savre tre ncessaire dans la plupart des sessions dans linterprteur.
94
Annexe A. Edition dentre interactive et substitution historique
# # # # # # # # #
Add auto-completion and a stored history file of commands to your Python interactive interpreter. Requires Python 2.0+, readline. Autocomplete is bound to the Esc key by default (you can change it - see readline docs). Store the file in ~/.pystartup, and set an environment variable to point to it, e.g. "export PYTHONSTARTUP=/max/home/itamar/.pystartup" in bash. Note that PYTHONSTARTUP does *not* expand "~", so you have to put in the full path to your home directory. atexit os readline rlcompleter
import import import import
historyPath = os.path.expanduser("~/.pyhistory") def save_history(historyPath=historyPath): import readline readline.write_history_file(historyPath) if os.path.exists(historyPath): readline.read_history_file(historyPath) atexit.register(save_history) del os, atexit, readline, rlcompleter, save_history, historyPath
A.4
Commentaire
Cette commodit est un norme pas en avant par rapport aux versions plus anciennes de linterprteur ; nanmoins, quelques vux restent remplir : ce serait bien que lindentation soit suggre sur les lignes de continuation (linterprteur sait si un lexme dindentation est requis par la suite). Le mcanisme de compltion pourrait se servir de la table de symboles de linterprteur. Une commande pour vrier (voire suggrer) lquilibre des parenthses, des quotes, etc. serait aussi trs utile.
A.4. Commentaire
95
96
ANNEXE
Arithmtique virgule ottante : problmes et limites

Les nombres virgule ottante sont reprsents dans le matriel de lordinateur comme des fractions de base 2 (binaires). Par exemple, la fraction dcimale
0.125
a la valeur 1/10 + 2/100 + 5/1000, et de la mme faon, la fraction binaire

0.001
a la valeur 0/2 + 0/4 + 1/8. Ces deux fractions ont des valeurs identiques, mais la seule diffrence relle tant que la premire est crite en notation fractionnaire base 10, et la seconde en base 2. Malheureusement, la plupart des fractions dcimales ne peuvent pas tre reprsentes exactement comme des fractions binaires. Une consquence est que, en gnral, les nombres virgule ottante dcimaux que vous entrez sont seulement des approximations des nombres binaires virgule ottante effectivement stocks dans la machine. Le problme est facile comprendre tout dabord en base 10. Considrons la fraction 1/3. Vous pouvez en faire une approximation en fraction de base 10 :
0.3
ou, mieux,
0.33
ou, mieux,
0.333
et ainsi de suite. Peu importe combien de chiffres vous souhaitez crire, le rsultat ne sera jamais exactement 1/3, mais sera une approximation toujours meilleure de 1/3. Dela mme faon, peu importe combien de chiffres de base 2 vous souhaitez utiliser, la valeur dcimale 0.1 ne peut tre reprsente exactement comme fraction de base 2. En base 2, 1/10 est une fraction se rptant indniment
0.0001100110011001100110011001100110011001100110011...
Arrtez nimporte quel nombre ni de bits, et vous aurez une approximation. Cela explique que vous voyiez des choses comme :
97
>>> 0.1 0.10000000000000001
Sur la plupart des machines aujourdhui, cest ce que vous verrez si vous entrez 0.1 lors du prompt Python. Vous pourriez voir autre chose, pourtant, car le nombre de bits utilis par le matriel pour stocker les valeurs en virgule ottante peut varier entre les machines, et Python afche juste une approximation dcimale de la vraie valeur dcimale de lapprocimation binaire stocke dans la machine. Sur la plupart des machines, si Python devait afcher la vraie valeur dcimale de lapproximation binaire stockes pour 0.1, il devrait afcher
>>> 0.1 0.1000000000000000055511151231257827021181583404541015625
la place ! Le prompt Python utilise (implicitement) la fonction intgre repr() pour obtenir une version en chaine de tout ce quil afche. Pour les ottants, repr(ottant) arrondit la vraie valeur dcimale 17 dcimales signicatives, donnant
0.10000000000000001
repr(ottant) produit 17 dcimales signicatives parce quil savre que cest sufsant (sur la plupart des machines) de faon ce que eval(repr(x)) == x exactement pour tous les ottants nis x, mais que larrondissement 16 dcimales nest pas sufsant pour assurer cela. Notez que cest dans la vraie nature de la virgule ottante en binaire : ce nest pas un bogue de Python, ce nest pas non plus un bogue dans votre code, et vous verrez la mme chose dans tout langage qui supporte larithmtique virgule ottante de votre matriel (bien que certains langages puissent ne pas afcher la diffrence par dfaut, ou dans tous les modes dafchage). La fonction intgre str() de Python produit seulement 12 dcimales signicatives, et vous pourriez souhaiter utiliser cela la place. Il nest pas habituel que eval(str(x)) reproduise x, mais la sortie pourrait tre plus agrable regarder :
>>> print str(0.1) 0.1
Il est important de comprendre que cela est, en vrit, une illusion : la valeur dans la machine nest pas exactement 1/10, vous arrondissez seulement lafchage de la vraie valeur de la machine. Dautres surprises dcoulent de celle-ci. Par exemple, aprs avoir vu
>>> 0.1 0.10000000000000001
vous pourriez tre tents dutiliser la fonction round() pour la tronquer vers la seule dcimale que vous attendez. Mais a ne change rien :
>>> round(0.1, 1) 0.10000000000000001
Le problme est que la valeur binaire virgule ottante stocke pour "0.1" tait dj la meilleure approximation binaire possible de 1/10, donc essayer de larrondir nouveau ne peut rien amliorer : ctait dj aussi bon que possible. Une autre consquence est que puisque 0.1 nest pas exactement 1/10, ajouter 0.1 lui-mme 10 fois pourrait ne pas atteindre exactement 1.0, soit :
98
Annexe B. Arithmtique virgule ottante : problmes et limites
>>> somme = 0.0 >>> for i in range(10): ... somme += 0.1 ... >>> somme 0.99999999999999989
Larithmtique binaire virgule ottante rserve de nombreuses surprises comme celle-ci. Le problme avec 0.1 est expliqu en dtails prcis ci-dessous, dans la section B.1, Erreur de reprsentation. Voir The Perils of Floating Point pour un compte-rendu plus complet dautres surprises courantes. Comme il est dit prs de la n, il ny a pas de rponses faciles. Cependant, ne soyez pas trop inquiets ! Les erreurs dans les oprations ottantes en Python sont hrites des matriels virgule ottante, et sur la plupart des machines sont de lordre de pas plus de 1 sur 2**53 par opration. Cest plus quadquat pour la plupart des tches, mais vous devez conserver lesprit que ce nest pas de larithmtique dcimale, et que toute opration ottante peut souffrir dune nouvelle erreur darrondi. Alors que des cas pathologiques existent effectivement, pour la plupart des utilisations courantes de larithmtique virgule ottante, vous verrez le rsultat que vous attendez au nal si vous arrondissez simplement lafchage de vos rsultats naux au nombre de dcimales que vous attendez. str() suft gnralement, et pour un contrle plus n voir la discussion de loprateur de format % de Python : les codes de format %g, %f et %e fournissent des faons adaptables et simples darrondir les rsultats pour lafchage.
B.1
Erreur de reprsentation
Cette section explique lexemple de 0.1 en dtail, et montre comment vous pouvez effectuer une analyse exacte de cas similaires vous-mme. Une familiarit basique avec la reprsentation virgule ottante est suppose. Erreur de reprsentation renvoie au fait que certaines (la plupart, en ralit) des fractions dcimales ne peuvent tre reprsentes exactement comme fractions binaires (base 2). Cest la raison principale pour laquelle Python (ou Perl, C, C++, Java, Fortran, et beaucoup dautres) nafcheront souvent pas le nombre dcimal exact que vous attendez :
>>> 0.1 0.10000000000000001
Pourquoi cela ? 1/10 nest pas exactement reprsentable en tant que fraction binaire. Presque toutes les machines daujourdhui (juin 2005) utilisent larithmtique virgule ottante IEEE-754, et presque toutes les plate-formes associent les ottants Python des double prcision IEEE-754. Les doubles 754 contiennent 53 bits de prcision, donc en entre lordinateur sefforce de convertir 0.1 vers la fraction la plus proche quil peut de forme J/2**N o J est un entier contenant exactement 53 bits. Rcrire
1 / 10 ~= J / (2**N)
en
J ~= 2**N / 10
et se souvenir que J a exactement 53 bits (est >= 2**52 mais < 2**53), la meilleure valeur pour N est 56 :
B.1. Erreur de reprsentation
99
>>> 2L**52 4503599627370496L >>> 2L**53 9007199254740992L >>> 2L**56/10 7205759403792793L
Cest dire que 56 est la seule valeur pour N qui laisse J exactement 53 bits. La meilleure valeur possible pour J
>>> q, r = divmod(2L**56, 10) >>> r 6L
Puisque le reste est suprieur la moiti de 10, la meilleure aproximation est obtenue en arrondissant au suprieur :
>>> q+1 7205759403792794L
Ainsi la meilleure approximation possible de 1/10 en double prcision 754 est cela sur 2**56, ou
7205759403792794 / 72057594037927936
Notez que depuis que nous avons arrondi, cest un peu plus grand que 1/10 ; si nous navions pas arrondi, le quotient aurait t un peu plus petit que 1/10. Mais dans aucun cas il ne peut tre exactement 1/10 ! Donc lordinateur ne voit jamais 1/10 : ce quil voit est la fraction exacte donne ci-dessus, la meilleure approximation double 754 quil puisse obtenir :
>>> .1 * 2L**56 7205759403792794.0
Si on multiplie cette fraction par 10**30, nous pouvons voir la valeur (tronque) de ses 30 dcimales les plus signicatives :
>>> 7205759403792794L * 10L**30 / 2L**56 100000000000000005551115123125L
ce qui signie que le nombre exact stock dans lordinateur est approximativement gal la valeur dcimale 0.100000000000000005551115123125. Arrondir cela 17 chiffres signicatifs donne le 0.10000000000000001 que Python afche (enn, quil afchera sur toute plateforme conforme-754 qui effectue les meilleures conversions de saisie et dafchage possibles dans sa bibliothque C la votre peut-tre pas !).
100
Annexe B. Arithmtique virgule ottante : problmes et limites
ANNEXE
Historique et licence
C.1 Histoire de Python
Python a t cr dans les annes 90 par Guido van Rossum au Stichting Mathematisch (CWI, voir
http ://www.cwi.nl/) aux Pays-Bas, comme successeur dun langage appel ABC. Guido est rest lauteur principal
de Python, mme si ce dernier inclut maintenant de nombreuses contributions dautres personnes. En 1995, Guido a continu son travail sur Python la Corporation for National Research Initiatives (CNRI, voir http ://www.cnri.reston.va.us/) Reston, Virginie, o il a dvelopp et mis disposition plusieurs versions du logiciel. En mai 2000, Guido et lquipe de dveloppement du cur de Python ont dmnag chez BeOpen.com pour former le BeOpen PythonLabs team. En octobre de la mme anne, lquipe de PythonLabs a dmnag chez Digital Creations (maintenant Zope Corporation, voir http ://www.zope.com/). En 2001 a t cre la Python Software Foundation (PSF, voir http ://www.python.org/psf/), une organisation sans but lucratif spciquement cre pour grer la proprit intellectuelle de Python. Zope Corporation est un membre et un sponsor de la PSF. Toutes les versions de Python sont Open Source (voir http ://www.opensource.org/ pour la dnition de cette expression). Historiquement, la plupart mais non la totalit des versions de Python sont aussi compatibles GPL. La table suivante rsume les diverses livraisons. Produit de 0.9.0 1.2 de 1.3 1.5.2 1.6 2.0 1.6.1 2.1 2.0.1 2.1.1 2.2 2.1.2 2.1.3 2.2.1 2.2.2 2.2.3 2.3 2.3.1 2.3.2 2.3.3 2.3.4 2.3.5 2.4 2.4.1 2.4.2 2.4.3 Driv de 1.2 1.5.2 1.6 1.6 2.0+1.6.1 2.0+1.6.1 2.1+2.0.1 2.1.1 2.1.1 2.1.2 2.2 2.2.1 2.2.2 2.2.2 2.3 2.3.1 2.3.2 2.3.3 2.3.4 2.3 2.4 2.4.1 2.4.2 Anne 1991-1995 1995-1999 2000 2000 2001 2001 2001 2001 2001 2002 2002 2002 2002 2002-2003 2002-2003 2002-2003 2003 2003 2004 2005 2004 2005 2005 2006 Propritaire CWI CNRI CNRI BeOpen.com CNRI PSF PSF PSF PSF PSF PSF PSF PSF PSF PSF PSF PSF PSF PSF PSF PSF PSF PSF PSF compatible GPL ? oui oui non non non non oui oui oui oui oui oui oui oui oui oui oui oui oui oui oui oui oui oui
101
Note: Compatible GPL ne signie pas que nous distribuons Python sous licence GPL. Contrairement GPL, toutes les licences Python vous permettent de distribuer une version modie sans rendre vos changements open source. Une licence compatible GPL rend possible de combiner Python avec dautres logiciels distribus sous GPL, les autres licences non. Merci aux nombreux volontaires extrieurs qui ont travaill sous la direction de Guido pour rendre possibles ces productions.
C.2
Terms and conditions for accessing or otherwise using Python

PSF LICENSE AGREEMENT FOR PYTHON 2.4.3
1. This LICENSE AGREEMENT is between the Python Software Foundation (PSF), and the Individual or Organization (Licensee) accessing and otherwise using Python 2.4.3 software in source or binary form and its associated documentation. 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python 2.4.3 alone or in any derivative version, provided, however, that PSFs License Agreement and PSFs notice of copyright, i.e., Copyright c 2001-2006 Python Software Foundation ; All Rights Reserved are retained in Python 2.4.3 alone or in any derivative version prepared by Licensee. 3. In the event Licensee prepares a derivative work that is based on or incorporates Python 2.4.3 or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python 2.4.3. 4. PSF is making Python 2.4.3 available to Licensee on an AS IS basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.4.3 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.4.3 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.4.3, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions. 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party. 8. By copying, installing or otherwise using Python 2.4.3, Licensee agrees to be bound by the terms and conditions of this License Agreement. BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0 BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1 1. This LICENSE AGREEMENT is between BeOpen.com (BeOpen), having an ofce at 160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization (Licensee) accessing and otherwise using this software in source or binary form and its associated documentation (the Software). 2. Subject to the terms and conditions of this BeOpen Python License Agreement, BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use the Software alone or in any derivative version, provided, however, that the BeOpen Python License is retained in the Software, alone or in any derivative version prepared by Licensee. 3. BeOpen is making the Software available to Licensee on an AS IS basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 102 Annexe C. Historique et licence
4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. 5. This License Agreement will automatically terminate upon a material breach of its terms and conditions. 6. This License Agreement shall be governed by and interpreted in all respects by the law of the State of California, excluding conict of law provisions. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between BeOpen and Licensee. This License Agreement does not grant permission to use BeOpen trademarks or trade names in a trademark sense to endorse or promote products or services of Licensee, or any third party. As an exception, the BeOpen Python logos available at http ://www.pythonlabs.com/logos.html may be used according to the permissions granted on that web page. 7. By copying, installing or otherwise using the software, Licensee agrees to be bound by the terms and conditions of this License Agreement. CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1 1. This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an ofce at 1895 Preston White Drive, Reston, VA 20191 (CNRI), and the Individual or Organization (Licensee) accessing and otherwise using Python 1.6.1 software in source or binary form and its associated documentation. 2. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python 1.6.1 alone or in any derivative version, provided, however, that CNRIs License Agreement and CNRIs notice of copyright, i.e., Copyright c 1995-2001 Corporation for National Research Initiatives ; All Rights Reserved are retained in Python 1.6.1 alone or in any derivative version prepared by Licensee. Alternately, in lieu of CNRIs License Agreement, Licensee may substitute the following text (omitting the quotes) : Python 1.6.1 is made available subject to the terms and conditions in CNRIs License Agreement. This Agreement together with Python 1.6.1 may be located on the Internet using the following unique, persistent identier (known as a handle) : 1895.22/1013. This Agreement may also be obtained from a proxy server on the Internet using the following URL : http ://hdl.handle.net/1895.22/1013. 3. In the event Licensee prepares a derivative work that is based on or incorporates Python 1.6.1 or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python 1.6.1. 4. CNRI is making Python 1.6.1 available to Licensee on an AS IS basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions. 7. This License Agreement shall be governed by the federal intellectual property law of the United States, including without limitation the federal copyright law, and, to the extent such U.S. federal law does not apply, by the law of the Commonwealth of Virginia, excluding Virginias conict of law provisions. Notwithstanding the foregoing, with regard to derivative works based on Python 1.6.1 that incorporate non-separable material that was previously distributed under the GNU General Public License (GPL), the law of the Commonwealth of Virginia shall govern this License Agreement only as to issues arising under or with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between CNRI and Licensee. This License Agreement does not grant permission to use CNRI trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party. 8. By clicking on the ACCEPT button where indicated, or by copying, installing or otherwise using Python 1.6.1, Licensee agrees to be bound by the terms and conditions of this License Agreement. C.2. Terms and conditions for accessing or otherwise using Python 103
ACCEPT CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2 Copyright c 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The Netherlands. All rights reserved. Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Stichting Mathematisch Centrum or CWI not be used in advertising or publicity pertaining to distribution of the software without specic, written prior permission. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
C.3
Licenses and Acknowledgements for Incorporated Software
This section is an incomplete, but growing list of licenses and acknowledgements for third-party software incorporated in the Python distribution.
C.3.1
Mersenne Twister
The _random module includes code based on a download from http ://www.math.keio.ac.jp/ matumoto/MT2002/emt19937ar.html. The following are the verbatim comments from the original code :
A C-program for MT19937, with initialization improved 2002/1/26. Coded by Takuji Nishimura and Makoto Matsumoto. Before using, initialize the state by using init_genrand(seed) or init_by_array(init_key, key_length). Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura, All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The names of its contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
104
Annexe C. Historique et licence
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Any feedback is very welcome. http://www.math.keio.ac.jp/matumoto/emt.html email: matumoto@math.keio.ac.jp
C.3.2
Sockets
The socket module uses the functions, getaddrinfo, and getnameinfo, which are coded in separate source les from the WIDE Project, http ://www.wide.ad.jp/about/index.html.
Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the project nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS AS IS AND GAI_ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE FOR GAI_ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON GAI_ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN GAI_ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
C.3.3
Floating point exception control
The source for the fpectl module includes the following notice :
C.3. Licenses and Acknowledgements for Incorporated Software
105
--------------------------------------------------------------------Copyright (c) 1996. \ | The Regents of the University of California. | | All rights reserved. | | | | Permission to use, copy, modify, and distribute this software for | | any purpose without fee is hereby granted, provided that this en| | tire notice is included in all copies of any software which is or | | includes a copy or modification of this software and in all | | copies of the supporting documentation for such software. | | | | This work was produced at the University of California, Lawrence | | Livermore National Laboratory under contract no. W-7405-ENG-48 | | between the U.S. Department of Energy and The Regents of the | | University of California for the operation of UC LLNL. | | | | DISCLAIMER | | | | This software was prepared as an account of work sponsored by an | | agency of the United States Government. Neither the United States | | Government nor the University of California nor any of their em| | ployees, makes any warranty, express or implied, or assumes any | | liability or responsibility for the accuracy, completeness, or | | usefulness of any information, apparatus, product, or process | | disclosed, or represents that its use would not infringe | | privately-owned rights. Reference herein to any specific commer| | cial products, process, or service by trade name, trademark, | | manufacturer, or otherwise, does not necessarily constitute or | | imply its endorsement, recommendation, or favoring by the United | | States Government or the University of California. The views and | | opinions of authors expressed herein do not necessarily state or | | reflect those of the United States Government or the University | | of California, and shall not be used for advertising or product | \ endorsement purposes. / --------------------------------------------------------------------/
C.3.4
MD5 message digest algorithm
The source code for the md5 module contains the following notice :
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights reserved. License to copy and use this software is granted provided that it is identified as the "RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing this software or this function. License is also granted to make and use derivative works provided that such works are identified as "derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing the derived work.
106
RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided "as is" without express or implied warranty of any kind. These notices must be retained in any copies of any part of this documentation and/or software.
C.3.5
Asynchronous socket services
The asynchat and asyncore modules contain the following notice :

Copyright 1996 by Sam Rushing All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Sam Rushing not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. SAM RUSHING DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SAM RUSHING BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
C.3.6
Cookie management
The Cookie module contains the following notice :

Copyright 2000 by Timothy OMalley <timo@alum.mit.edu> All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Timothy OMalley not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission.
107
Timothy OMalley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL Timothy OMalley BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
C.3.7
Proling
The profile and pstats modules contain the following notice :

Copyright 1994, by InfoSeek Corporation, all rights reserved. Written by James Roskind Permission to use, copy, modify, and distribute this Python software and its associated documentation for any purpose (subject to the restriction in the following sentence) without fee is hereby granted, provided that the above copyright notice appears in all copies, and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of InfoSeek not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. This permission is explicitly restricted to the copying and modification of the software to remain in Python, compiled Python, or other languages (such as C) wherein the modified or derived code is exclusively imported into a Python module. INFOSEEK CORPORATION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INFOSEEK CORPORATION BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
C.3.8
Execution tracing
The trace module contains the following notice :

portions copyright 2001, Autonomous Zones Industries, Inc., all rights... err... reserved and offered to the public under the terms of the Python 2.2 license. Author: Zooko OWhielacronx http://zooko.com/ mailto:zooko@zooko.com Copyright 2000, Mojam Media, Inc., all rights reserved. Author: Skip Montanaro
108
Copyright 1999, Bioreason, Inc., all rights reserved. Author: Andrew Dalke Copyright 1995-1997, Automatrix, Inc., all rights reserved. Author: Skip Montanaro Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved. Permission to use, copy, modify, and distribute this Python software and its associated documentation for any purpose without fee is hereby granted, provided that the above copyright notice appears in all copies, and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of neither Automatrix, Bioreason or Mojam Media be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission.
C.3.9
UUencode and UUdecode functions
The uu module contains the following notice :

Copyright 1994 by Lance Ellinghouse Cathedral City, California Republic, United States of America. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Lance Ellinghouse not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. Modified by Jack Jansen, CWI, July 1995: - Use binascii module to do the actual line-by-line conversion between ascii and binary. This results in a 1000-fold speedup. The C version is still 5 times faster, though. - Arguments more compliant with python standard
C.3.10
XML Remote Procedure Calls
The xmlrpclib module contains the following notice :

The XML-RPC client interface is Copyright (c) 1999-2002 by Secret Labs AB Copyright (c) 1999-2002 by Fredrik Lundh
109
By obtaining, using, and/or copying this software and/or its associated documentation, you agree that you have read, understood, and will comply with the following terms and conditions: Permission to use, copy, modify, and distribute this software and its associated documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appears in all copies, and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Secret Labs AB or the author not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
========================================================== La version traduite en franais de ce document, rsultat du travail initial de plusieurs traducteurs (Olivier Berger, Daniel Calvelo Aros, Bruno Linard) a t assemble et mise jour par Olivier Berger dans le cadre du projet bnvole de traduction en franais de la documentation Python. Pour contribuer au projet, ou obtenir une mise jour de ce document, veuillez vous reporter au site Internet suivant : http ://sourceforge.net/projects/frpython. Ce document est issu de la traduction du document original en anglais V1.5.1 de Guido Van Rossum, avec son aimable permission. Il a t mis--jour rgulirement pour tenir compte des volutions du document original. La prsente version est jour par rapport la V2.0.1. Les questions concernant le langage Python ou le contenu du prsent document sont adresser directement lauteur. ========================================================== La prsente mise jour de la traduction, synchrone avec la dernire version amricaine en date Release 2.4.3 a t ralise par Henri Garreta. Merci de lui envoyer (henri.garreta@univmed.fr) les signalements derreurs et les remarques concernant la traduction.
110
ANNEXE
Glossaire
>>> Invite Python usuelle dans un shell interactif. Souvent montre dans les exemples de code extraits de sessions de linterprteur Python. ... Invite Python habituelle, dans un shell interactif, lorsquil faut entrer le code dun bloc indent. BDFL Benevolent Dictator For Life, cest--dire Guido van Rossum, le crateur de Python. byte code (langage intermdiaire) Reprsentation interne, dans linterprteur, dun programme Python. Le bytecode peut galement tre rang dans des chiers .pyc et .pyo, ainsi lexcution dun mme chier est plus rapide les fois ultrieures (la compilation du source en byte code peut tre vite). On dit que le bytecode tourne sur une machine virtuelle qui, essentiellement, se rduit une collection dappels des routines correspondant chaque code du bytecode. classic class (classe classique) Une classe qui nhrite pas de la classe object. Voir new-style class. coercion (coercition) Conversion implicite dune instance dun type dans un autre type dans une opration concernant deux arguments de types compatibles. Par exemple, int(3.15) convertit le nombre ottant 3.15 en lentier 3, mais dans 3+4.5, chaque argument est dun type diffrent (lun int et lautre float) et doivent tre convertis dans un mme type avant de faire laddition, sinon une exception TypeError sera lance. La coercion entre deux oprandes peut tre effectue avec la fonction incorpore coerce ; ainsi, 3+4.5 est quivalent lappel operator.add(*coerce(3, 4.5)) et produit operator.add(3.0, 4.5). Si la coercition nexistait pas, tous les arguments, mme de types compatibles, devraient tre normaliss en un mme type par le programmeur en crivant, par exemple, float(3)+4.5 au lieu de simplement 3+4.5. complex number (nombre complexe) Une extension du systme familier des nombres rels dans laquelle tous les nombres sont exprims comme la somme dune partie relle et une partie imaginaire. Les nombres imaginaires sont des multiples rels de lunit imaginaire (la racine carre de -1), souvent crite i par les mathmaticiens et j par les ingnieurs. Python a un traitement incorpor des nombres complexes, qui sont crits avec cette deuxime notation ; la partie imaginaire est crite avec un sufxe j, par exemple 3+1j. Pour avoir accs aux quivalents complexes des lments du module math utilisez le module cmath. Lutilisation des nombres complexes est une possibilit mathmatique assez avance. Si vous ntes pas certain den avoir besoin vous pouvez presque certainement les ignorer. descriptor (descripteur) Un objet de style nouveau (voir new-style) qui dnit les mthodes __get__(), __set__() ou __delete__(). Lorsquun attribut dune classe est un descripteur, un comportement spcique est dclench lors de la consultation de lattribut. Normalement, crire a.b consulte lobjet b dans le dictionnaire de la classe de a, mais si b est un descripteur, la mthode __get__() est appele. Comprendre les descripteurs est fondamental pour la comprhension profonde de Python, car ils sont la base de nombreuses caractristiques, comme les fonctions, les mthodes, les proprits, les mthodes de classe, les mthodes statiques et les rfrences aux super-classes. dictionary (dictionnaire) Une table associative, dans laquelle des cls arbitraires sont associes des valeurs. Lutilisation des objets dict ressemble beaucoup celle des objets list, mais les cls peuvent tre nimporte quels objets ayant une fonction __hash__(), non seulement des entiers partant de zro. Ces tables sont appeles hash en Perl. duck-typing (typage comme un canard) Style de programmation en Python dans lequel on dtermine le type dun objet par inspection de ses mthodes et attributs plutt que par des relations explicites des types (sil 111
ressemble un canard et fait coin-coin comme un canard alors ce doit tre un canard). En mettant laccent sur des interfaces plutt que sur des types spciques on amliore la exibilit du code en permettant la substitution polymorphe. Ce mode de typage vite les tests qui utilisent type() ou isinstance() ; la place, il emploie des tests comme hasattr() et le style de programmation EAFP. EAFP (Easier to ask for forgiveness than permission, ou plus facile de demander pardon que la permission). Ce style courant de programmation en Python consiste supposer lexistence des cls et des attributs ncessaires lexcution dun code et attraper les exceptions qui se produisent lorsque de telles hypothses se rvlent fausses. Cest un style propre et rapide, caractris par la prsence de nombreuses in structions try et except. Cette technique contraste avec le style LBYL, courant dans dautres langages comme le C. __future__ Un pseudo-module que les programmeurs peuvent utiliser pour permettre les nouvelles fonctionnalits du langage qui ne sont pas compatibles avec linterprteur couramment employ. Par exemple, lvaluation de lexpression 11/4 donne couramment 2. Si le module dans lequel on fait cette valuation a activ true division en excutant :
from __future__ import division
la valeur de lexpression 11/4 sera 2.75. En important __future__ et en valuant ses variables, vous pouvez voir quel moment une caractristique nouvelle a t ajoute au langage et quand est-elle devenue la fonctionnalit par dfaut :
>>> import __future__ >>> __future__.division _Feature((2, 2, 0, alpha, 2), (3, 0, 0, alpha, 0), 8192)
generator (fonction gnrateur) Une fonction qui renvoie un itrateur. Elle ressemble une fonction normale, except que la valeur de la fonction est rendue lappelant en utilisant une instruction yield au lieu dune instruction return. Les fonctions gnrateurs contiennent souvent une ou plusieurs boucles for ou while qui cdent des lments lappelant. Lexcution de la fonction est stoppe au niveau du mot-cl yield, en renvoyant un rsultat, et elle est reprise lorsque llment suivant est requis par un appel de la mthode next() de litrateur. generator expression (expression gnrateur) Une expression qui renvoie un gnrateur. Elle ressemble une expression normale suivie dune expression for dnissant une variable de contrle, un intervalle et une expression if facultative. Toute cette expression combine produit des valeurs pour une fonction englobante :
>>> sum(i*i for i in range(10)) 285 # somme des carrs 0, 1, 4, ... 81
GIL Voir global interpreter lock. global interpreter lock (verrou global de linterprteur) Le verrou utilis par les threads Python pour assurer quun seul thread tourne un instant donn. Il simplie Python en garantissant que deux processus ne peuvent pas accder en mme temps une mme mmoire. Bloquer linterprteur tout entier lui permet dtre multi-thread aux frais du paralllisme du systme environnant. Des efforts ont t faits par le pass pour crer un interprteur free-threaded (o les donnes partages sont verrouilles avec une granularit ne), mais les performances des programmes suffraient considrablement, y compris dans le cas des programmes mono-thread. IDLE Un environnement de dveloppement intgr pour Python. IDLE est un diteur basique et un environnement dinterprtation ; il est donn avec la distribution standard de Python. Excellent pour les dbutants, il peut aussi servir dexemple propre pour tous ceux qui doivent implmenter une application avec interface utilisateur graphique multi-plate-forme. immutable (immuable) Un objet avec une valeur xe. Par exemple, les nombres, les chanes, les tuples, etc. De tels objets ne peuvent pas tre altrs ; pour changer de valeur un nouvel objet doit tre cr. Les objets immuables jouent un rle important aux endroits o une valeurs de hash constantes sont requises, par exemple les cls des dictionnaires. integer division (division entire) Division mathmatique dans laquelle le reste est perdu. Par exemple, lexpression 11/4 vaut couramment 2, par opposition la valeur 2.75 renvoye par la division ottante. galement appele quotient par dfaut ou oor division. 112 Annexe D. Glossaire
Lorsquon divise deux entiers le rsultat est entier ; cependant, si un des oprandes est dun autre type numrique, comme float, le rsultat doit tre forc (voir coercion) vers un type commun. Par exemple, un entier divis par un ottant donnera un ottant, ventuellement avec une partie fractionnaire. La division entire peut tre force en utilisant loprateur // au lieu de /. Voir aussi __future__. interactive (interactif) Python possde un interprteur interactif, ce qui signie que vous pouvez essayer vos ides et voir immdiatement les rsultats. Il suft de lancer python sans arguments (ventuellement en le slectionnant dans un certain menu principal de votre ordinateur). Cest vraiment un moyen puissant pour tester les ides nouvelles ou pour inspecter les modules et les paquetages (pensez help(x)). interpreted (interprt) Python est un langage interprt, par opposition aux langages compils. Cela signie que les chiers source peuvent tre directement excuts sans avoir besoin de crer pralablement un chier binaire excut ensuite. Typiquement, les langages interprts ont un cycle de dveloppement et de mise au point plus court que les langages compils mais leurs programmes sexcutent plus lentement. Voir aussi interactive. iterable Un objet conteneur capable de renvoyer ses membres un par un. Des exemples diterables sont les types squences (comme les list, les str, et les tuple) et quelques types qui ne sot pas des squences, comme les objets dict, les objets file et les objets de nimporte quelle classe que vous dnissez avec une mthode __iter__() ou une mthode __getitem__(). Les iterables peuvent tre utiliss dans les boucles for et dans beaucoup dautres endroits o une squence est requise (zip(), map(), . . .). Lorsquun objet iterable est pass comme argument la fonction incorpore iter() il renvoie un itrateur. Cet itrateur est un bon moyen pour effectuer un parcours dun ensemble de valeurs. Lorsquon utilise des iterables, il nest gnralement pas ncesaire dappeler la fonction iter() ni de manipuler directement les valeurs en question. Linstruction for fait cela automatiquement pour vous, en crant une variable temporaire sans nom pour grer litrateur pedant la dure de litration. Voir aussi iterator, sequence, et generator. iterator (iterateur) Un objet reprsentant un ot de donnes. Des appeles rpts la mthode next() de litrateur renvoient des lments successifs du ot. Lorsquil ny a plus de donnes disponibles dans le ot une exception StopIteration est lance. A ce moment-l, lobjet itrateur est puis et tout appel ultrieur de la mthode next() ne fait que lancer encore une exception StopIteration. Les itrateurs sont obligs davoir une mthode __iter__() qui renvoie lobjet itrateur lui-mme. Ainsi un itrateur est iterable et peut tre utilis dans beaucoup dendroits o les iterables sont accepts ; une exception notable est un code qui tenterait des itrations multiples. Un objet conteneur (comme un objet list) produit un nouvel itrateur chaque fois quil est pass la fonction iter() ou bien utilis dans une boucle for. Si on fait cela avec un itrateur on ne rcuprera que le mme itrateur puis utilis dans le parcours prcdent, ce qui dera apparatre le conteneur comme sil tait vide. LBYL (Look before you leap ou regarder avant dy aller). Ce style de code teste explicitement les pr-conditions avant deffectuer un appel ou une recherche. Ce style soppose lapproche EAFP et est caractris par la prsence de nombreuses instructions if. list comprehension Une manire compacte deffectuer un traitement sur un sous-ensemble dlments dune squence en renvoyant une liste avec les rsultats. Par exemple result = ["0x%02x" % x for x in range(256) if x % 2 == 0] engendre une liste de chanes contenant les critures hexadcimales des nombres impairs de lintervalle de 0 255. La clause if est facultative. Si elle est omise, tous les lments de lintervalle range(256) seront traits. mapping (liste associative) Un objet conteneur (comme dict) qui supporte les recherches par des cls arbitraires en utilisant la mthode spciale __getitem__(). metaclass La casse dune classe. La dnition dune classe cre un nom de classe, un dictionnaire et une liste de classes de base. La mtaclasse est responsable de la cration de la classe partir de ces trois lments. Beaucoup de langages de programmation orients objets fournissent une implmentation par dfaut. Une originalit de Python est quil est possible de crer des mtaclasses personnalises. Beaucoup dutilisateurs nauront jamais besoin de cela mais, lorsque le besoin apparat, les mtaclasses fournissent une solution puissante et lgante. mutable (modiable) Les objets modiables peuvent changer leur valeur tout en gardant leur id(). Voir aussi immutable. namespace (espace de noms) Lendroit o une variable est conserve. Les espaces de noms sont implments comme des dictionnaires. Ils peuvent tre locaux, globaux et intgrs et galement imbriqus dans les objets. Les espaces de noms contribuent la modularit en prvenant les conits de noms. Par exemple, les fonctions __builtin__.open() et os.open() se distinguent par leurs espaces de noms. 113
Les espaces de noms contribuent aussi la lisibilit et la maintenablit en clariant quel module implmente une fonction. Par exemple, en crivant random.seed() ou itertools.izip() on rend vident que ces fonctions sont implmentes dans les modules random et itertools respectivement. nested scope (porte imbrique) La possibilit de faire rfrence une variable dune dnition englobante. Par exemple, une fonction dnie lintrieur dune autre fonction peut faire rfrence une variable de la fonction extrieure. Notez que le portes imbrique fonctionnent uniquement pour la rfrence aux variables et non pour leur affectation, qui concerne toujours la porte imbrique. Les variables locales sont lues et crites dans la porte la plus intrieure ; les variables globales sont lues et crites dans lespace de noms global. new-style class (classe de style nouveau) Une classe qui hrite de object. Cela comprend tous les types incorpors, comme list et dict. Les classes de style nouveau sont les seules qui peuvent utiliser les plus rcentes, riches et souples caractristiques de Python, comme __slots__, les descripteurs, les proprits, __getattribute__(), les mthodes de classe et les mthodes statiques. Python3000 Une version mythique de Python, non ncessairement compatible avec les prcdentes, possdant une interface tlpathique. __slots__ Une dclaration lintrieur dune classe de style nouveau qui conomise la mmoire en pr-dclarant lespace pour les attributs et en liminant en consquence les dictionnaires dinstance. Bien que populaire, cette technique est quelque peu difcile mettre en place et doit tre rserve aux rares cas o il y a un nombre important dinstances dans une application o la mmoire est rduite. sequence Un iterable qui offre un accs efcace aux lments en utilisant des indices entiers et les mthodes spciales __getitem__() et __len__(). Des types squences incorpors sont list, str, tuple et unicode. Notez que le type dict comporte aussi les mthodes __getitem__() et __len__(), mais est considr comme une table associative plutt que comme une squence car la recherche se fait laide de cls arbitraires immuables au lieu dentiers. Zen of Python Une liste de principes mthodologiques et philosophiques utiles pour la comprhension et lutilisation du langage Python. Cette liste peut tre obtenue en tapant import this dans linterprteur Python.
114
Annexe D. Glossaire

Tut Oriel Python

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Tut Oriel Python

Transféré par

Droits d'auteur :

Formats disponibles

Tutoriel Python

Guido van Rossum Fred L. Drake, Jr., editor

Python Software Foundation E-mail: docs@python.org

TABLE DES MATIRES

Exceptions dnies par lutilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dnir les actions de nettoyage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

B Arithmtique virgule ottante : problmes et limites B.1 Erreur de reprsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Pour vous mettre en apptit

Chapitre 1. Pour vous mettre en apptit

Utilisation de linterprteur Python

Linterprteur et son environnement

Scripts Python excutables

problme avec la bibliothque GNU Readline peut empcher cela.

Chapitre 2. Utilisation de linterprteur Python

Encodage du chier source

Le chier de dmarrage interactif

2.2. Linterprteur et son environnement

import os filename = os.environ.get(PYTHONSTARTUP) if filename and os.path.isfile(filename): execfile(filename)

Chapitre 2. Utilisation de linterprteur Python

Une introduction informelle Python

Utiliser Python comme calculatrice

>>> 4 >>> ... 4 >>> 4 >>> 5 >>> ... 2 >>> -3

Une valeur peut tre affecte plusieurs variables simultanment :

Chapitre 3. Une introduction informelle Python

>>> a=1.5+0.5j >>> a.real 1.5 >>> a.imag 0.5

3.1. Utiliser Python comme calculatrice

Affiche cette notice dusage hte auquel il faut se connecter

produit lafchage suivant :

Chapitre 3. Une introduction informelle Python

Usage: trucmuche [OPTIONS] -h -H hte

Affiche cette notice dusage hte auquel il faut se connecter

Cest ok Cest ok Ca cest faux

3.1. Utiliser Python comme calculatrice

Voici un invariant utile des oprations de dcoupage : s[ :i] + s[i :] gale s.

Chapitre 3. Une introduction informelle Python

Chapitre 3. Une introduction informelle Python

3.1. Utiliser Python comme calculatrice

La fonction intgre len() sapplique aussi aux listes :

Premiers pas vers la programmation

Chapitre 3. Une introduction informelle Python

>>> ... ... >>> ... ... ... 1 1 2 3 5 8

Une virgule nale empche le retour chariot aprs lafchage :

3.2. Premiers pas vers la programmation

Dautres outils de contrle dexcution

Peut-tre linstruction la plus connue est-elle linstruction if. Par exemple :

Chapitre 4. Dautres outils de contrle dexcution

4.5. LInstruction pass

Chapitre 4. Dautres outils de contrle dexcution

Encore plus sur la dnition de fonctions

Valeurs dargument par dfaut

4.7. Encore plus sur la dnition de fonctions

pourrait tre appele de lune des faons suivantes :

mais les appels suivants seraient tous invalides :

Elle pourrait tre appele comme ceci :

et bien sr, elle crirait :

Listes darguments arbitraires

Listes darguments dballer

# appel avec des arguments dballs depuis une liste

4.7. Encore plus sur la dnition de fonctions

Les formes lambda

Chanes de documentation (Docstrings)

Chapitre 4. Dautres outils de contrle dexcution

4.7. Encore plus sur la dnition de fonctions

Plus de dtails sur les listes

Utiliser les listes comme des piles