Python Tutoriel FR

Tutoriel Python
Release 2.0.1
Guido van Rossum Fred L. Drake, Jr., editor
June 22, 2001
PythonLabs E-mail: python-docs@python.org
c Copyright 2000 BeOpen.com. All rights reserved. c Copyright 1995-2000 Corporation for National Research Initiatives. All rights reserved. c Copyright 1991-1995 Stichting Mathematisch Centrum. All rights reserved.
Copyright c 2001 Python Software Foundation. All rights reserved. See the end of this document for complete license and permissions information.
R sum e e Python est un langage de programmation facile a utiliser et puissant. Il offre des structures de donn es puissantes de ` e haut niveau et une approche simple mais r elle de la programmation orient e-objet. La syntaxe el gante de python e e e et le typage dynamique, ajout s a sa nature interpr t e, en font un langage id al pour ecrire des scripts et pour le e ` ee e d veloppement rapide dapplications dans de nombreux domaines et sur la plupart des plates-formes. e Linterpr teur python et la vaste librairie standard sont librement disponible pour toutes les plates-formes principales e sous forme de sources ou de binaires a partir du site web de Python, http ://www.python.org, et peuvent etre distribu s ` e librement. Le m me site contient aussi des distributions et des pointeurs vers de nombreux modules Python provenant e dautres fournisseurs, des programmes et des outils, et de la documentation suppl mentaire. e Linterpr teur Python est facilement extensible par de nouvelles fonctions et de nouveaux types de donn es e e impl ment s en C ou en C++ (ou dautres langages appelables depuis le C). Python convient egalement comme e e langage dextension pour des logiciels congurables. Ce tutoriel introduit le lecteur de facon informelle aux concepts et caract ristiques de base du langage et du syst` me e e Python. Il est utile davoir un interpr teur Python disponible pour exp rimenter directement, mais tous les exemples e e sont auto-porteurs, donc le tutoriel peut egalement etre lu sans interpr teur sous la main. e Pour une description des objets et modules standards, voir le document Python Library Reference. Le Python Reference Manual donne une d nition plus formelle du langage. Pour ecrire des extensions en C ou C++, lire les manuels e Extending and Embedding et Python/C API. Il existe aussi plusieurs livres d crivant Python en profondeur. e Ce tutoriel nessaye pas d tre complet et de traiter chaque possibilit , ou m me toutes les caract ristiques utilis es e e e e e couramment. A la place, il pr sente bon nombre des caract ristiques les plus remarquables de Python, et vous donnera e e une bonne id e de la couleur et du style du langage. Apr` s lavoir lu, vous serez capable de lire et d crire des proe e e grammes ou des modules en Python, et vous serez pr ts a en apprendre plus sur les diff rents modules de biblioth` ques e ` e e Python d crits dans le Python Library Reference. e
` TABLE DES MATIERES
1 2
Pour vous Mettre en App tit e 1.1 Et a Partir de L` . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ` a Utilisation de lInterpr teur Python e 2.1 Lancement de lInterpr teur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e 2.2 LInterpr teur et Son Environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e ` Une Introduction Informelle a Python 3.1 Utiliser Python comme Calculatrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Premiers Pas Vers la Programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . DAutres Outils de Contr le dEx cution o e 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 D nition de Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e 4.7 Encore Plus sur la D nition de Fonctions . . . . . . . . . . . . . . . . . . . e Structures de Donn es e 5.1 Plus de D tails sur les Listes . . . . . . . e 5.2 Linstruction del . . . . . . . . . . . . . 5.3 N-uplets (tuples) et S quences . . . . . . e 5.4 Dictionnaires . . . . . . . . . . . . . . . . 5.5 Plus de D tails sur les Conditions . . . . . e 5.6 Comparer Les S quences et dAutres Types e Modules 6.1 Encore Plus sur les Modules 6.2 Modules Standard . . . . . 6.3 La Fonction dir() . . . . 6.4 Paquetages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1 2 3 3 4 7 7 17 19 19 19 20 21 21 22 23 29 29 33 34 35 35 36 37 38 39 40 41 45 45 48 51 51
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . .
Entr es et Sorties e 7.1 Un Formatage de Sortie Plus Fantaisiste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2 Lire et Ecrire des Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Erreurs et Exceptions 8.1 Erreurs de Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2 8.3 8.4 8.5 8.6 9
Exceptions . . . . . . . . . . . . . . Gestion des Exceptions . . . . . . . D clencher des Exceptions . . . . . e Exceptions D nies par lUtilisateur e D nir les Actions de Nettoyage . . e
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
51 52 54 54 55 57 57 58 59 62 63 64 65 65 67
Classes 9.1 Un Mot Sur la Terminologie . . . . . . . . . . 9.2 Les Port es et les Espaces de Noms en Python e 9.3 Une Premi` re Approche des Classes . . . . . e 9.4 Quelques Remarques . . . . . . . . . . . . . 9.5 H ritage . . . . . . . . . . . . . . . . . . . . e 9.6 Variables Priv es . . . . . . . . . . . . . . . . e 9.7 En Vrac . . . . . . . . . . . . . . . . . . . . 9.8 Les Exceptions Peuvent Etre des Classes . . .
10 Et Maintenant ? A Edition dEntr e Interactive et Substitution Historique e A.1 Edition de Ligne . . . . . . . . . . . . . . . . . . . A.2 Substitution Historique . . . . . . . . . . . . . . . A.3 D nition des Touches . . . . . . . . . . . . . . . e A.4 Commentaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
69 69 69 69 70 71 71 71
B Historique et Licence B.1 Historique du logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . B.2 Termes et conditions dacc` s ou de toute autre utilisation de Python . . . . . . . . . . . . . . . . . . e
ii
CHAPITRE
UN
Pour vous Mettre en Appetit

Si vous avez jamais ecrit un long shell-script, vous connaissez probablement ce sentiment : vous aimeriez ajouter en core une autre fonctionnalit , mais il est d j` tellement lent, et tellement gros, et si compliqu ; ou bien la fonctionnalit e ea e e requiert un appel syst` me ou une autre fonction qui est accessible seulement en C . . .Habituellement, le probl` me a e e ` r soudre nest pas sufsamment grave pour justier une r ecriture du script en C ; peut- tre que le probl` me ree e e e quiert des chanes de caract` res de longueur variable ou dautres types de donn es (comme des listes tri es de noms e e e de chiers) qui sont faciles a faire en shell mais n cessitent beaucoup deffort dimpl mentation en C, ou peut- tre ` e e e n tes-vous pas sufsamment familier avec le C. e Une autre situation : peut- tre devez-vous travailler avec plusieurs biblioth` ques C, et le cycle habituel en C ecrire, e e compiler, tester, re-compiler est trop lent. Vous avez besoin de d velopper du logiciel plus rapidement. Ou alors, e peut- tre avez-vous ecrit un programme qui pourrait utiliser un langage dextension, et vous ne voulez pas d nir un e e langage, ecrire et mettre au point un interpr teur pour lui, puis le lier a votre application. e ` Dans toutes ces situations, Python pourrait etre 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 possibilit s que le shell pour des programmes e volumineux. Dautre part, il offre egalement beaucoup plus de v rication derreurs que le C, et, etant un langage de e tr` s haut niveau, il contient des types de donn es de haut niveau int gr s, comme des tableaux redimensionnables et e e e e des dictionnaires, qui vous demanderaient des jours a impl menter efcacement en C. Gr ce a ses types de donn es ` e a ` e plus g n raux, Python est applicable a un domaine de probl` mes beaucoup plus large que Awk ou m me Perl, et de e e ` e e nombreuses choses sont au moins aussi faciles en Python que dans ces langages. Python vous permet de s parer vos programmes en modules qui peuvent etre r utilis s dans dautres programmes en e e e 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 a la programmation en Python. Il y a aussi des modules int gr s qui ` e e fournissent des fonctionnalit s comme les entr es/sorties vers les chiers, les appels syst` mes, les sockets, et m me e e e e des interfaces avec les toolkits dIHM comme Tk. Python est un langage interpr t , ce qui peut vous faire gagner un temps consid rable pendant la r alisation de proee e e grammes car aucune compilation ou edition de liens nest n cessaire. Linterpr teur peut etre utilis de facon interac e e e tive, ce qui facilite lexp rimentation avec les possibilit s du langage, l criture de programmes jetables, ou le test de e e e fonctions pendant le d veloppement ascendant de vos logiciels. Cest aussi une calculatrice de bureau assez pratique. e Python permet d crire des programmes tr` s compacts et lisibles. Les programmes ecrits en Python sont typiquement e e beaucoup plus courts que leurs equivalents en C, pour plusieurs raisons : les types de donn es de haut niveau vous permettent de r aliser des op rations complexes en une seule instruction ; e e e le regroupement des instructions se fait par indentation, sans accolades de d but/n ; e il nest pas n cessaire de d clarer les variables ou les arguments. e e Python est extensible : si vous savez programmer en C, il est facile dajouter une nouvelle fonction int gr e ou un moe e dule dans linterpr teur, soit pour r aliser les op rations critiques a vitesse maximum, soit pour linker les programmes e e e ` en Python a des biblioth` ques qui ne sont disponibles que sous forme binaire (comme une biblioth` que graphique ` e e propri taire). Une fois que vous serez accro, vous pourrez linker linterpr teur Python dans votre application ecrite en e e C et lutiliser comme langage dextension ou de commande pour cette application.
Au passage, le langage est nomm dapr` s l mission de la BBC Monty Pythons Flying Circus et na rien a voir e e e ` avec de vilains reptiles. Faire r f rence a des dialogues des Monty Python dans la documentation nest pas seulement ee ` autoris , cest encourag ! e e
1.1
` ` Et a Partir de La
Maintenant que vous etes tout excit par Python, vous voudrez lexaminer plus en d tail. Puisque la meilleure facon e e dapprendre un langage est de lutiliser, vous etes invit a le faire d` s maintenant. e` e Dans le chapitre suivant, les el ments n cessaires a lutilisation de linterpr teur sont expliqu s. Ce sont des informae e ` e e tions plut t r barbatives, mais essentielles pour pouvoir tester les exemples donn s plus loin. o e e Le reste de ce tutoriel introduit les diff rentes caract ristiques du langage et du syst` me Python a travers des exemples, e e e ` en commencant par les expressions, instructions et types de donn es simples, puis les fonctions et modules, et enn e en survolant des concepts avanc s comme les exceptions et les classes d nies par lutilisateur. e e
Chapitre 1. Pour vous Mettre en Appetit
CHAPITRE
DEUX
Utilisation de lInterpreteur Python

2.1 Lancement de lInterpreteur
Linterpr teur Python est habituellement install a lemplacement /usr/local/bin/python sur les machines Unix sur e e ` 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 r pertoire dans lequel est install linterpr teur est une option dinstallation, dautres e e e endroits sont possibles ; v riez avec votre gourou Python local ou votre administrateur syst` me. (Par exemple, e e /usr/local/python est un autre emplacement populaire.) Tapez le caract` re EOF (Control-D sur U NIX, Control-Z sur DOS ou Windows) a linvite (prompt) principale pour e ` quitter linterpr teur avec un code de retour de z ro. Si ca ne marche pas, vous pouvez quitter linterpr teur en tapant e e e les commandes suivantes : import sys ; sys.exit(). Les fonctions d dition de ligne de linterpr teur ne sont habituellement pas tr` s sophistiqu es. Sur U NIX, celui qui a e e e e install linterpr teur peut avoir activ le support de la biblioth` que GNU Readline, qui ajoute une edition interactive e e e e plus elabor e et des fonctions dhistorique. Peut- tre la v rication la plus rapide pour savoir si l dition de ligne e e e e de commande est support e consiste a taper Control-P au premier prompt afch par Python. Si ca fait un bip, vous e ` e disposez de l dition de ligne de commande ; voir lAnnexe A pour une introduction aux touches. Si rien ne semble e se passer, ou si P est afch , l dition de ligne de commande nest pas disponible ; vous pourrez seulement utiliser e e backspace pour enlever des caract` res de la ligne courante. e Linterpr teur fonctionne en quelque sorte comme le shell U NIX : lorsquil est lanc avec lentr e standard connect e e e e e a un p riph rique tty, il lit et ex cute les commandes interactivement ; lorsquil est lanc avec un nom de chier en ` e e e e argument ou avec un chier comme entr e standard, il lit et ex cute un script depuis ce chier. e e Une troisi` me facon de lancer linterpr teur est python -c commande [arg] ..., ce qui ex cute les inse e e tructions dans commande, de facon analogue a loption -c du shell. Puisque les instructions en Python contiennent ` souvent des espaces ou dautres caract` res qui sont sp ciaux pour le shell, il est conseill de mettre enti` rement entre e e e e guillemets (doubles quotes) la commande. Notez quil y a une diff rence entre python fichier et python <fichier. Dans le second cas, les requ tes e e e en entr e du programme, comme les appels a input() et raw input(), sont effectu es depuis chier. Puisque ce e ` chier a d j` et lu jusqu` la n par linterpr teur avant que le programme ne commence a sex cuter, le programme eae a e ` e rencontrera imm diatement EOF. Dans le premier cas (qui est habituellement ce quon souhaite) les requ tes sont e e satisfaites par l ventuel chier ou p riph rique qui est connect a lentr e standard de linterpr teur Python. e e e e` e e Lorsquun chier script est utilis , il est parfois utile de pouvoir lancer le script et de passer ensuite en mode interactif. e Ceci peut etre fait en passant en param` tre -i avant le script. (Ceci ne marche pas si le script est lu depuis lentr e e e
standard, pour la m me raison expliqu e dans le paragraphe pr c dent.) e e e e
` 2.1.1 Passage de Parametres

Lorsquils sont connus de linterpr teur, le nom du script et les param` tres suppl mentaires sont pass s au script dans e e e e 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 a dire lentr e e e ` e standard), sys.argv[0] est positionn a -. Quand -c commande est utilis , sys.argv[0] est positionn a e` e e` -c. Les options trouv es apr` s -c commande ne sont pas retir es par le traitement des options de linterpr teur e e e e Python mais laiss es dans sys.argv pour etre trait es par la commande. e e
2.1.2 Mode Interactif

Quand les commandes sont lues depuis un terminal, linterpr teur fonctionne en mode interactif. Dans ce mode, e il demande la commande suivante avec le prompt principal, habituellement trois signes sup rieur (>>> ) ; pour e les lignes de continuation, il questionne avec le prompt secondaire, par d faut trois points (... ). Linterpr teur e e imprime un message de bienvenue sp ciant son num ro de version et une notice de copyright avant dafcher le e e prompt principal, par ex. :
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 n cessaires lorsquon saisit une construction sur plusieurs lignes. Comme exemple, e voici une instruction if :
>>> le_monde_est_plat = 1 >>> if le_monde_est_plat: ... print "Gaffe ` pas tomber par dessus bord!" a ... Gaffe ` pas tomber par dessus bord! a
2.2
LInterpreteur et Son Environnement
2.2.1 Gestion des Erreurs

Quand une erreur survient, linterpr teur imprime un message derreur et une trace de l tat de la pile. En mode e e interactif, il retourne alors au prompt principal ; lorsque lentr e se fait depuis un chier, il termine lex cution avec e e un code de sortie diff rent de z ro apr` s avoir imprim la trace de pile. (Les exceptions g r es par une clause except e e e e ee 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 diff rent de z ro ; ceci se produit pour les aberrations internes et certains cas e e de saturation m moire. Tous les messages derreur sont ecrits sur la sortie derreur standard ; lafchage normal des e commandes ex cut es est effectu sur la sortie standard. e e e Taper le caract` re dinterruption (habituellement Control-C ou DEL) au prompt principal ou secondaire annule la e saisie et revient au prompt principal.1 Taper le caract` re dinterruption pendant lex cution dune commande d clenche e e e
1 Un
probl` me avec la biblioth` que GNU Readline peut emp cher ceci. e e e
Chapitre 2. Utilisation de lInterpreteur Python
lexception KeyboardInterrupt, qui peut etre g r e par une instruction try. ee
2.2.2 Scripts Python Executables

Sur les syst` mes U NIX a la BSD, les scripts Python peuvent etre rendus directement ex cutables, comme les shelle ` e scripts, en placant la ligne
#! /usr/bin/env python
(en supposant que linterpr teur est dans le $PATH de lutilisateur au lancement du script) et rendant le chier e ex cutable. Le # ! doit correspondre aux deux premiers caract` res du chier. e e
2.2.3 Le Fichier de Demarrage Interactif

Quand vous utilisez Python de facon interactive, il est souvent pratique que certaines commandes standard soient ex cut es a chaque fois que linterpr teur est lanc . Vous pouvez faire ceci en donnant a la variable denvironnement e e ` e e ` $PYTHONSTARTUP la valeur du nom dun chier contenant vos commandes de d marrage. Ceci est analogue a e ` 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 ex cut dans le m me espace de noms que celui o` sont ex cut es les commandes e e e u e e interactives, de sorte que les objets quil d nit ou importe peuvent etre utilis s directement dans la session interactive. e e 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 r pertoire courant, vous pouvez programmer cela e dans le chier de d marrage global, par ex. execfile(.pythonrc). Si vous voulez utiliser le chier de e d marrage dans un script, vous devez le faire explicitement dans le script : e
import os filename = os.environ.get(PYTHONSTARTUP) if filename and os.path.isfile(filename): execfile(filename)
2.2. LInterpreteur et Son Environnement
CHAPITRE
TROIS
` Une Introduction Informelle a Python

Dans les exemples suivants, la saisie et lafchage seront distingu s par la pr sence ou labsence dinvites (>>> et e e ... ) : 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 a lafchage effectu par linterpr teur. Notez quune invite secondaire ` e e seule sur une ligne signie que vous devez taper une ligne vide ; ceci marque la n des commandes sur plusieurs lignes. De nombreux exemples de ce manuel, m me ceux qui sont saisis a linvite interactive, contiennent des commentaires. e ` Les commentaires en Python commencent par un caract` re di` se, #, et continuent jusqu` la n de la ligne physique. e e a Un commentaire peut se trouver au d but dune ligne derri` re un espace ou du code, mais pas a lint rieur dune chane e e ` e de caract` res lit rale. Un caract` re di` se a lint rieur dune chane est juste un caract` re di` se. e e e e ` e e e Quelques exemples :
# voici le premier commentaire SPAM = 1 # et voici le deuxi`me commentaire e # ... et maintenant un troisi`me! e STRING = "# Ceci nest pas un commentaire."
3.1
Utiliser Python comme Calculatrice
Essayons quelques commandes Python simples. Lancez linterpr teur et attendez lapparition du prompt principal, e >>> . (Ca ne devrait pas etre tr` s long.) e
3.1.1 Nombres
Linterpr teur fonctionne comme une simple calculatrice : vous pouvez y taper une expression et il va en afcher la e valeur. La syntaxe des expression est naturelle : les op rateurs +, -, * et / marchent exactement comme dans la plupart e des langages (par exemple Pascal ou C) ; les parenth` ses peuvent etre utilis es pour les regrouper. Par exemple : e e
>>> 4 >>> ... 4 >>> 4 >>> 5 >>> ... 2 >>> -3
2+2 # Ceci est un commentaire 2+2 2+2 e # et un commentaire sur la mme ligne que le code
(50-5*6)/4 e e # La division des entiers retourne lentier immdiatement infrieur: 7/3 7/-3
Comme en C, le signe egale (=) est utilis pour affecter une valeur a une variable. La valeur dune affectation nest e ` pas afch e : e
>>> largeur = 20 >>> hauteur = 5*9 >>> largeur * hauteur 900
Une valeur peut etre affect e a plusieurs variables simultan ment : e ` e

>>> >>> 0 >>> 0 >>> 0 x = y = z = 0 x y z # Mettre ` zro x, y et z a e
Il y a un support complet des nombres a virgule ottante ; les op rateurs en pr sence de types dop randes m lang s ` e e e e e convertissent les op randes entiers en virgule ottante : e
>>> 4 * 2.5 / 3.3 3.0303030303030303 >>> 7.0 / 2 3.5
` Chapitre 3. Une Introduction Informelle a Python
>>> 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 repr sent s comme deux nombres en virgule ottante, les parties r elle et imae e e ginaire. Pour extraire ces parties dun nombre complexe z, utilisez z.real et z.imag.
>>> 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 facon correcte et unique de convertir un nombre complexe en un nombre r el. e Utilisez abs(z) pour obtenir sa norme (en ottant) ou z.real pour sa partie r elle. e
>>> a=1.5+0.5j >>> float(a) Traceback (innermost last): File "<stdin>", line 1, in ? TypeError: cant convert complex to float; use e.g. abs(z) >>> a.real 1.5 >>> abs(a) 1.5811388300841898
En mode interactif, la derni` re expression afch e est affect e a la variable . Quand vous voulez utiliser Python e e e ` comme calculatrice, cest plus pratique pour continuer les calculs, par exemple :
>>> tva = 17.5 / 100 >>> prix = 3.50 >>> prix * tva 0.6125 >>> prix + _ 4.1125 >>> round(_, 2) 4.11
Cette variable doit etre utilis e en lecture seule par lutilisateur. Ne lui affectez pas une valeur de facon explicite e vous auriez alors cr e une variable locale ind pendante, avec le m me nom, masquant la variable int gr e et son e e e e e comportement magique.
3.1. Utiliser Python comme Calculatrice
` 3.1.2 Chanes de Caracteres

En plus des nombres, Python peut aussi manipuler des chanes, qui peuvent etre exprim es de diff rentes facons. Elles e e peuvent etre 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.
Notez1 que les chanes admettent ou non les caract` res accentu s en mode int ractif suivant votre plate-forme. Si e e e les commandes sont lues depuis un chier, la situation est l g` rement diff rente : en g n ral vous pourrez, mais les e e e e e caract` res accentu s risquent d tre interpr t s diff remment si vous transf rez vos chiers entre des plate-formes e e e ee e e diff rentes. Pour ces questions de portabilit , les identicateurs en Python sont limit s au code ASCII 7 bits. Vous ne e e e pourrez pas (en mode int ractif ou pas) utiliser des lettres accentu es dans les noms de variables, fonctions, modules, e e classes, etc. Les textes dans les chanes peuvent se poursuivre sur plusieurs lignes de plusieurs facons. Les retours chariot peuvent etre pr x s avec un antislash, par ex. : e e
salut = "Ceci est une chane plutot longue contenant\n\ plusieurs lignes de texte excatement comme on le ferait en C.\n\ e Notez que les blancs au dbut de la ligne sont\ significatifs.\n" print salut
ce qui safcherait de la facon 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. e
Ou bien, les chanes peuvent etre entour es par un couple de triple-quotes correspondantes : """ ou . Les ns de e lignes nont pas besoin d tre pr x es lorsquon utilise les triple-quotes, mais elles seront incluses dans la chane. e e e
print """ Usage: trucmuche [OPTIONS] -h -H hte o """
Affiche cette notice dusage hte auquel il faut se connecter o
produit lafchage suivant :

1 NDT
: Ce paragraphe absent de l dition originale a et ajout par Daniel Calvelo Aros a lintention des utilisateurs de Python francophones. e e e `
10
Usage: trucmuche [OPTIONS] -h o -H hte
Affiche cette notice dusage o hte auquel il faut se connecter
Linterpr teur afche le r sultat des op rations sur les chanes de la m me facon qu` la saisie : entre quotes, et e e e e a avec quotes et autres caract` res bizarres pr x s par un antislash, pour afcher leur valeur exacte. La chane sera e e e d limit e par des doubles quotes si elle contient une simple quote et aucune double quote, sinon, elle sera d limit e e e e e par des simples quotes. (Linstruction print, d crite plus loin, peut etre utilis e pour ecrire des chanes sans quotes e e ni caract` res pr x s.) e e e Les chanes peuvent etre concat n es (accol es) avec lop rateur +, et r p t es avec * : e e e e e ee
>>> word = Help + A >>> word HelpA >>> < + word*5 + > <HelpAHelpAHelpAHelpAHelpA>
Deux chanes de texte c te a c te sont automatiquement concat n es ; la premi` re ligne ci-dessus aurait pu etre ecrite o ` o e e e mot = HelpA ; ceci 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 string.strip(cha) ine SyntaxError: invalid syntax
# # #
<<<-
Cest ok Cest ok Ca cest faux
Les chanes peuvent etre d compos es (index es) ; comme en C, le premier caract` re dune chane est en position e e e e (index) 0. Il ny a pas de type caract` re sp cique ; un caract` re est simplement une chane de taille un. Comme en e e e Icon, les sous-chanes peuvent etre sp ci es avec la notation de d coupage (slice) : deux indices s par s par deux e e e e e points.
>>> mot[4] A >>> mot[0:2] He >>> mot[2:4] lp
A la diff rence des chanes de caract` res en C, les chanes Python ne peuvent etre modi es. Faire une affectation a e e e ` lemplacement dun indice dans la chane aboutit a une erreur : `
11
>>> mot[0] = x Traceback (innermost last): File "<stdin>", line 1, in ? TypeError: object doesnt support item assignment >>> mot[:-1] = Splat Traceback (innermost last): File "<stdin>", line 1, in ? TypeError: object doesnt support slice assignment
Cependant, il est facile et efcace de cr er une nouvelle chane avec un contenu combin : e e
>>> x + mot[1:] xelpA >>> Splat + mot[-1:] SplatA
Les indices de d coupage ont des valeurs par d faut utiles ; un premier index non-d ni prend pour valeur par d faut e e e e z ro, un second index omis prend pour valeur par d faut la taille de la chane quon est en train de d couper. e e e
>>> mot[:2] He >>> mot[2:] lpA # Les deux premiers caract`res e # Tout sauf les deux premiers caract`res e
Voici un invariant utile des op rations de d coupage : s[ :i] + s[i :] egale s. e e

>>> mot[:2] + mot[2:] HelpA >>> mot[:3] + mot[3:] HelpA
Les indices de d coupage erron s sont g r s de facon el gante : un index qui est trop grand est remplac par la taille e e ee e e de la chane, un index de n inf rieur a lindice de d but retourne une chane vide. e ` e
>>> mot[1:100] elpA >>> mot[10:] >>> mot[2:1]
Les indices peuvent etre des nombres n gatifs, pour compter a partir de la droite. Par exemple : e `
12
>>> mot[-1] A >>> mot[-2] p >>> mot[-2:] pA >>> mot[:-2] Hel
# Le dernier caract`re e e # Lavant dernier caract`re # Les deux derniers caract`res e e # Tout sauf les deux derniers caract`res
Mais notez que -0 est vraiment la m me chose que 0, donc ca ne compte pas a partir de la droite ! e `
>>> mot[-0] H e # (puisque -0 gale 0)
Les indices de d coupage n gatifs hors limites sont tronqu s, mais nessayez pas ceci avec des indices dacc` s a des e e e e ` el ments uniques (sans d coupage) : e e
>>> mot[-100:] HelpA >>> mot[-10] # erreur Traceback (innermost last): File "<stdin>", line 1 IndexError: string index out of range
La meilleure facon de se rappeler comment marchent les d coupages est de penser aux indices comme pointant entre e les caract` res, avec le bord gauche du premier caract` re num rot 0. Alors le bord droit du dernier caract` re dune e e e e e chane de n caract` res porte lindex n, par exemple : e
+---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1
La premi` re ligne de nombres donne la position des indices 0...5 dans la chane ; la seconde ligne donne les indice e n gatifs correspondants. Le d coupage de i a j consiste en tous les caract` res entre les extr mit s etiquet es i et j, e e ` e e e e respectivement. Pour les indices non n gatifs, la longueur dune tranche est la diff rence entre ses indices, si les deux sont a lint rieur e e ` e des limites, par ex., la longueur de mot[1 :3] est 2. La fonction int gr e len() retourne la longueur dune chane : e e
>>> s = supercalifragilisticexpialidocious >>> len(s) 34
3.1.3 Chanes Unicode

A partir de Python 2.0, un nouveau type de donn es destin a stocker du texte est disponible pour les programmeurs : e e` lobjet Unicode. Il peut etre utilis pour stocker et manipuler des donn es Unicode (voir http ://www.unicode.org) et e e
13
sint` gre bien avec les objets chanes en fournissant des conversions automatiques l` o` cest n cessaire. e a u e Unicode offre lavantage de fournir un num ro pour chaque caract` re de chaque ecriture utilis e dans les textes moe e e dernes et anciens. Auparavant, il ny avait que 256 num ros possibles pour les caract` res d criture et les textes etaient e e e donc typiquement associ s a une page de codes qui r alisait lassociation entre le num ros et les caract` res d criture. e ` e e e e Ceci conduisait a beaucoup de confusion, sp cialement en ce qui concerne linternationalisation ( crite dhabitude ` e e comme i18n i + caract` res 18 + n) des logiciels. Unicode r sout ces probl` mes en d nissant une page de e e e e codes pour toutes les ecritures. Cr er des chanes Unicode en Python est exactement aussi simple que de cr er des chanes normales : e e
>>> uBonjour ! uBonjour !
Le u minuscule devant les guillemets indique quon souhaite cr er une chane Unicode. Si vous d sirez placer e e des caract` res sp ciaux dans la chane, vous pouvez le faire en utilisant lencodage Python Echappement-Unicode. e e Lexemple suivant montre comment faire :
>>> uSalut\\u0020tout le monde ! uSalut tout le monde !
La s quence d chappement e e u0020 indique quil faut ins rer le caract` re Unicode dont le num ro HEX est 0x0020 (le caract` re espace) a lendroit e e e e ` indiqu . e Les autres caract` res sont interpr t s en utilisant leurs valeurs num riques respectives directement comme des num ros e ee e e Unicode. Comme les 256 premiers Unicode sont les m mes que les encodages standard Latin-1 utilis s dans la plupart e e des pays occidentaux, le processus de saisie de lUnicode est grandement simpli . e Pour les experts, il y a aussi un mode brut exactement comme pour les chanes normales. Vous devez ins rer au d but e e de la chane un petit r pour que Python utilise lencodage Echappement-Brut-Escape. 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 extr` mement utile lorsquil sagit de saisir de nombreux antislash, par exemple dans les expressions e rationnelles. En dehors de ces encodages standards, Python fournit tout un ensemble dautres moyens de cr er des chanes Unicode e sur la base dun encodage connu. La fonction unicode() int gr e fournit un acc` s a tous les codecs (COdeurs et DECodeurs) Unicode enregistr s. e e e ` e 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 a longueur variable qui permettent de stocker des caract` res Unicode avec 8 ou ` e 16 bits. Python utilise UTF-8 comme encodage par d faut. On sen appercoit lorsquon imprime des chanes Unicode e ou lorsquon les ecrit dans des chiers.
14
>>> u"" aou u\344\366\374 >>> str(u"") aou \303\244\303\266\303\274
Si vous avez des donn es dans un encodage sp cique et souhaitez produire une chane Unicode correspondante, vous e e pouvez utiliser la fonction unicode() int gr e avec le nom de lencodage comme second argument. e e
>>> unicode(\303\244\303\266\303\274,UTF-8) u\344\366\374
Pour convertir a nouveau la chane Unicode vers une chane en utilisant lencodage original, les objets fournissent une ` m thode encode(). e
>>> u"".encode(UTF-8) aou \303\244\303\266\303\274
3.1.4 Listes
Python connat un grand nombre de types de donn es composites, utilis es pour regrouper un ensemble de valeurs. e e La plus riche en possibilit s est la liste, qui peut etre ecrite comme une liste de valeurs ( l ments) entre crochets et e ee s par s par des virgules. Les el ments dune liste nont pas n cessairement le m me type. e e e e e
>>> a = [spam, eggs, 100, 1234] >>> a [spam, eggs, 100, 1234]
Comme les indices des chanes, les indices des listes commencent a 0, et les listes peuvent etre d coup es, concat n es, ` e e e e 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 diff rence des chanes, qui sont non-modiables, il est possible de changer les el ments individuels dune liste : e e
15
>>> a [spam, eggs, 100, 1234] >>> a[2] = a[2] + 23 >>> a [spam, eggs, 123, 1234]
Laffectation dans des tranches est aussi possible, et ceci peut m me changer la taille de la liste : e
e >>> # Remplacer certains elments: ... a[0:2] = [1, 12] >>> a [1, 12, 123, 1234] >>> # En enlever certains: ... a[0:2] = [] >>> a [123, 1234] >>> # En insrer e ... a[1:1] = [bletch, xyzzy] >>> a [123, bletch, xyzzy, 1234] >>> a[:0] = a # Ins`re (une copie de) soi-mme au dbut e e e >>> a [123, bletch, xyzzy, 1234, 123, bletch, xyzzy, 1234]
La fonction int gr e len() sapplique aussi aux listes : e e

>>> len(a) 8
Il est possible demboter des listes (cr er des listes contenant dautres listes), par exemple : e
>>> >>> >>> 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 pr c dent, p[1] et q se r f` rent r ellement au m me objet ! Nous reviendrons plus tard sur e e ee e e la s mantique des objets. e
16
3.2
Premiers Pas Vers la Programmation
Bien s r, nous pouvons utiliser Python pour des t ches plus compliqu es que dajouter deux et deux. Par exemple, u a e nous pouvons ecrire une sous-s quence de la suite de Fibonacci de la facon suivante : e
>>> ... ... >>> ... ... ... 1 1 2 3 5 8 # Suite de Fibonacci # La somme de deux lments dfinit le suivant e e e a, b = 0, 1 while b < 10: print b a, b = b, a+b
Cet exemple introduit plusieurs fonctionnalit s nouvelles. e La premi` re ligne contient une affectation multiple : les variables a et b prennent simultan ment les nouvelles e e valeurs 0 et 1. Sur la derni` re ligne laffectation multiple est utilis e a nouveau, montrant que les expressions en e e ` partie droite sont dabord toutes evalu es avant quaucune affectation ne se fasse. e La boucle while sex cute tant que la condition (ici : b < 10) reste vraie. En Python, comme en C, toute valeur e enti` re diff rente de z ro est vraie ; z ro est faux. La condition pourrait aussi etre une chane ou une valeur de e e e e type liste, en fait nimporte quelle s quence ; nimporte quoi avec une longueur diff rente de z ro est vrai, les e e e s quences vides correspondent a faux. Le test utilis dans lexemple est une simple comparaison. Les op rateurs de e ` e e comparaison standard sont ecrits de la m me facon quen C : <, >, ==, <=, >= et !=. e Le corps de la boucle est indent : lindentation est le moyen par lequel Python regroupe les instructions. Python ne e fournit pas (encore) une fonction d dition de ligne intelligente, donc vous devez ins rer une tabulation ou un espace e e pour chaque ligne indent e. En pratique vous pr parerez les saisies plus compliqu es avec un editeur de texte ; la e e e plupart des editeurs de texte ont une fonction dauto-indentation. Lorsquune instruction compos e est entr e en e e mode interactif, elle doit etre suivie dune ligne vide pour indiquer quelle est termin e (car linterpr teur ne peut e e pas deviner si vous avez tap la derni` re ligne). e e Linstruction print ecrit la valeur de la ou des expressions qui lui sont donn es. Elle diff` re de la simple ecriture e e de lexpression (comme tout-` -lheure dans les exemples de la calculatrice) dans la mesure o` elle accepte plusieurs a u expressions et chanes. Les chanes sont imprim es sans quotes, et un espace est ins r entre les el ments, ce qui e ee e 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 emp che le retour chariot apr` s lafchage : e e

>>> 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 linterpr teur ins` re un retour chariot avant dimprimer le prompt suivant si la ligne na pas et compl t e. e e e ee
3.2. Premiers Pas Vers la Programmation
17
18
CHAPITRE
QUATRE
DAutres Outils de Controle dExecution

A part linstruction while que lon vient de d couvrir, Python comprend les instructions de contr le dex cution e o e habituelles connues dans dautres langages, avec quelques adaptations.
4.1
Instructions if
Peut- tre linstruction la plus connue est-elle linstruction if. Par exemple : e
>>> ... ... ... ... ... ... ... ... ... if x < 0: x = 0 e e e print Ngatif chang en zro elif x == 0: print Zro e 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 e abr viation de else if, et est utile pour eviter une indentation excessive. Une s quence if . . . elif . . . elif . . . est e e un substitut pour les instructions switch ou case quon trouve dans dautres langages.
4.2
Instructions for
Linstruction for en Python diff` re un petit peu de ce que vous avez pu utiliser en C ou en Pascal. Au lieu dit rer e e toujours dans une progression arithm tique de nombres (comme en Pascal), ou de laisser lutilisateur compl` tement e e libre dans les tests et les pas dit ration (comme en C), linstruction for de Python it` re parmi les el ments de e e e nimporte quelle s quence (par ex., une liste ou une chane), dans lordre o` ils apparaissent dans la s quence. Par e u e exemple (aucun jeu de mots volontaire) :
19
>>> # Mesurer quelques chanes: e e ... a = [chat, fentre, dfenestrer] >>> for x in a: ... print x, len(x) ... chat 4 fentre 7 e dfenestrer 11 e
Il nest pas prudent de modier la s quence sur laquelle on it` re dans la boucle (ceci peut seulement arriver pour les e e types de s quences modiables, par exemple, les listes). Si vous avez besoin de modier la liste sur laquelle vous it rez, e e par exemple, pour dupliquer des el ments s lectionn s, vous devez it rer sur une copie. La notation de d coupage rend e e e e e ceci particuli` rement pratique : e
>>> for x in a[:]: # fait une copie de la liste enti`re par dcoupage e e ... if len(x) > 8: a.insert(0, x) ... >>> a [dfenestrer, chat, fentre, dfenestrer] e e e
4.3
La Fonction range()
Si vous avez besoin dit rer sur une s quence de nombres, la fonction int gr e range() vient a point. Elle g n` re e e e e ` e e des listes contenant des progressions arithm tiques, par ex. : e
>>> 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 g n r e ; range(10) g n` re une liste de 10 valeurs, e e ee e e exactement les indices des el ments dune s quence de longueur 10. Il est possible de faire commencer lintervalle a e e ` un autre nombre, ou de sp cier un incr ment diff rent (m me n gatif) : e e e e e
>>> 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 s quence, combinez range() et len() comme ci-dessous : e
20
Chapitre 4. DAutres Outils de Controle dExecution
>>> 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, egalement emprunt e au C, continue sur la prochaine it ration de la boucle. e e Les instructions de boucle ont une clause else ; elle est ex cut e lorsque la boucle se termine par epuisement de la e e liste (avec for) ou quand la condition devient fausse (avec while), mais pas quand la boucle est interrompue par une instruction break. Ceci est expliqu dans la boucle suivante, qui recherche des nombres premiers : e
>>> for n in range(2, 10): ... for x in range(2, n): ... if n % x == 0: ... print n, gale, x, *, n/x e ... break ... else: ... print n, est un nombre premier ... 2 est un nombre premier 3 est un nombre premier 4 gale 2 * 2 e 5 est un nombre premier 6 gale 2 * 3 e 7 est un nombre premier 8 gale 2 * 4 e e 9 gale 3 * 3
4.5
LInstruction pass
Linstruction pass ne fait rien. Elle peut etre utilis e lorsquune instruction est requise syntaxiquement mais que le e programme ne n cessite aucune action. Par exemple : e
>>> while 1: ... pass # Attente active dune interruption au clavier ...
4.4. Les Instructions break et continue, et les Clauses else dans les Boucles
21
4.6
Denition de Fonctions
Nous pouvons cr er une fonction qui ecrit la s rie de Fibonacci jusqu` une limite quelconque : e e a
>>> ... ... ... ... ... ... >>> ... 1 1 a e e def fib(n): # crit la srie de Fibonacci jusqu` n "Affiche une suite de Fibonacci jusqu` n" a a, b = 0, 1 while b < n: print b, a, b = b, a+b # Maintenant on appelle la fonction qui vient juste dtre dfinie e e fib(2000) 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
Le mot-cl def d bute la d nition dune fonction. Il doit etre suivi par le nom de la fonction et une liste entre e e e parenth` ses de param` tres formels. Les instructions qui forment le corps de la fonction commencent sur la ligne e e suivante, indent e par une tabulation. La premi` re instruction du corps de la fonction peut eventuellement etre un texte e e dans une chane de caract` res ; cette chane est la chane de documentation de la fonction, ou docstring. e Il y a des outils qui utilisent les docstrings pour g n rer automatiquement de la documentation papier, ou pour pere e mettre a lutilisateur de naviguer interactivement dans le code ; cest une bonne technique que dinclure les docstrings ` dans le code que vous ecrivez, donc essayez de vous y habituer. Lex cution dune fonction g n` re une nouvelle table de symboles, utilis e pour les variables locales de la fonction. e e e e Plus pr cis ment, toutes les affectations de variables dans une fonction stockent la valeur dans la table de symboles e e locale ; alors que les r f rences a des variables regardent en premier dans la table de symboles locale, puis dans la ee ` table de symboles globale, et enn dans la table des noms int gr s. Ainsi, on ne peut affecter directement une valeur e e aux variables globales a lint rieur dune fonction (` moins de les d clarer avec une instruction global), bien quon ` e a e puisse y faire r f rence. ee Les vrais param` tres (arguments) dun appel de fonction sont introduits dans la table de symboles locale de la fonction e appel e quand elle est appel e ; ainsi, les arguments sont pass s en utilisant un passage par valeur.1 Quand une e e e fonction appel e appelle a son tour une autre fonction, une nouvelle table de symboles locaux est cr ee pour cet appel. e ` e La d nition dune fonction introduit le nom de la fonction dans la table de symboles courante. La valeur du nom de la e fonction a un type qui est reconnu par linterpr teur comme une fonction d nie par lutilisateur. Cette valeur peut etre e e affect e a un autre nom qui peut alors etre utilis aussi comme une fonction. Ceci permet de disposer dun m canisme e ` e e g n ral de renommage : e e
>>> 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 proc dure. En Python, comme en C, les proc dures e e sont juste des fonctions qui ne retournent pas de valeur. En fait, techniquement parlant, les proc dures retournent bien e une valeur, bien quelle soit plut t d cevante. Cette valeur est appel e None (cest un nom int gr ). La valeur None o e e e e nest normalement pas afch e par linterpr teur si elle devait etre la seule valeur ecrite. Vous pouvez le v rier si e e e vous y tenez vraiment :
1 En r alit , passage par r f rence dobjet serait une meilleure description, puisque si un objet modiable est pass , lappelant verra tous les e e ee e changements que lappel y effectue (par ex., des el ments ins r s dans une liste). e e ee
22
>>> print fib(0) None
Ecrire une fonction qui retourne une liste des nombres de la suite de Fibonacci, au lieu de les imprimer, est tr` s simple : e
>>> ... ... ... ... ... ... ... ... >>> >>> [1, a e def fib2(n): # retourne la srie de Fibonacci jusqu` n "Retourne une liste contenant la srie de Fibonacci jusqu` n" e a 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 e e 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Cet exemple, comme dhabitude, d montre quelques nouvelles caract ristiques de Python : e e Linstruction return termine une fonction en renvoyant une valeur. return sans une expression en argument est utilis pour retourner depuis le milieu dune proc dure (aboutir a la n termine aussi la proc dure), auquel cas la e e ` e valeur None est retourn e. e Linstruction result.append(b) appelle une m thode de lobjet result. Une m thode est une fonction qui e e appartient a un objet et est nomm e obj.nommethode, o` obj est un objet (cela pourrait etre une expression), ` e u et nommethode est le nom dune m thode qui est d nie dapr` s le type de lobjet. Diff rents types d nissent e e e e e diff rentes m thodes. Les m thodes de types diff rents peuvent avoir le m me nom sans que cela soit source dame e e e e bigut s. (Il est possible de d nir vos propres types dobjets et m thodes, en utilisant des classes, de la facon e e e d crite en 9.) La m thode append() montr e pr c demment, est d nie pour les objets listes ; elle ajoute un noue e e e e e vel el ment a la n de la liste. Dans cet exemple, cest equivalent a result = result + [b], mais en plus e ` ` performant.
4.7
Encore Plus sur la Denition de Fonctions
Il est aussi possible de d nir des fonctions a nombre darguments variable. Il y a trois facons de faire, qui peuvent e ` etre combin es. e
4.7.1 Valeurs dArgument par Defaut

La technique la plus utile consiste a sp cier une valeur par d faut pour un ou plusieurs arguments. Ceci cr e une ` e e e fonction qui peut etre appel e avec moins darguments quil nen a et d ni, par ex. e e e
4.7. Encore Plus sur la Denition de Fonctions
23
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 etre appel e soit comme ceci : demande ok(Etes vous sur de vouloir e quitter ?)2 ou comme ceci : demande ok(OK pour crasement du fichier ?, 2). e Les valeurs par d faut sont evalu es au moment de la d nition de la fonction dans la port e de d nition, ainsi par e e e e e ex.
i = 5 def f(arg = i): print arg i = 6 f()
afchera 5. Avertissement important : La valeur par d faut est evalu e seulement une fois. Ceci est important lorsque la valeur e e par d faut est un objet modiable comme une liste ou un dictionnaire. Par exemple, la fonction suivante accumule les e arguments qui lui sont pass s au fur et a mesure des appels : e `
def f(a, l = []): l.append(a) return l print f(1) print f(2) print f(3)
Ceci afchera
[1] [1, 2] [1, 2, 3]
Si vous ne voulez pas que la valeur par d faut soit partag e entre des appels successifs, vous pouvez plut t ecrire la e e o fonction comme ceci :
def f(a, l = None): if l is None: l = [] l.append(a) return l
2 NDT : laccent circomexe sur le u de sur safche assez mal chez nous. D sol , mais notre comp tence en LaTeX est limit e. Merci de e e e e nous signaler le correctif.
24
` 4.7.2 Arguments a Mot-Cle

Les fonctions peuvent aussi etre appel es en utilisant des arguments mots-cl s de la forme motcle = valeur. Par e e exemple, la fonction suivante :
def perroquet(voltage, etat=c\est du solide, action=voom, type=Bleu Norvgien): e print "-- Ce perroquet ne fera pas", action, print "si vous le mettez sous", voltage, "Volts." print "-- Beau plumage, le", type print "-- Ca", etat, "!"
pourrait etre appel e de lune des facons suivantes : e

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) e
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 e e doublon de valeurs pour un argument mot-cl inconnu e
En g n ral, une liste darguments doit etre constitu e de tous les arguments de position, suivis de tous les arguments e e e mots-cl s, o` ces mots-cl s doivent etre choisis parmi les noms des param` tres formels. Il nest pas important quun e u e e param` tre formel ait une valeur par d faut ou non. Aucun argument ne peut recevoir une valeur plus dune fois les e e noms de param` tre formel correspondant aux arguments de position ne peuvent etre utilis s comme mots-cl s dans les e e e m mes appels. e
>>> def function(a): ... pass ... >>> function(0, a=0) Traceback (innermost last): File "<stdin>", line 1, in ? TypeError: keyword parameter redefined
Quand un param` tre formel de la forme **nom est pr sent en derni` re position, il recoit un dictionnaire contenant e e e tous les arguments mots-cl s dont les mots-cl s ne correspondent pas a un param` tre formel. Ceci peut etre combin e e ` e e avec un param` tre formel de la forme *nom (d crit dans la sous-section suivante) qui recoit un tuple contenant les e e arguments positionnels au-del` de la liste de param` tres formels. (*nom doit etre plac avant **nom.) Par exemple, a e e nous d nissons une fonction comme ceci : e
25
def fromagerie(type, *arguments, **motcles): print "-- Avez-vous du", type, ? e e print "-- Je suis dsol, plus personne na de", type for arg in arguments: print arg print -*40 for mc in motcles.keys(): print mc, :, motcles[mc]
Elle pourrait etre appel e comme ceci : e

fromagerie(Camembert, "Il est tr`s coulant, monsieur.", e "Il est vraiment tr`s, TRES coulant, monsieur.", e client=John Cleese, proprietaire=Michael Palin, sketch=Sketch de la Fromagerie )
et bien s r, elle ecrirait : u

-- Avez-vous du Camembert ? -- Je suis dsol, plus personne na de Camembert e e Il est tr`s coulant, monsieur. e Il est vraiment tr`s, TRES coulant, monsieur. e ---------------------------------------client : John Cleese proprietaire : Michael Palin sketch : Sketch de la Fromagerie
4.7.3 Listes dArguments Arbitraires

Finalement, loption la moins fr quemment utilis e est de sp cier quune fonction peut etre appel e avec un nombre e e e e darguments arbitraire. Ces arguments seront r cup r s dans un tuple. Avant le nombre variable darguments, z ro ou e ee e plus arguments normaux pourraient etre pr sents. e
def fprintf(fichier, format, *args): fichier.write(format % args)
4.7.4 Les Formes Lambda

Suite a la demande populaire, quelques caract ristiques trouv es habituellement dans les langages de programmation ` e e fonctionnelle et dans Lisp ont et ajout es a Python. Avec le mot-cl lambda, de petites fonctions anonymes peuvent e e ` e etre cr ees. Voici une fonction qui retourne la somme de ses deux arguments : lambda a, b : a+b. Les formes e Lambda peuvent etre utilis es chaque fois quun objet fonction est requis. Elles sont limit es syntaxiquement a une e e ` expression unique. S mantiquement, elles sont juste de lenrobage syntaxique pour une d nition de fonction normale. e e Comme les d nitions de fonctions imbriqu es, les formes lambda ne peuvent pas faire r f rence a des variables de la e e ee ` port e qui les contient, mais ceci peut etre surpass en utilisant judicieusement les valeurs des arguments par d faut, e e e par ex.
def fabrique_incrementeur(n): return lambda x, incr=n: x+incr
26
4.7.5 Chanes de Documentation (Docstrings)

Il existe des conventions emergentes a propos du contenu et du formatage des chanes de documentation. ` La premi` re ligne devrait toujours etre un r sum concis des objectifs de lobjet. An d tre bref, il ne devrait pas e e e e r p ter explicitement le nom ou le type de lobjet, puisque ces informations sont disponibles par dautres moyens e e (sauf si le nom se trouve etre un verbe d crivant lutilisation dune fonction). Cette ligne devrait toujours commencer e par une lettre majuscule et nir par une virgule. Sil y a dautres lignes dans la chane de documentation, la deuxi` me ligne devrait etre vide, s parant visuellement le e e r sum du reste de la description. Les lignes suivantes devraient constituer un ou plusieurs paragraphes d crivant les e e e conventions dappel des objets, ses effets de bord, etc. Linterpr teur python ne supprime pas lindentation des chanes de texte multilignes en Python, donc les outils qui e traitent la documentation doivent supprimer lindentation. Ceci peut se faire en utilisant la convention suivante. La premi` re ligne non-vide apr` s la premi` re ligne de la chane d termine la quantit dindentation pour toute la chane e e e e e de documentation. (On ne peut pas utiliser la premi` re ligne puisquelle est g n ralement adjacente aux quotes oue e e vrantes de la chane donc son indentation nest pas apparente dans le texte de la chane.) Les espaces quivalents e a cette indentation sont ensuite supprim s du d but de toutes les lignes de la chane. Des lignes indent es de facon ` e e e moins importante ne devraient pas apparatre, mais si elles le font, tous leurs espaces en d but de ligne devraient etre e supprim s. L quivalence de lespacement devrait etre test e apr` s lexpansion des tabulations (` 8 espaces, normalee e e e a ment). Voici un exemple de docstring multi-ligne :
>>> 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.
27
28
CHAPITRE
CINQ
Structures de Donnees
Ce chapitre d crit avec plus de d tail quelques el ments que vous avez d j` etudi , et ajoute aussi quelques nouveaut s. e e e ea e e
5.1
Plus de Details sur les Listes
Le type de donn es liste poss` de dautres m thodes. Voici toutes les m thodes des objets listes : e e e e append(x) Equivalent a a.insert(len(a), x). ` extend(L) Rallonge la liste en ajoutant a la n tous les el ments de la liste donn e ; equivalent a a[len(a) :] ` e e ` = L. insert(i, x) Ins` re un el ment a une position donn e. Le premier argument est lindice de l l ment avant e e ` e ee lequel il faut ins rer, donc a.insert(0, x) ins` re au d but de la liste, et a.insert(len(a), x) est e e e equivalent a a.append(x). ` remove(x) Enl` ve le premier el ment de la liste dont la valeur est x. Il y a erreur si cet el ment nexiste pas. e e e pop([i ]) Enl` ve l l ment pr sent a la position donn e dans la liste, et le renvoie. Si aucun indice nest sp ci , e ee e ` e e e a.pop() renvoie le dernier el ment de la liste. L l ment est aussi supprim de la liste. e ee e index(x) Retourne lindice dans la liste du premier el ment dont la valeur est x. Il y a erreur si cet el ment nexiste e e pas. count(x) Renvoie le nombre de fois que x apparat dans la liste. sort() Trie les el ments a lint rieur de la liste. e ` e reverse() Renverse lordre des el ments a lint rieur de la liste. e ` e Un exemple qui utilise toutes les m thodes des listes : e
29
>>> 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 m thodes des listes rendent tr` s facile lutilisation dune liste comme une pile, o` le dernier el ment ajout est le e e u e e premier el ment r cup r (LIFO, last-in, rst-out). Pour ajouter un el ment au sommet de la pile, utilisez la m thode e e ee e e append(). Pour r cup rer un el ment du sommet de la pile, utilisez pop() sans indice explicite. Par exemple : e e e
>>> >>> >>> >>> [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 el ment ajout est le premier el ment u e e e retir (FIFO, rst-in, rst-out). Pour ajouter un el ment a la n de la le, utiliser append(). Pour r cup rer un e e ` e e el ment du devant de la le, utilisez pop() avec 0 pour indice. Par exemple ; e
30
Chapitre 5. Structures de Donnees
>>> 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 int gr es qui sont tr` s pratiques avec les listes : filter(), map(), et reduce(). e e e filter(fonction, sequence) renvoit une liste (du m me type, si possible) contenant les seul el ments de la e e s quence pour lesquels fonction(element) est vraie. Par exemple, pour calculer quelques nombres premiers : e
>>> 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 el ments de la s quence et renvoie la liste e e 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 s quences peuvent etre pass es en param` tre ; la fonction doit alors avoir autant darguments quil y a de e e e s quences et est appel e avec les el ments correspondants de chacune des s quences (ou None si lune des s quences e e e e e est plus courte que lautre). Si None est pass en tant que fonction, une fonction retournant ses arguments lui est e substitu e. e En combinant ces deux cas sp ciaux, on voit que map(None, liste1, liste2) est une facon pratique de transformer e 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 el ments de la s quence, puis sur le r sultat et l l ment suivant, et ainsi de suite. Par exemple, pour e e e ee calculer la somme des nombres de 1 a 10 : `
5.1. Plus de Details sur les Listes
31
>>> def ajoute(x,y): return x+y ... >>> reduce(ajoute, range(1, 11)) 55
Sil y a seulement un el ment dans la s quence, sa valeur est renvoy e ; si la s quence est vide, une exception est e e e e d clench e. e e Un troisi` me argument peut etre transmis pour indiquer la valeur de d part. Dans ce cas, la valeur de d part est e e e renvoy e pour une s quence vide, et la fonction est dabord appliqu e a la valeur de d part et au premier el ment de e e e ` e e la s quence, puis au r sultat et a l l ment suivant, et ainsi de suite. Par exemple, e e ` ee
>>> 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 facon concise de cr er des listes sans avoir recours a map(), filter() e ` et/ou lambda. La d nition de liste qui en r sulte a souvent tendance a etre plus claire que des listes construites avec e e ` ces outils. Chaque list comprehension consiste en une expression suivie dune clause for, puis z ro ou plus clauses e for ou if. Le r sultat sera une liste r sultant de l valuation de lexpression dans le contexte des clauses for et if e e e qui la suivent. Si lexpression s value en un tuple, elle doit etre mise entre parenth` ses. e e
32
>>> 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 - parenth`ses obligatoires pour les tuples e File "<stdin>", line 1 [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]
5.2
Linstruction del
Il y a un moyen denlever un el ment dune liste en ayant son indice au lieu de sa valeur : linstruction del. Ceci peut e aussi etre utilis pour enlever des tranches dans une liste (ce que lon a fait pr c demment par remplacement de la e e e 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 etre utilis pour supprimer des variables compl` tes : e e
>>> del a
Faire par la suite r f rence au nom a est une erreur (au moins jusqu` ce quune autre valeur ne lui soit affect e). Nous ee a e trouverons dautres utilisations de del plus tard.
5.2. Linstruction del
33
5.3
N-uplets (tuples) et Sequences
Nous avons vu que les listes et les chanes ont plusieurs propri t s communes, par ex., lindexation et les op rations ee e de d coupage. Elles sont deux exemples de types de donn es de type s quence. Puisque Python est un langage qui e e e evolue, dautres types de donn es de type s quence pourraient etre ajout s. Il y a aussi un autre type de donn es de e e e e type s quence standard : le tuple (n-uplet). e Un n-uplet consiste en un ensemble de valeurs s par es par des virgules, par exemple : e e
>>> t = 12345, 54321, salut! >>> t[0] 12345 >>> t (12345, 54321, salut!) >>> # Les Tuples peuvent tre imbriqus: e e ... u = t, (1, 2, 3, 4, 5) >>> u ((12345, 54321, salut!), (1, 2, 3, 4, 5))
Comme vous pouvez le voir, a lafchage, les tuples sont toujours entre parenth` ses, de facon a ce que des tuples de ` e ` tuples puissent etre interpr t s correctement ; ils peuvent etre saisis avec ou sans parenth` ses, bien que des parenth` ses ee e e soient souvent n cessaires (si le tuple fait partie dune expression plus complexe). e Les tuples ont plein dutilisations, par exemple, les couples de coordonn es (x, y), les enregistrements des employ s e e dune base de donn es, etc. Les tuples, comme les chanes, sont non-modiables : il est impossible daffecter indivie duellement une valeur aux el ments dun tuple (bien que vous puissiez simuler quasiment cela avec le d coupage et la e e concat nation). e Un probl` me particulier consiste a cr er des tuples contenant 0 ou 1 el ment : la syntaxe reconnat quelques subtilit s e ` e e e pour y arriver. Les tuples vides sont construits gr ce a des parenth` ses vides ; un tuple avec un el ment est construit a ` e e en faisant suivre une valeur dune virgule (il ne suft pas de mettre une valeur seule entre parenth` ses). Moche, mais e efcace. Par exemple :
>>> 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 emball es ensemble dans un tuple. Lop ration inverse est aussi possible, par ex. : e e
>>> x, y, z = t
Ceci est appel , fort judicieusement, d ballage de tuple (tuple unpacking). Le d ballage dun tuple n cessite que la e e e e liste des variables a gauche ait un nombre d l ments egal a la longueur du tuple. Notez que des affectations multiples ` ee ` ne sont en r alit quune combinaison demballage et d ballage de tuples ! e e e
34
5.4
Dictionnaires
Un autre type de donn es int gr a Python est le dictionnaire. Les dictionnaires sont parfois trouv s dans dautres e e e` e langages sous le nom de m moires associatives ou tableaux associatifs. A la diff rence des s quences, qui sont e e e index es par un intervalle num rique, les dictionnaires sont index s par des cl s, qui peuvent etre de nimporte quel e e e e type non-modiable ; les chanes et les nombres peuvent toujours etre des cl s. Les tuples peuvent etre utilis s comme e e cl s sils ne contiennent que des chanes, des nombres ou des tuples. Vous ne pouvez pas utiliser des listes comme e cl s, puisque les listes peuvent etre modi es en utilisant leur m thode append(). e e e Il est pr f rable de consid rer les dictionnaires comme des ensembles non ordonn s de couples cl :valeur, avec la ee e e e contrainte que les cl s soient uniques (` lint rieur dun m me dictionnaire). Un couple daccolades cr e un dictione a e e e naire vide : {}. Placer une liste de couples cl :valeur s par s par des virgules a lint rieur des accolades ajoute les e e e ` e couples initiaux cl :valeur au dictionnaire ; cest aussi de cette facon que les dictionnaires sont afch s. e e Les op rations principales sur un dictionnaire sont le stockage dune valeur a laide dune certaine cl et lextraction de e ` e la valeur en donnant la cl . Il est aussi possible de d truire des couples cl :valeur avec del. Si vous stockez avec une e e e cl d j` utilis e, lancienne valeur associ e a cette cl est oubli e. Cest une erreur dextraire une valeur en utilisant e ea e e ` e e une cl qui nexiste pas. e La m thode keys() dun objet de type dictionnaire retourne une liste de toutes les cl s utilis es dans le dictionnaire, e e e dans un ordre quelconque (si vous voulez quelle soit tri e, appliquez juste la m thode sort() a la liste des cl s). e e ` e Pour savoir si une cl particuli` re est dans le dictionnaire, utilisez la m thode has key() du dictionnaire. e e e 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) 1
5.5
Plus de Details sur les Conditions
Les conditions utilis es dans les instructions while et if peuvent contenir dautres op rateurs en dehors des compae e raisons. Les op rateurs de comparaison in et not in v rient si une valeur apparat (ou non) dans une s quence. Les e e e op rateurs is et is not v rient si deux objets sont r ellement le m me objet ; ceci se justie seulement pour e e e e les objets modiables comme les listes. Tous les op rateurs de comparaison ont la m me priorit , qui est plus faible e e e que celle de tous les op rateurs num riques. e e Les comparaisons peuvent etre enchan es : par ex., a < b == c teste si a est inf rieur ou egal a b et de plus si b e e ` est egal a c. ` Les comparaisons peuvent etre combin es avec les op rateurs Bool ens and (et) et or (ou), et le r sultat dune e e e e comparaison (ou de nimporte quel autre expression Bool enne) peut etre invers avec not (pas). Ces op rateurs ont e e e
5.4. Dictionnaires
35
encore une fois une priorit inf rieure a celle des op rateurs de comparaison ; et entre eux, not a la plus haute priorit , e e ` e e et or la plus faible, de sorte que A and not B or C est equivalent a (A and (not B)) or C. Bien s r, les ` u parenth` ses peuvent etre utilis es pour exprimer les compositions d sir es. e e e e Les op rateurs Bool ens and et or sont des op rateurs dits raccourcis : leurs arguments sont evalu s de gauche a e e e e ` droite, et l valuation sarr te d` s que le r sultat est trouv . Par exemple, si A et C sont vrais mais que B est faux, A e e e e e and B and C n value pas lexpression C. En g n ral, la valeur de retour dun op rateur raccourci, quand elle est e e e e utilis e comme une valeur g n rale et non comme un Bool en, est celle du dernier argument evalu . e e e e e Il est possible daffecter le r sultat dune comparaison ou une autre expression Bool enne a une variable. Par exemple, e e `
>>> 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 etre effectu es a lint rieur des expressions. e ` e
5.6
Comparer Les Sequences et dAutres Types
Les objets de type s quence peuvent etre compar s a dautres objets appartenant au m me type de s quence. La e e ` e e comparaison utilise lordre lexicographique : les deux premiers el ments sont dabord compar s, et sils diff` rent ceci e e e d termine le r sultat de la comparaison ; sils sont egaux, les deux el ments suivants sont compar s, et ainsi de suite, e e e e jusqu` ce que lune des deux s quences soit epuis e. Si deux el ments a comparer sont eux-m mes des s quences du a e e e ` e e m me type, la comparaison lexicographique est reconsid r e r cursivement. Si la comparaison de tous les el ments de e ee e e deux s quences les donne egaux, les s quences sont consid r es comme egales. Si une s quence est une sous-s quence e e ee e e initiale de lautre, la s quence ecourt e est la plus petite. Lordonnancement lexicographique pour les chanes utilise e e lordonnancement ASCII pour les caract` res. Quelques exemples de comparaisons de s quences du m me type : e e e
(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 diff rents est licite. Le r sultat est d terministe mais arbitraire : les types e e e sont tri s selon leur nom. Ainsi une liste (list) est toujours inf rieure a une chane (string), une chane (string) est e e ` toujours inf rieure a un n-uplet (tuple), etc. Les types num riques m lang s sont compar s en fonction de leur valeur e ` e e e e num rique, ainsi 0 est egal a 0.0, etc.1 e `
ne doit pas se er aux r` gles de comparaison pour des objets de types diff rents ; elles pourraient changer dans une version ult rieure du e e e langage.
1 On
36
CHAPITRE
SIX
Modules
Si vous quittez linterpr` teur de Python et le lancez a nouveau, les d nitions que vous avez faites (fonctions et e ` e variables) sont perdues. Par cons quent, si vous voulez ecrire un programme plus long, vous feriez mieux dutiliser a e ` la place un editeur de texte pour pr parer le source pour linterpr teur et de le lancer avec ce chier comme entr e. e e e Ceci sappelle cr er un script. Quant votre programme devient plus long, vous pouvez vouloir le couper en plusieurs e chiers pour une maintenance plus facile. Vous pouvez egalement vouloir utiliser dans plusieurs programmes une fonction pratique que vous avez ecrite sans copier sa d nition dans chaque programme. e Pour supporter ceci, Python offre un moyen de mettre des d nitions dans un chier et de les utiliser dans un script ou e dans un session interactive de linterpr teur. Un tel chier sappelle un module ; les d nitions dun module peuvent e e etre import es dans un autre module ou dans le module principal (la collection de variables a laquelle vous avez acc` s e ` e dans un script ex cut depuis le plus haut niveau et dans le mode calculatrice). e e Un module est un chier contenant des d nitions et des instructions Python. Le nom de chier est le nom du module e auquel est ajout le sufxe .py. Dans un module, le nom du module (comme chane de caract` res) est disponible e e eee e comme valeur de la variable globale name . Par exemple, employez votre editeur de texte pr f r pour cr er un chier appel bo.py dans le r pertoire courant avec le contenu suivant : e e
# Module nombres de Fibonacci a e e 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 e a result = [] a, b = 0, 1 while b < n: result.append(b) a, b = b, a+b return result
Maintenant lancez linterpr teur Python et importez ce module avec la commande suivante : e
>>> import fibo
Ceci n crit pas les noms des fonctions d nies dans fibo directement dans la table de symboles actuelle ; cela y e e ins` re seulement le nom de module fibo. En utilisant le nom de module vous pouvez acc der aux fonctions : e e
37
>>> 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 a 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 ex cutables aussi bien que des d nitions de fonction. Ces instructions sont e e destin es a initialiser le module. On les ex cute seulement la premi` re fois que le module est import quelque part.1 e ` e e e Chaque module a sa propre table de symboles priv e, qui est utilis e comme table de symbole globale par toutes les e e fonctions d nies dans le module. Ainsi, lauteur dun module peut utiliser des variables globales dans le module sans e sinqui ter des d saccords accidentels avec les variables globales dun utilisateur. Dautre part, si vous savez que ce e e que vous faites, vous pouvez acc der aux variables globales dun module avec la m me notation que celle employ e e e e pour se r f rer a ses fonctions, nommodule.nomelem. ee ` Les modules peuvent importer dautres modules. Il est dusage mais pas obligatoire de placer toutes les instructions import au d but dun module (ou dun script). Les noms du module import sont plac s dans la table globale de e e e 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
Ceci nintroduit pas dans la table de symboles locale le nom du module duquel les el ments import s sont issus (ainsi e e dans lexemple, fibo nest pas d ni). e Il y a m me une variante pour importer tous les noms quun module d nit : e e
>>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Ceci importe tous les noms except ceux qui commencent par un tiret-bas ( ). e
1 En fait, les d nitions de fonctions sont aussi des instructions qui sont ex cut es ; lex cution ins` re le nom de la fonction dans la table de e e e e e symboles globale du module.
38
Chapitre 6. Modules
6.1.1 Le Chemin de Recherche du Module

Quand un module nomm spam est import , linterpr teur recherche un chier nomm spam.py dans le r pertoire e e e e e courant, et puis dans la liste de r pertoires indiqu e par la variable denvironnement $PYTHONPATH. Elle a la m me e e e syntaxe que la variable du shell $PATH, c.-` -d., une liste de noms de r pertoire. Quand $PYTHONPATH nest pas a e renseign , ou quand le chier ny est pas trouv , la recherche continue dans un chemin dacc` s par d faut, d pendant e e e e e de linstallation ; sur U NIX, cest habituellement . :/usr/local/lib/python. En fait, les modules sont recherch s dans la liste de r pertoires donn e par la variable sys.path qui est initialis e e e e e a partir du r pertoire contenant le script dentr e (ou le r pertoire actuel), $PYTHONPATH et le chemin par d faut, ` e e e e d pendant de linstallation. Ceci permet aux programmes Python qui savent ce quils font de modier ou de remplacer e le chemin dacc` s aux modules. Voyez la section sur les modules standards plus tard. e
6.1.2 Fichiers Compiles de Python

Pour acc l rer de mani` re importante le temps de lancement des petits programmes qui utilisent beaucoups de modules ee e standard, si un chier appel spam.pyc existe dans le r pertoire o` spam.py se trouve, il est suppos contenir une e e u e version du module spam d j` compil e en byte-code Lheure de modication de la version de spam.py employ e ea e e pour cr er spam.pyc est enregistr e dans spam.pyc, et le chier est ignor si ceux-ci ne saccordent pas. e e e Normalement, vous navez rien a faire pour cr er le chier spam.pyc. Toutes les fois que spam.py est compil avec ` e e succ` s, une tentative est faite pour ecrire la version compil e sur spam.pyc. Il ny a pas derreur si cette tentative e e echoue ; si pour une raison quelconque le chier nest pas ecrit compl` tement, le chier spam.pyc r sultant sera e e identi comme incorrect et ainsi ignor plus tard. Le contenu du chier spam.pyc est ind pendant de la plate-forme, e e e ainsi un r pertoire de module de Python peut etre partag par des machines darchitectures diff rentes. e e e Quelques trucs pour les experts : Quand linterpr teur de Python est appel avec lindicateur -O, du code optimis est produit et enregistr dans e e e e des chiers .pyo. Loptimiseur actuel naide pas beaucoup ; il retire seulement les instructions assert et des e e e instructions SET LINENO. Quand -O est utilis , tout le byte-code est optimis ; les chiers pyc sont ignor s et des chiers py sont compil s en byte-code optimis . e e Passer deux options -O en param` tres a linterpr teur Python (-OO) forcera le compilateur de bytecode a effectuer e ` e ` des optimisations qui pouraient dans certains cas rares avoir pour r sultat des programmes ne foctionnant pas core rectement. Actuellement, seules les chanes doc sont enlev es du bytecode, ce qui a pour r sultat des chiers e e .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 a ` laquelle ils sont charg s. e Quand un script est ex cut en donnant son nom sur la ligne de commande, le byte-code pour le script nest jamais e e ecrit dans un chier .pyc ou .pyo. Ainsi, le temps de d marrage dune s quence type peut etre r duit en d placant e e e e 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 e e dans le m me module. Ceci peut etre employ pour distribuer une biblioth` que de code Python sous une forme qui e e e est moyennement difcile a d compiler. ` e Le module compileall peut cr er des chiers .pyc (ou des chiers .pyo quand -O est utilis ) pour tous les e e modules pr sents dans un r pertoire. e e
6.2
Modules Standard
Python est livr avec une biblioth` que de modules standard, d crite dans un document s par , Python Library e e e e e Reference (Library Reference ci-apr` s). Quelques modules sont int gr s dans linterpr teur ; ceux-ci permettent e e e e dacc der a des op rations qui ne font pas partie du noyau du langage mais sont n anmoins int gr es, pour des raisons e ` e e e e 6.2. Modules Standard 39
defcacit ou pour permettre dacc der aux primitives du syst` me dexploitation telles que les appels syst` me. La e e e e d nition de lensemble de ces modules standards est une option de conguration ; par exemple, le module amoeba e est seulement fourni sur les syst` mes qui supportent dune facon ou dune autre les primitives dAmoeba. Un moe dule particulier m rite une certaine attention : sys, qui est int gr dans chaque interpr teur de Python. Les variables e e e e sys.ps1 et sys.ps2 d nissent les chanes de caract` res utilis es en tant quinvites primaire et secondaire : e e e
>>> import sys >>> sys.ps1 >>> >>> sys.ps2 ... >>> sys.ps1 = C> C> print Yuck! Yuck! C>
Ces deux variables sont seulement d nies si linterpr teur est en mode interactif. e e La variable sys.path est une liste de chanes de caract` res qui d terminent le chemin de recherche des modules e e pour linterpr teur. Il est initialis a un chemin par d faut a partir de la variable denvironnement $PYTHONPATH, ou e e` e ` dune valeur par d faut int gr e au programme si $PYTHONPATH nest pas renseign . Vous pouvez la modier en e e e e utilisant des op rations standard sur des listes, par exemple : e
>>> import sys >>> sys.path.append(/ufs/guido/lib/python)
6.3
La Fonction dir()
La fonction int gr e dir() est employ e pour d couvrir les noms quun module d nit. Elle renvoie une liste tri e e e e e e e de chanes de caract` res : e
>>> import fibo, sys >>> dir(fibo) [__name__, fib, fib2] >>> dir(sys) [__name__, argv, builtin_module_names, copyright, exit, maxint, modules, path, ps1, ps2, setprofile, settrace, stderr, stdin, stdout, version]
Sans arguments, dir() enum` re les noms que vous avez d nis : e e
>>> a = [1, 2, 3, 4, 5] >>> import fibo, sys >>> fib = fibo.fib >>> dir() [__name__, a, fib, fibo, sys]
Notez quelle enum` re tous les types de noms : les variables, les modules, les fonctions, etc. e dir() n num` re pas les noms des fonctions et des variables int gr es. Si vous en voulez une liste, elles sont d nies e e e e e 40 Chapitre 6. Modules
dans le module standard
builtin
>>> import __builtin__ >>> dir(__builtin__) [AccessError, AttributeError, ConflictError, EOFError, IOError, ImportError, IndexError, KeyError, KeyboardInterrupt, MemoryError, NameError, None, OverflowError, RuntimeError, SyntaxError, SystemError, SystemExit, TypeError, ValueError, ZeroDivisionError, __name__, abs, apply, chr, cmp, coerce, compile, dir, divmod, eval, execfile, filter, float, getattr, hasattr, hash, hex, id, input, int, len, long, map, max, min, oct, open, ord, pow, range, raw_input, reduce, reload, repr, round, setattr, str, type, xrange]
6.4
Paquetages
Les paquetages sont un moyen de structurer lespace des noms de modules Python en utilisant les noms de modules point s. Par exemple, le nom de module A.B d signe un sous-module nomm B dans un module nomm A. Tout e e e e comme lutilisation des modules permet aux auteurs de diff rents modules de ne pas sinqui ter au sujet des noms e e des variables globales de chacun des autres modules, lutilisation des noms de modules point s dispense lauteur de e paquetages multi-modules comme NumPy ou PIL de devoir sinqui ter au sujet de leurs noms de modules. e Supposez que vous vouliez concevoir une collection de modules (un paquetage) pour la manipulation uniforme des chiers de sons et des donn es de son. Il y a beaucoup de formats de chier de sons diff rents (habituellement e e reconnus par leur extension, par exemple .wav, .ai, .au), ainsi vous pouvez avoir besoin de cr er et mettre a jour e ` une collection grandissante de module pour la conversion entre les divers formats de chier. Il y a egalement beaucoup dop rations diff rentes que vous pourriez vouloir ex cuter sur des donn es de sons (par exemple le mixage, ajouter de e e e e l cho, appliquer une fonction d galisation, cr er un effet articiel de st r o), ainsi en compl ment, vous ecrirez une e e e ee e s rie interminable de modules pour r aliser ces op rations. Voici une structure possible pour votre paquetage (exprim e e e e en termes de syst` me de chiers hi rarchique) : e e
6.4. Paquetages
41
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 e Initialisation du paquetage sons Sous-paquetage pour la conversion des formats de fichiers
Sous-paquetage pour les effets sonores
Sous-paquetage pour les filtres
e e Les chiers init .py sont obligattoires pour que Python consid` re les r pertoires comme contenant des paquetages ; ceci est fait pour emp cher des r pertoires avec un nom commun, tel que string, de cacher involontaie e rement les modules valides qui apparaissent plus tard dans le chemin de recherche de module. Dans le cas le plus e simple, init .py peut juste etre un chier vide, mais doit pouvoir egalement ex cuter du code dinitialisation pour le paquetage ou positionner la variable all , d crite ci-dessous. e Les utilisateurs du paquetage peuvent importer individuellement des modules du paquetage, par exemple :
import Sound.Effects.echo
Ceci charge le sous-module Sound.Effects.echo. Il doit etre r f renc avec son nom complet, par exemple. ee e
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
Ceci charge le sous-module echo, et le rend egalement disponible sans son pr xe de paquetage, ainsi il peut etre e utilis comme suit : e
echo.echofilter(input, output, delay=0.7, atten=4)
Une autre variante consiste encore a importer la fonction ou la variable d sir e directement : ` e e
from Sound.Effects.echo import echofilter
Encore une fois, ceci charge le sous-module echo, et rend sa fonction echolter disponible directement :
42
Chapitre 6. Modules
echofilter(input, output, delay=0.7, atten=4)
Notez quen utilisant from paquetage import element, l l ment peut etre un sous-module (ou sous-paquetage) ee du paquetage, ou un autre nom d ni dans le paquetage, comme une fonction, une classe ou une variable. Linstruction e import teste dabord si l l ment est d ni dans le paquetage ; sinon, elle suppose que cest un module et essaye de ee e le charger. Si elle ne le trouve pas, ImportError est d clench . e e Au contraire, en utilisant la syntaxe import element.souselement.soussouselement, chaque el ment except le dere e nier doit etre un paquetage ; le dernier el ment peut etre un module ou un paquetage mais ne peut pas etre une classe e ou une fonction ou une variable d nie dans l l ment pr c dent. e ee e e
6.4.1 Importer * Depuis un Paquetage

Maintenant, quest-ce qui se produit quand lutilisateur ecrit from Sound.Effects import * ? Dans le meilleur des cas, on esp rerait que ceci sadresse dune facon ou dune autre au syst` me de chiers, trouve quels e e sous-modules sont pr sents dans le paquetage, et les importe tous. Malheureusement, cette op ration ne fonctionne e e pas tr` s bien sur des plate-formes Mac et Windows, o` le syst` me de chiers na pas toujours des informations pr cises e u e e 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 etre import en tant que module echo, Echo ou ECHO. (Par exemple, Windows 95 a la f cheuse habitude de e a montrer tous les noms de chier avec une premi` re lettre en capitale.) La restriction de nom de chier DOS 8+3 ajoute e un autre probl` me int ressant pour les longs noms de modules. e e La seule solution est que lauteur de module fournisse un index explicite du module. Linstruction dimportation utilise e e e la convention suivante : si le code init .py dun paquetage d nit une liste nomm e all , celle-ci est utilis e comme la liste des noms de modules qui doivent etre import s quand from paquetage import * est rencontr . e e Il appartient a lauteur du paquetage de tenir cette liste a jour quand une nouvelle version du paquetage est livr e. ` ` e Les auteurs de paquetage peuvent egalement d cider de ne pas la supporter, sils ne souhaitent pas une utilisation e dimportation par * de leur module. Par exemple, le chier Sounds/Effects/ init .py pourrait contenir le code suivant :
__all__ = ["echo", "surround", "reverse"]
Ceci signierait que from Sound.Effects import * importerait les trois sous-modules du paquetage Sound all nest pas d ni, linstruction from Sound.Effects import * nimporte pas dans lespace des e Si noms actuel lensemble des sous-modules du paquetage Sound.Effects ; elle sassure seulement que le paquetage Sound.Effects a et import (probablement en ex cutant son code dinitialisation, init .py) et puis importe e e e tous les noms d nis dans le module, quels quils soient. Ceci inclut tout nom d ni (et tout sous-module charg e e e explicitement) par init .py. Elle inclut egalement tous les sous-modules du paquetage qui ont et charg s de e e facon explicite par des instructions dimportation pr c dentes, par exemple. e e
import Sound.Effects.echo import Sound.Effects.surround from Sound.Effects import *
Dans cet exemple, les modules echo et surround sont import s dans lespace des noms actuel parce quils sont e d nis dans le paquetage Sound.Effects quand linstruction from...import est ex cut e. (Ceci fonctionne e e e e egalement quand all est d ni.) Notez quen g n ral la pratique de limportation par * dun module ou paquetage fait froncer les sourcils, puisquelle e e conduit souvent a un code tr` s peu lisible. Cependant, il est correct de lemployer pour eviter la saisie au clavier lors des ` e sessions interactives, et parce que certains modules sont concus pour exporter seulement les noms qui correspondent 6.4. Paquetages 43
a certains motifs. ` Rappelez-vous, il ny a rien dincorrect a utiliser from Paquetage import sous module specifique ! ` En fait, cest la notation recommand e a moins que le module importateur ne doive utiliser des sous-modules avec le e ` m me nom, issus de paquetages diff rents. e e
6.4.2 References Intra-Paquetage

Les sous-modules doivent souvent se faire r f rence mututellement. Par exemple, le module surround pourrait utiee liser le module echo. En fait, de telles r f rences sont si communes que linstruction import regarde dabord dans ee 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 e trouv dans le paquetage actuel (le paquetage dont le module actuel est un sous-module), linstruction import ree cherche un module au niveau sup rieur avec le nom donn . e e Quand des paquetages sont structur s dans des sous-paquetages (comme avec le paquetage Sound dans lexemple), il e ny a aucun raccourci pour se r f rer a des sous-modules des paquetages enfants de m mes parents le nom complet ee ` e du sous-paquetage doit etre utilis . Par exemple, si le module Sound.Filters.vocoder doit utiliser le module e echo du paquetage Sound.Effects, il peut utiliser from Sound.Effects import echo.
44
Chapitre 6. Modules
CHAPITRE
SEPT
Entrees et Sorties
Il y a plusieurs mani` res de pr senter lafchage produit par un programme ; les donn es peuvent etre imprim es sous e e e e une forme humainement lisible, ou etre ecrites dans un chier pour un usage ult rieur. Ce chapitre pr sentera certaines e e de ces possibilit s. e
7.1
Un Formatage de Sortie Plus Fantaisiste
Jusquici nous avons rencontr deux mani` res dafcher des valeurs : les instructions dexpression et linstruction e e print. (Une troisi` me mani` re est dutiliser la m thode write() des objets chier ; le chier de sortie standard e e e peut etre r f renc par sys.stdout. Voyez le manuel Library Reference pour plus dinformations.) ee e Vous souhaiterez souvent avoir plus de contr le sur le formatage de vos sorties que dimprimer simplement des valeurs o s par es par des espaces. Il y a deux mani` res de formater vos sorties ; la premi` re mani` re est de faire toutes les e e e e e manipulations de chanes de caract` res vous-m me ; en utilisant les op rations de concat nation et de d coupage e e e e e de chanes de caract` res, vous pouvez cr er nimporte quel format que vous puissiez imaginer. Le module standard e e string contient quelques op rations utiles pour remplir des chanes de caract` res a une largeur de colonne donn e ; e e ` e celles-ci seront discut es sous peu. La deuxi` me mani` re est dutiliser lop rateur % avec une chane de caract` res e e e e e comme argument de gauche, % interpr` te largument de gauche comme une chane de formatage comme pour la e fonction sprintf() du langage C a appliquer a largument de droite, et retourne une chane de caract` res r sultant ` ` e e de cette op ration de formatage. e Il reste naturellement une question : comment convertissez-vous des valeurs en chanes de caract` res ? Heureusement, e Python a un moyen de convertir nimporte quelle valeur en chane de caract` res : passez-la a la fonction repr(), ou e ` ecrivez juste la valeur entre des guillemets renvers s (anti-quotes : ). Quelques exemples : e
45
>>> x = 10 * 3.14 >>> y = 200*200 >>> s = La valeur de x est + x + , et y est + y + ... >>> print s La valeur de x est 31.4, et y est 40000... >>> # Les anti-quotes marchent avec dautres types en dehors des nombres: ... p = [x, y] >>> ps = repr(p) >>> ps [31.4, 40000] >>> # Convertir une chane ajoute des quotes de chane et des antislash: ... salut = salut, monde\n >>> saluts = salut >>> print saluts salut, monde\012 >>> # Largument des anti-quotes peut tre un tuple: e ... x, y, (spam, eggs) "(31.4, 40000, (spam, eggs))"
Voici deux mani` res d crire une table des carr s et des cubes : e e e
>>> import string >>> for x in range(1, 11): ... print string.rjust(x, 2), string.rjust(x*x, 3), e e a ... # 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 et ajout a cause de la facon dont print fonctionne : elle ajoute toujours e e` des espaces entre ses arguments.) Cet exemple pr sente la fonction string.rjust(), qui justie a droite une chane de caract` res dans un e ` e
46
Chapitre 7. Entrees et Sorties
champ dune largeur donn e en la compl tant avec des espaces du c t gauche. Il y a les fonctions semblables e e oe string.ljust() et string.center(). Ces fonctions n crivent rien, elles renvoient juste une nouvelle chane e de caract` res. Si la chane de caract` res dentr e est trop longue, elles ne la tronquent pas, mais la renvoient sans e e e changement ; ceci g chera votre pr sentation de colonne mais cest habituellement mieux que lalternative, qui serait a e de tricher au sujet dune valeur. (Si vous voulez vraiment la troncature vous pouvez toujours ajouter une op ration de e d coupage, comme string.ljust(x, n)[0 :n].) e Il y a une autre fonction, string.zfill(), qui compl` te une chane de caract` res num rique du c t gauche avec e e e oe des z ros. Elle sait g rer les signes positifs et n gatifs : e e e
>>> import string >>> string.zfill(12, 5) 00012 >>> string.zfill(-3.14, 7) -003.14 >>> string.zfill(3.14159265359, 5) 3.14159265359
Lutilisation de lop rateur % ressemble a ceci : e `

>>> 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 caract` res, vous passez un tuple comme op rande de droite, e e par exemple.
>>> table = {Sjoerd: 4127, Jack: 4098, Dcab: 8637678} >>> for nom, telephone in table.items(): ... print %-10s ==> %10d % (nom, telephone) ... Jack ==> 4098 Dcab ==> 8637678 Sjoerd ==> 4127
La plupart des formats fonctionnent exactement comme en C et exigent que vous passiez le type appropri ; cependant, e 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 caract` res, il est converti en chane de caract` res en utilisant la fonction e e int gr e str(). Utiliser * pour passer la largeur ou la pr cision comme argument (entier) s par est possible. Les e e e e e formats %n et %p du C ne sont pas support s. e Si vous avez une chane de caract` res de formatage vraiment longue que vous ne voulez pas fractionner, il serait el gant e e de pouvoir r f rencer les variables a formater par leur nom et pas par leur position. Ceci peut etre fait en utilisant une ee ` extension des formats du C en utilisant la forme %(name)format, par exemple.
>>> table = {Sjoerd: 4127, Jack: 4098, Dcab: 8637678} >>> print Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d % table Jack: 4098; Sjoerd: 4127; Dcab: 8637678
Cest particuli` rement utile en combinaison avec la fonction int gr e vars(), qui renvoie un dictionnaire contenant e e e toutes les variables locales.
7.1. Un Formatage de Sortie Plus Fantaisiste
47
7.2
Lire et Ecrire des Fichiers
open() renvoie un objet de type chier, et est utilis e plus g n ralement avec deux arguments : open(nomchier, e e e mode).
>>> f=open(/tmp/fichiertravail, w) >>> print f <open file /tmp/fichiertravail, mode w at 80a0960>
Le premier argument est une chane de caract` res contenant le nom du chier. Le deuxi` me argument est une autre e e chane de caract` res contenant quelques caract` res d crivant la mani` re dutiliser le chier. mode vaut r quand le e e e e chier doit etre seulement lu, w pour seulement ecrit (un chier d j` existant avec le m me nom sera effac ), et ea e e a ouvre le chier en ajout ; les donn es ecrites dans le chier seront automatiquement ajout es a la n. r+ ouvre e e ` le chier pour la lecture et l criture. Largument mode est facultatif ; r sera pris par d faut sil est omis. e e Sur Windows et Macintosh, b ajout au mode ouvre chier en mode binaire, donc il y a aussi des modes comme e rb, wb, et r+b. Windows fait la distinction entre chier texte et binaire ; les caract` res de n de ligne dans des e chiers texte sont automatiquement modi s l g` rement quand des donn es sont lues ou ecrites. Cette modication e e e e imperceptible des donn es du chier marche tr` s bien pour des chiers textes ASCII, mais elle alt` rera des donn es e e e e binaires comme dans des chiers JPEG ou .EXE. Faites tr` s attention a utiliser le mode binaire en lisant et en ecrivant e ` de tels chiers. (notez que la s mantique pr cise du mode texte sur le Macintosh d pend de la biblioth` que C utilis e.) e e e e e
7.2.1 Methodes des Objets Fichier

Le reste des exemples dans cette section supposera quun objet chier appel f a d j` et cr e. e e a e e Pour lire le contenu dun chier, appeler f.read(taille), qui lit une certaine quantit de donn es et les retourne en e e tant que chane de caract` res. taille est un argument num rique facultatif. Quand taille est omis ou n gatif, le contenu e e e entier du chier sera lu et retourn ; cest votre probl` me si le chier est deux fois plus grand que la m moire de votre e e e machine. Autrement, au plus taille octets sont lus et retourn s. Si la n du chier a et atteinte, f.read() renverra e e une chane de caract` res vide (""). e
>>> f.read() Ceci est le fichier entier.\012 >>> f.read()
f.readline() lit une seule ligne a partir du chier ; un caract` re de n de ligne (\n) est laiss a lextr mit de la ` e e` e e chane de caract` res lue, et est seulement omis sur la derni` re ligne du chier si le chier ne se termine pas par une e e n de ligne. Ceci rend la valeur de retour non ambigu ; si f.readline() renvoie une chane de caract` res vide, e e la n du chier a et atteinte, alors quune n de ligne est repr sent e par \n, une chane de caract` res contenant e e e e seulement une seule n de ligne.
>>> f.readline() Ceci est la premi`re ligne du fichier.\012 e >>> f.readline() Deuxi`me ligne du fichier\012 e >>> f.readline()
f.readlines() utilise f.readline() de facon r p titive, et retourne une liste contenant toutes les lignes de e e donn es du chier. e 48 Chapitre 7. Entrees et Sorties
>>> f.readlines() e e [Ceci est la premi`re ligne du fichier.\012, Deuxi`me ligne du fichier\012]
f.write(chaine) ecrit le contenu de chaine dans le chier, en retournant None.

>>> f.write(Voici un test\n)
f.tell() renvoie un nombre entier donnant la position actuelle dans le chier associ a lobjet chier, mesur e e` e en octets depuis le d but du chier. Pour changer la position dans lobjet chier, employez f.seek(decalage, e e ` ee ee point depart). La position est calcul e en ajoutant decalage a un point de r f rence ; le point de r f rence est choisi par largument point depart. Une valeur de 0 pour point depart fait d marrer au d but du chier, 1 utilise la position e e courante du chier, et 2 utilise la n de chier comme point de r f rence. point depart peut etre omis et prend alors ee 0 pour valeur par d faut comme point de r f rence. e ee
>>> >>> >>> >>> 5 >>> >>> d f=open(/tmp/fichiertravail, r+) f.write(0123456789abcdef) f.seek(5) # Saute jusquau 5`me octet dans le fichier e f.read(1) f.seek(-3, 2) # Saute jusquau 3`me octet avant la fin e f.read(1)
Quand vous en avez termin avec un chier, appeler f.close() pour le fermer et lib rer toutes les ressources e e syst` me utilis es par le chier ouvert. Apr` s avoir appel f.close(), les tentatives dutiliser lobjet chier e e e e echoueront automatiquement.
>>> f.close() >>> f.read() Traceback (innermost last): File "<stdin>", line 1, in ? ValueError: I/O operation on closed file
Les objets chier ont quelques m thodes suppl mentaires, telles que isatty() et truncate() qui sont moins e e fr quemment utilis es ; consultez la Library Reference pour un guide complet des objets chier. e e
7.2.2 Le Module pickle

Les chanes de caract` res peuvent facilement etre ecrites et lues dans un chier. Les nombres demandent un peu e plus deffort, puisque la m thode read() renvoie seulement les chanes de caract` res, qui devront etre pass es vers e e e une fonction comme string.atoi(), qui prend une chane de caract` res comme 123 et renvoie sa valeur e num rique 123. Cependant, quand vous voulez sauvegarder des types de donn es plus complexes comme des listes, e e des dictionnaires, ou des instances de classe, les choses deviennent beaucoup plus compliqu es. e Plut t que faire ecrire et d boguer constamment par les utilisateurs le code pour sauvegarder des types de donn es o e e complexes, Python fournit un module standard appel pickle. Cest un module etonnant qui peut prendre presque e nimporte quel objet Python (m me quelques formes de code Python !), et le convertir en une repr sentation sous e e forme de chane de caract` res ; ce processus sappelle pickling. Reconstruire lobjet a partir de sa repr sentation en e ` e chane de caract` res sappelle unpickling. Entre pickling et unpickling, la chane de caract` res repr sentant lobjet a pu e e e avoir et enregistr e dans un chier ou des donn es, ou avoir et envoy e a une machine eloign e via une connexion e e e e e ` e r seau. e 7.2. Lire et Ecrire des Fichiers 49
Si vous avez un objet x, et un objet chier f ouvert en ecriture, 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 ceci, utilis es pour pickler beaucoup dobjets ou quand vous ne voulez pas ecrire les e donn es pickl es dans un chier ; consultez la documentation compl` te pour pickle dans la Library Reference.) e e e pickle est le moyen standard pour enregistrer des objets Python et les r utiliser dans dautres programmes ou e dans une future invocation du m me programme ; le terme technique pour ceci est la persistance dun objet. Puisque e pickle est tr` s largement r pandu, beaucoup dauteurs qui ecrivent des extensions pour Python prennent soin de e e sassurer que de nouveaux types de donn es tels que des matrices peuvent etre correctement pickl s et unpickl s. e e e
50
Chapitre 7. Entrees et Sorties
CHAPITRE
HUIT
Erreurs et Exceptions
Jusquici nous avons a peine mentionn les messages derreur, mais si vous avez essay les exemples vous en avez ` e e certainement crois . Il y a (au moins) deux types distincts derreurs : les erreurs de syntaxe et les exceptions. e
8.1
Erreurs de Syntaxe
Les erreurs de syntaxe, ou erreurs dinterpr tation, sont peut- tre les formes de messages derreur les plus courantes e e que vous rencontrerez pendant votre apprentissage de Python :
>>> while 1 print Bonjour File "<stdin>", line 1 while 1 print Bonjour SyntaxError: invalid syntax
Linterpr teur afche la ligne o` lerreur a eu lieu, et une petite ` che qui marque le premier point de la ligne e u e o` lerreur a et d tect e. Lerreur est caus e par le (ou du moins d tect e au) lex` me qui pr c` de la ` che : dans u e e e e e e e e e e lexemple, lerreur est d tect e au mot-cl print, vu quil manque un deux-points ( :) juste avant. Un nom et un e e e num ro de ligne de chier sont aussi donn s pour que vous sachiez o` aller regarder si les commandes proviennent e e u dun script.
8.2
Exceptions
M me lorsquune instruction ou une expression est syntaxiquement correcte, elle peut provoquer une erreur lorsquon e essaye de lex cuter. Les erreurs d tect es a lex cution sont appel es exceptions et ne sont pas fatales : vous allez e e e ` e e bient t apprendre a les g rer dans des programmes Python. N anmoins, la plupart des exceptions nest pas g r e par o ` e e ee un programme et entrane des messages derreur comme ci-dessous :
51
>>> 10 * (1/0) Traceback (innermost last): File "<stdin>", line 1 ZeroDivisionError: integer division or modulo >>> 4 + spam*3 Traceback (innermost last): File "<stdin>", line 1 NameError: spam >>> 2 + 2 Traceback (innermost last): File "<stdin>", line 1 TypeError: illegal argument type for built-in operation
La derni` re ligne du message derreur indique ce qui sest pass . Les exceptions peuvent etre de plusieurs types, e e le type est ecrit dans le message : dans lexemple, les types sont ZeroDivisionError (erreur de division par z ro), NameError (erreur de nom) et TypeError (erreur de type). La chane de caract` res afch e comme type de e e e lexception est le nom int gr pour lexception qui a eu lieu. Cest le cas pour toutes les exceptions int gr es, mais pas e e e e forc ment pour les exceptions d nies par lutilisateur (m me si cest une convention utile). Les noms des exceptions e e e standard sont des identiants int gr s (et non des mots-cl s r serv s). e e e e e Le reste de la ligne contient des d tails, dont linterpr tation d pend du type de lexception. e e e La partie pr c dant le message derreur afche le contexte dans lequel lexception a eu lieu, sous forme de trace de la e e pile. En g n ral, elle contient une trace de pile avec des lignes de code source ; toutefois, les lignes lues depuis lentr e e e e standard ne seront pas afch es. e La Library Reference donne la liste des exceptions int gr es et leur signication. e e
8.3
Gestion des Exceptions
Il est possible d crire des programmes qui prennent en charge des exceptions sp ciques. Regardez lexemple suivant, e e qui afche une table des inverses de quelques nombres a virgule ottante : `
>>> while 1: ... try: ... x = int(raw_input("Veuillez entrer un nombre: ")) ... break ... except ValueError: ... print "Aille! Ce ntait pas un nombre valide. Essayez encore..." e ...
Linstruction try fonctionne ainsi : Dabord, la clause dessai (clause try : les instructions entre les mots-cl s try et except) est ex cut e. e e e Sil ne se produit pas dexception, la clause dexception (clause except) est ignor e, et lex cution du try est e e termin e. e Si une exception se produit a un moment de lex cution de la clause dessai, le reste de la clause try est ignor . ` e e Puis si son type correspond a lexception donn e apr` s le mot-cl except, la clause except est ex cut e, puis ` e e e e e lex cution reprend apr` s linstruction try. e e Si une exception se produit qui ne correspond pas a lexception donn e dans la clause except, elle est renvoy e aux ` e e instructions try ext rieures ; sil ny a pas de prise en charge, il sagit dune exception non g r e et lex cution est e ee e arr t e avec un message, comme vu pr c demment. ee e e
52
Chapitre 8. Erreurs et Exceptions
Une instruction try peut avoir plus dune clause dexception, de facon a d nir des gestionnaires dexception ` e diff rents pour des exceptions diff rentes. Au plus une clause dexception sera ex cut e. Dans une clause dexcepe e e e tion ne seront g r es que les exceptions survenant dans la clause dessai correspondante, et non pas celles provenant ee dautres clauses dexception. Une clause dexception peut nommer plusieurs exceptions dans une liste parenth s e, ee par exemple :
... except (RuntimeError, TypeError, NameError): ... pass
La derni` re clause dexception peut omettre le(s) nom(s) dexception, et sert alors de passe-partout. Utilisez ceci avec e une pr caution extr me : il est facile de cacher de cette facon une vraie erreur de programmation ! e e
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." e except: print "Erreur non prvue:", sys.exc_info()[0] e raise
Linstruction try. . .except admet une clause par d faut (clause else) qui doit suivre toutes les clauses dexception. e Elle est utile pour placer le code qui doit etre ex cut si la clause dessai ne d clenche pas dexception. Par exemple : e e e
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 suppl mentaire a la clause try parce quelle evite e ` dintercepter de facon accidentelle une exception qui na pas et d clench e par le code qui est prot g par linstruction e e e e e try . . . except. Quand une exception survient, elle peut avoir une valeur associ e, appel e aussi largument de lexception. La pr sence e e e et le type de largument d pendent du type de lexception. Pour les types dexception qui ont un argument, la clause e dexception peut sp cier une variable apr` s le nom (ou la liste) dexception(s) qui recevra la valeur de largument, de e e la mani` re suivante : e
8.3. Gestion des Exceptions
53
>>> try: ... spam() ... except NameError, x: ... print nom, x, non dfini e ... nom spam non dfini e
Si une exception a un argument, celui-ci sera afch dans la derni` re partie (d tail) du message pour une exception e e e non g r e. ee Les clauses dexception ne prennent pas en charge uniquement les exceptions qui surviennent dans la clause dessai, mais aussi celles qui surviennent dans les fonctions appel es (m me de facon indirecte) dans la clause dessai. Par e e exemple :
>>> def ceci_ne_marche_pas(): ... x = 1/0 ... >>> try: ... ceci_ne_marche_pas() ... except ZeroDivisionError, detail: ... print Gestion derreur ` lexcution:, detail a e ... Gestion derreur ` lexcution: integer division or modulo a e
8.4
Declencher des Exceptions
Linstruction raise permet au programmeur de d clencher une exception. Par exemple : e

>>> raise NameError, Coucou Traceback (innermost last): File "<stdin>", line 1 NameError: Coucou
Le premier argument de raise nomme lexception qui doit etre d clench e. Le second argument (optionnel) sp cie e e e largument de lexception.
8.5
Exceptions Denies par lUtilisateur
Les programmes peuvent nommer leurs propres exceptions en affectant une chane de caract` res a une variable. Par e ` exemple.
54
Chapitre 8. Erreurs et Exceptions
>>> mon_exc = mon_exc >>> try: ... raise mon_exc, 2*2 ... except mon_exc, val: ... print Mon exception a t dclenche, valeur:, val e e e e ... Mon exception a t dclenche, valeur: 4 e e e e >>> raise mon_exc, 1 Traceback (innermost last): File "<stdin>", line 1 mon_exc: 1
Plusieurs modules standard sen servent pour rapporter les erreurs qui peuvent survenir dans les fonctions quils d nissent. e Plus dinformations au sujet des classes sont donn es dans le chapitre 9, Classes. e
8.6
Denir les Actions de Nettoyage
Linstruction try admet une autre clause optionnelle qui permet de d nir les actions de nettoyage qui doivent etre e ex cut es imp rativement. Par exemple : e e e
>>> try: ... raise KeyboardInterrupt ... finally: ... print Adieu, monde! ... Adieu, monde! Traceback (innermost last): File "<stdin>", line 2 KeyboardInterrupt
Une clause de nalisation (clause nally) est ex cut e quune exception ait eu lieu ou non dans la clause dessai. Si e e une exception a et d clench e, elle est d clench e a nouveau apr` s lex cution de la clause de nalisation. La clause e e e e e ` e e de nalisation est aussi ex cut e en sortant lorsque linstruction try est interrompue par les instructions break ou e e return. Une instruction try doit avoir ou bien une ou plusieurs clauses dexception, ou bien une clause de nalisation, mais pas les deux.
8.6. Denir les Actions de Nettoyage
55
56
CHAPITRE
NEUF
Classes
Le m canisme de classe en Python permet dintroduire les classes avec un minimum de syntaxe et s mantique noue e velles. Cest un m lange des m canismes de classe de C++ et Modula-3. Comme les modules, les classes en Python e e ninstallent pas de barri` re absolue entre la d nition et lutilisateur, mais appellent plut t a la politesse de lutilisae e o ` teur pour eviter leffraction de la d nition. Les caract ristiques les plus importantes des classes sont pleinement e e pr sentes : le m canisme dh ritage permet la multiplicit des classes de base, une classe d riv e peut surcharger e e e e e e nimporte quelle m thode de sa ou ses classes de base, une m thode peut appeler une m thode de sa classe de base e e e avec le m me nom. Les objets peuvent contenir un nombre arbitraire de donn es priv es. e e e Dans la terminologie du C++, tous les membres dune classe (dont les donn es membres) sont publics, et toutes les e 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 r f rence aux membres dun objet a partir de ses m thodes : une m thode est ee ` e e d clar e avec un premier argument explicite qui repr sente lobjet, qui est fourni implicitement a lappel. Comme en e e e ` Smalltalk, les classes sont elles-m mes des objets, mais dans un sens plus large : en Python, tous les types de donn es e e sont des objets. Ceci fournit la s mantique pour limportation et le renommage. Mais, comme en C++ et en Modula-3, e les types int gr s ne peuvent pas etre utilis s comme classes de base pour des extensions par lutilisateur. En plus, e e e comme en C++ mais contrairement a Modula-3, la plupart des op rateurs int gr s qui ont une syntaxe particuli` re ` e e e e (op rateurs arithm tiques, indicage, etc.) peuvent etre red nis pour des instances de classe. e e e
9.1
Un Mot Sur la Terminologie
A d faut dune terminologie universellement accept e pour parler des classes, jutiliserai a loccasion des termes e e ` de Smalltalk et C++. (Jutiliserais volontiers des termes de Modula-3, puisque sa s mantique orient e objet est plus e e proche de celle de Python que celle de C++, mais jimagine que peu de lecteurs ont entendu parler de ce langage.) Je dois aussi vous pr venir quil y a un pi` ge terminologique pour les lecteurs familiers de lorient objet : le mot e e e objet en Python ne veut pas forc ment dire instance dune classe. Comme en C++ et Modula-3 et contrairement a e ` Smalltalk, tous les types Python ne sont pas des classes : les types int gr s de base comme les entiers et les listes ne e e le sont pas, et m me des types plus exotiques comme les chiers ne le sont pas non plus. Pourtant, tous les types en e Python partagent un peu de s mantique commune, d crite au mieux par le mot objet. e e Les objets poss` dent une individualit , et des noms multiples (dans des port es multiples) peuvent etre li s au m me e e e e e 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 caract` res, tuples). N anmoins, e e laliasing a un effet (voulu !) sur la s mantique du code Python qui met en jeu des objets modiables comme listes, e dictionnaires et la plupart des types repr sentant des entit s a lexception du programme (chiers, fen tres, etc.). Ceci e e ` e est mis a prot dans les programmes, puisque les alias se comportent comme des pointeurs a plusieurs points de ` ` vue. Par exemple, le passage en param` tre dun objet nest pas co teux puisque seul un pointeur est transmis par e u limpl mentation ; et si une fonction modie un objet recu en argument, lappelant verra la modication ce qui e elimine le besoin davoir deux m canismes de passage darguments comme en Pascal. e
57
9.2
Les Portees et les Espaces de Noms en Python
Avant dintroduire les classes, je dois vous dire quelques mots sur les r` gles de port e en Python. Les d nitions de e e e classe jouent astucieusement avec les espaces de noms, et vous devez savoir comment fonctionnent les port es et les e espaces de noms pour comprendre ce qui se passe. En fait, la connaissance de ce sujet est utile a tout programmeur ` Python avanc . e Dabord quelques d nitions. e Un espace de noms (name space) est une relation entre des noms et des objets. La plupart des espaces de noms sont actuellement impl ment s comme des dictionnaires, mais cela nest pas visible (sauf sur les performances peute e etre) et pourrait changer dans le futur. Quelques exemples despaces de noms : lensemble des noms int gr s (les e e fonctions telles que abs(), et les noms dexception int gr s) ; les noms globaux dans un module ; les noms locaux e e au cours dun appel de fonction. En un sens, lensemble des attributs dun objet constitue aussi un espace de noms. La chose importante a savoir sur les espaces de noms est quil ny a absolument aucune relation entre les noms ` contenus dans les diff rents espaces de noms ; par exemple, deux modules diff rents peuvent d nir tous les deux une e e e fonction maximise sans confusion possible les utilisateurs des modules doivent pr xer par le nom du module a e ` 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 r f rences a des noms dans des modules ee ` 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 d nis dans le module : ils e partagent le m me espace de noms !1 e Les attributs peuvent etre en lecture seule ou bien modiables. Dans ce cas, on peut affecter des valeurs a des attri ` buts. Les attributs dun module sont modiables : vous pouvez faire nommod.la reponse = 42. Les attributs modiables peuvent aussi etre effac s avec linstruction del, par exemple del nommod.la reponse. e Les espaces de noms sont cr es a des moments diff rents et ont des dur es de vie diff rentes. Lespace de noms qui e ` e e e contient les noms int gr s est cr e au lancement de linterpr teur Python, et nest jamais effac . Lespace de noms e e e e e global pour un module est cr e quand la d nition du module est charg e ; normalement, les espaces de noms des e e e modules vivent jusqu` la mort de linterpr teur. Les instructions ex cut es a linvocation de linterpr teur par le a e e e ` e niveau sup rieur, quelles soient lues depuis un chier ou entr es de facon interactive, sont consid r es comme faisant e e ee partie dun module appel e main , elles ont donc leur propre espace de noms global. (En fait, les noms int gr s e e font aussi partie dun module appel e builtin .) Lespace de noms local a une fonction est cr e quand celle-ci est appel e et il est effac quand la fonction se termine ou ` e e e d clenche une exception qui nest pas g r e dans la fonction. (En fait, oubli d crit mieux ce qui se passe vraiment.) e ee e e Evidemment, les appels r cursifs ont chacun leur propre espace de noms. e Une port e (scope) est une r gion textuelle dun programme Python dans laquelle un espace de noms est directement e e accessible. Directement accessible veut dire quune r f rence non quali e a un nom cherchera ce nom dans cet ee e ` espace de noms. Bien quelles soient d termin es statiquement, les port es sont utilis es dynamiquement. A nimporte quel moment e e e e de lex cution, exactement trois port es imbriqu es sont utilis es (cest-` -dire exactement trois espaces de noms sont e e e e a accessibles directement) : la port e imm diate, qui est explor e en premier, contient les noms locaux, la port e ine e e e term diaire, explor e ensuite, contient les noms globaux du module courant, et la port e ext rieure (explor e en dere e e e e nier) correspond a lespace de noms contenant les noms int gr s. ` e e Normalement, la port e locale fait r f rence aux noms de la fonction courante (textuellement). En dehors des fonctions, e ee la port e locale fait r f rence au m me espace de noms que la port e globale : lespace de noms du module. Les e ee e e d nitions de classe placent encore un autre espace de noms dans la port e locale. e e Il est important de voir que les port es sont d termin es de facon textuelle : la port e globale dune fonction d nie e e e e e
1 Sauf pour une chose. Les objets module poss` dent un attribut secret en lecture exclusive qui sappelle e dict et qui renvoie le dictionnaire dict est un attribut mais pas un nom global. Evidemment, lutiliser casse utilis pour impl menter lespace de noms du module ; le nom e e labstraction de l impl mentation des espaces de noms, et son usage doit etre restreint a des choses telles que les d bogueurs post-mortem. e ` e
58
Chapitre 9. Classes
dans un module est lespace de noms de ce module, peu importe do` ou a travers quel alias cette fonction est appel e. u ` e Dun autre c t , la recherche de noms elle-m me est effectu e dynamiquement, a l ex cution toutefois, la d nition oe e e ` e e du langage tend a evoluer vers la r solution statique de noms, au moment de la compilation, alors ne vous basez pas ` e sur la r solution dynamique de noms ! (En fait, les variables locales sont d j` d termin es de facon statique.) e ea e e Un point titilleux de Python est que les affectations se font toujours dans la port e imm diate. Laffectation ne copie e e pas de donn es elle ne fait quaffecter un nom a un objet. Ceci est vrai aussi de leffacement : linstruction del e ` x enl` ve le lien vers x de lespace de noms r f renc par la port e locale. En fait, toute op ration qui introduit de e ee e e e nouveaux noms utilise la port e locale : en particulier, les instructions dimportation et les d nitions de fonction lient e e le nom du module ou de la fonction a la port e locale. (Linstruction global peut etre utilis e pour indiquer que ` e e certaines variables vivent dans la port e globale.) e
9.3
` Une Premiere Approche des Classes
Les classes introduisent un peu de syntaxe nouvelle, trois nouveaux types dobjet, et quelques points de s mantique e suppl mentaires. e
9.3.1 Syntaxe de la Denition de Classes

La forme la plus simple de d nition de classe ressemble a ceci : e `
class NomClasse: <instruction-1> . . . <instruction-N>
Les d nitions de classe, comme les d nitions de fonction (instructions def) doivent etre ex cut es pour entrer en e e e e effet. (Vous pourriez placer une d nition de classe dans une branche dune instruction if, ou a lint rieur dune e ` e fonction.) Dans la pratique, les instructions a lint rieur dune d nition de classe seront souvent des d nitions de fonction, mais ` e e e dautres instructions sont accept es, et parfois sav` rent utiles plus de d tails sur le sujet ci-dessous. Les d nitions e e e e de fonction a lint rieur dune classe ont une forme particuli` re de liste darguments, dict e par les conventions dappel ` e e e de m thode ceci e A lentr e dune d nition de fonction, un nouvel espace de noms est cr e et utilis comme port e locale ainsi, e e e e e toute affectation de variables rentre dans cet espace de noms. En particulier, les d nitions de fonctions y rattachent le e nom des nouvelles fonction. Lorsque la d nition de la classe est achev e de facon normale (par la n), un objet classe (class object) est cr e. e e e Il sagit essentiellemnt dun enrobage autour du contenu de lespace de noms cr e par la d nition de classe ; nous e e verrons davantage de caract ristiques des objets classes dans la section suivante. La port e locale dorigine (celle en e e cours avant le d but de la d nition de classe) est r install e, et lobjet classe est li ici au nom donn dans len-t te e e e e e e e de la d nition de classe (NomClasse dans lexemple). e
9.3.2 Objets Classes

Les objets classe admettent deux sortes dop rations : la r f renciation des attributs et linstanciation. e ee Les r f rences aux attributs (attribute references) utilisent la syntaxe standard utilis e pour toutes les r f rences datee e ee
` 9.3. Une Premiere Approche des Classes
59
tribut en Python : obj.nom. Les noms dattribut valides sont ceux qui etaient dans lespace de noms de la classe quand lobjet classe a et cr e. Donc, si la d nition de classe ressemble a : e e e `
class MaClasse: "Une classe simple pour exemple i = 12345 def f(x): return bonjour
alors MaClasse.i et MaClasse.f sont des r f rences dattribut valides, qui renvoient un entier et un objet foncee tion, respectivement. On peut affecter une valeur aux attributs de classe, donc vous pouvez changer la valeur de est un attribut valide, en lecture exclusive, qui renvoie la docstring corresMaClasse.i par affectation. doc pondant a la classe : "Une classe simple pour exemple"). ` Linstantiation de classe utilise la notation dappel de fonction. Faites comme si lobjet classe etait une fonction sans param` tres qui renvoie une instance nouvelle de la classe. Par exemple, (avec la classe pr c dente) : e e e
x = MaClasse()
cr e une nouvelle instance de la classe et affecte cet objet a la variable locale x. e ` Lop ration dinstanciation (appeller un objet classe) cr e un objet vide. De nombreuses classes aiment bien cr er les e e e objets dans un etat initial connu. Ainsi une classe peut d nir une m thode sp ciale nomm e init (), comme e e e e ceci :
def __init__(self): self.donnee = []
init (), linstanciation de la classe appelle automatiquement Quand une classe d nit une m thode e e init () pour linstance de la classe nouvellement cr ee. Ainsi, dans cet exemple, une instance nouvelle, initiae lis e, peut etre obtenue par : e
x = MaClasse()
Bien-s r, la m thode init () peut avoir des arguments pour offrir plus de souplesse. Dans ce cas, les arguments u e fournis a lop rateur dinstanciation de la classe sont pass s a init (). Par exemple, ` e e `
>>> 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 op rations accept es par des objets instance sont des r f rences e e ee a leurs attributs. Il y a deux sortes de noms dattributs valides. `
60
Chapitre 9. Classes
Jappellerai la premi` re donn es attributs (data attributes). Ils correspondent aux variables dinstance (instance e e variables) en Smalltalk, et aux donn es membres (data members) en C++. Les donn es attributs nont pas besoin e e d tre d clar es ; comme les variables locales, elles apparaissent lorsquon leur affecte une valeur pour la premi` re e e e e fois. Par exemple, si x est linstance de MaClasse cr ee pr c demment, le morceau de code suivant afchera la e e e valeur 16, sans laisser de trace :
x.compteur = 1 while x.compteur < 10: x.compteur = x.compteur * 2 print x.compteur del x.compteur
La seconde sorte de r f rence dattribut accept e par les objets instance sont les m thodes (methods). Une m thode ee e e e est une fonction qui appartient a un objet. (En Python, le terme m thode nest pas exclusif aux instances de classe : ` e dautres types dobjet peuvent avoir des m thodes, par exemple les objets liste ont des m thodes appel es append, ine e e sert, remove, sort, etc. N anmoins, dans ce qui suit, nous allons utiliser le terme m thode pour d signer exclusivement e e e les m thodes dun objet instance de classe, sauf mention explicite.) e Les noms de m thodes valides pour un objet instance d pendent de sa classe. Par d nition, tous les attributs dune e e e classe qui sont des fonctions (d nies par lutilisateur) d nissent des m thodes correspondantes pour les instances. e e e Ainsi, dans notre exemple, x.f est une r f rence valide a une m thode, puisque MaClasse.f est une fonction, mais ee ` e x.i ne lest pas, vu que MaClasse.i ne lest pas. Toutefois x.f nest pas la m me chose que MaClasse.f e cest un objet m thode (method object), et non pas un objet fonction. e
9.3.4 Objets Methodes

Dhabitude, une m thode est appel e de facon directe, par exemple : e e
x.f()
Dans notre exemple, ceci renverrait la chane salut monde. Or, il nest pas n cessaire dappeler une m thode e e tout de suite : x.f est un objet m thode, il peut etre rang quelque part et etre appel plus tard, par exemple : e e e
xf = x.f while 1: print xf()
continuera a afcher bonjour jusqu` la n des temps. ` a Que se passe-t-il exactement lorsquune m thode est appel e ? Vous avez peut- tre remarqu que x.f() a et appel e e e e e e e sans argument ci-dessus, alors que la d nition de fonction pour f en sp ciait un. Quest-il arriv a largument ? e e e` On se doute bien que Python d clenche une exception quand une fonction qui requiert un argument est appel e sans e e argument m me si largument nest pas effectivement utilis . . . e e En fait, vous avez peut- tre devin la r ponse : la particularit des m thodes est que lobjet est pass comme premier e e e e e e argument a la fonction. Dans notre exemple, lappel x.f() est l quivalent exact de MaClasse.f(x). En g n ral, ` e e e appeler une m thode avec une liste de n arguments equivaut a appeler la fonction correspondante avec une liste e ` darguments qui est le r sultat de lins rtion de lobjet avant le premier argument. e e Si vous navez toujours pas compris comment fonctionnent les m thodes, un regard sur limpl mentation va peut- tre e e e clarier les choses. Lorsquun attribut dune instance est r f renc et quil nest pas une donn e attribut, une recherche ee e e est entam e dans sa classe. Si le nom correspond a un attribut de classe valide qui est un objet fonction, un objet e ` m thode est cr e en empaquetant (des pointeurs sur) lobjet instance et lobjet fonction trouv dans un objet abstrait : e e e ` 9.3. Une Premiere Approche des Classes 61
cest lobjet m thode. Lorsque lobjet m thode est appel avec une liste darguments, il est depaquet , une nouvelle e e e e liste darguments est construite a partir de lobjet instance et de la liste darguments originelle, puis lobjet fonction ` est appel avec cette nouvelle liste darguments. e
9.4
Quelques Remarques
Les donn es attributs ecrasent les m thodes de m me nom ; pour eviter des conits de noms accidentels, qui peuvent e e e causer des bogues difciles a trouver dans des programmes cons quents, il est sage dutiliser une convention qui ` e minimise les chances de conit, par exemple, mettre en majuscules les noms des m thodes, pr xer les noms des e e donn es attributs avec une m me courte chane de caract` res (peut- tre un simple tiret-bas), ou utiliser des verbes pour e e e e les m thodes et des substantifs pour les donn es. e e Les donn es attributs peuvent etre r f renc es par des m thodes aussi bien que par les utilisateurs ordinaires (clients) e ee e e dun objet. Autrement dit, les classes ne sont pas utilisables pour impl menter des types abstraits purs. En fait, e rien dans Python ne permet dassurer le secret des donn es tout est bas sur des conventions. (Dun autre c t , e e oe limpl mentation de Python, ecrite en C, peut cacher compl` tement les d tails dimpl mentation et de contr le dacc` s e e e e o e a un objet si besoin est ; ceci peut etre utilis par les extensions de Python ecrites en C.) ` e Les clients doivent utiliser les donn es attributs avec pr caution ils peuvent bouleverser des invariants entretenus e e par les m thodes en ecrasant leurs donn es attributs. Notez bien que les clients peuvent rajouter des donn es attributs e e e de leur cru a un objet instance sans affecter la validit des m thodes, pourvu que les conits de noms soient evit s ` e e e l` encore, une convention de nommage peut eviter bien des migraines. a Il ny a pas de raccourci pour faire r f rence a des donn es attributs (ou a dautres m thodes !) a partir dune m thode. ee ` e ` e ` e Je trouve que cela augmente en fait la lisibilit des m thodes : il ny a aucune chance de confondre les variables locales e e et les variables dinstance lorsquon examine une m thode. e Par convention, le premier argument dune m thode est souvent appel self. Ce nest quune convention : le mot e e self na absolument aucun sens sp cial pour Python. (Remarquez, tout de m me, que si votre code ne suit pas e e la convention, il peut se r v ler moins lisible par dautres programmeurs Python, et il est aussi concevable quun e e explorateur de classes soit ecrit, qui se base sur cette convention.) Tout objet fonction qui est aussi un attribut dune classe d nit une m thode pour les instances de cette classe. Il nest e e pas n cessaire que la d nition de la fonction soit textuellement comprise dans la d nition de la classe : affecter un e e e objet fonction a une variable locale dans la classe marche aussi. Par exemple : `
# Fonction dfinie en dehors de la classe e 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 r f rence a des objets fonctions, et par ee ` cons quent ils sont tous les trois des m thodes des instances de C h equivaut exactement a g. Remarquez que cette e e ` pratique ne sert souvent qu` embrouiller le lecteur du programme. a Les m thodes peuvent appeler dautres m thodes en utilisant les attributs m thodes de largument self, par exemple : e e e
62
Chapitre 9. Classes
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 m thodes peuvent faire r f rence a des noms globaux de la m me facon que les fonctions ordinaires. La port e e ee ` e e globale associ e a une m thode est celle du module qui contient la d nition de la classe. (La classe elle-m me ne e ` e e e sert jamais de port e globale !) Alors quon trouve rarement de bonnes raisons pour utiliser des donn es globales dans e e une m thode, il y a plusieurs utilisations l gitimes de la port e globale : ne serait-ce que le fait que les fonctions et les e e e modules import s dans la port e globale peuvent etre utilis s par les m thodes, de m me que les fonctions et les classes e e e e e qui y sont d nies. Dhabitude, la classe qui contient la m thode est elle-m me d nie dans cette port e globale, et e e e e e dans la section suivante nous allons voir quelques bonnes raisons pour lesquelles une m thode pourrait vouloir faire e r f rence a sa propre classe ! ee `
9.5
Heritage
Bien s r, une caract ristique du langage ne serait pas digne du mot classe si elle ne permettait pas lh ritage. La u e e syntaxe pour d nir une classe d riv e ressemble a ceci : e e e `
class NomClasseDerivee(NomClasseDeBase): <instruction-1> . . . <instruction-N>
Le nom NomClasseDeBase doit etre d ni dans une port e contenant la d nition de la classe d riv e. A la place e e e e e dun nom de classe de base, une expression est accept e. Ceci est utile lorsque la classe de base est d nie dans un e e autre module, par exemple :
class NomClasseDerivee(nommod.NomClasseDeBase):
Lex cution dune d nition de classe d riv e se d roule comme pour une classe de base. Quand lobjet classe est e e e e e construit, la classe de base est m moris e. Ceci est employ dans la r solution des r f rences dattribut : si lattribut e e e e ee demand nest pas trouv dans la classe, il est recherch dans la classe de base. Cette r` gle est employ e r cursivement e e e e e e si la classe de base est elle-m me d riv e depuis une autre classe. e e e Il ny a rien de sp cial dans linstantiation dune classe d riv e : NomClasseDerivee() cr e une nouvelle instance e e e e de la classe. Les r f rences aux m thodes sont r solues ainsi : lattribut est recherch dans la classe correspondante, en ee e e e descendant la chane des classes de base si besoin est, et la r f rence a la m thode est valide si cette recherche aboutit ee ` e a un objet fonction. ` Les classe d riv es peuvent red nir les m thodes de leurs classes de base. Puisque les m thodes ne jouissent pas de e e e e e privil` ges particuliers lorsquelles appellent dautres m thodes du m me objet, la m thode dune classe de base qui e e e e appelle une autre m thode d nie dans la m me classe de base peut en d nitive appeler une m thode dune classe e e e e e d riv e qui a red ni cette m thode. (Pour les programmeurs C++ : toutes les m thodes en Python sont des fonctions e e e e e virtuelles.)
9.5. Heritage
63
Une m thode dune classe d riv e qui red nit une fonction peut en fait vouloir etendre et non pas remplacer la e e e e m thode de la classe de base de m me nom. Il y un moyen simple dappeler la m thode de la classe de base die e e rectement : simplement appelez NomClasseDeBase.nommethode(self, arguments). Ceci peut parfois sav rer utile pour les clients aussi. (Remarquez que ca ne marche que si la classe de base est d nie ou import e dans e e e la port e globale.) e
9.5.1 Heritage Multiple

Python supporte aussi une forme limit e dh ritage multiple. Une d nition de classe avec plusieurs classes de base e e e ressemble a : `
class NomClasseDerivee(Base1, Base2, Base3): <instruction-1> . . . <instruction-N>
La seule r` gle permettant dexpliquer la s mantique de lh ritage multiple est la r` gle de r solution utilis e pour les e e e e e e r f rences aux attributs. La r solution se fait en profondeur dabord, de gauche a droite. Donc, si un attribut nest ee e ` pas trouv dans NomClasseDerivee, il est cherch dans Base1, puis (r cursivement) dans les classes de base de e e e Base1, et seulement sil ny est pas trouv , il est recherch dans Base2, et ainsi de suite. e e (Pour certains la recherche en largeur dabord chercher dans Base2 est Base3 avant les classes de base de Base1 semble plus naturelle. Pourtant, cela n cessite que vous sachiez si un attribut particulier de Base1 est d ni dans e e Base1 ou dans une de ses classes de base avant de pouvoir consid rer les conits de nom avec Base2. La r` gle en e e profondeur dabord ne fait pas de diff rence entre les attributs directs et h rit s de Base1.) e e e Il est clair que lutilisation banalis e de lh ritage multiple est un cauchemar de maintenance, etant donn que Python e e e se base sur des conventions pour eviter les conits de noms accidentels. Un probl` me bien connu de lh ritage multiple e e est celui dune classe d riv e de deux autres classes qui ont une m me classe de base en commun. Sil reste facile de e e e voir ce qui se passe dans ce cas (linstance aura une seule copie des variables dinstance ou des donn es attributs e utilis s par la classe de base commune), il nest pas clair que cette s mantique soit utile de quelque facon que ce soit. e e
9.6
Variables Privees
spam Il y a un support limit pour des identicateurs priv s dans une classe. Tout identicateur de la forme e e (au moins deux tirets-bas au d but, au plus un tiret-bas a la n) est maintenant textuellement remplac par e ` e nomclasse spam, o` nomclasse est le nom de classe courant, duquel les tirets-bas de d but on et enlev s. u e e e Ce brouillage (mangling) est r alis ind pendamment de la position syntaxique de lidenticateur, donc il peut etre e e e utilis pour d nir des variables de classe et dinstance priv es, des m thodes, des globales, et m me pour enregistrer e e e e e des variables dinstance priv es de cette classe dans des instances dautres classes. Le nom brouill peut etre tronqu e e e sil d passe 255 caract` res. En dehors des classes, ou lorsque le nom de la classe ne contient que des tirets-bas, le e e brouillage na pas lieu. Le brouillage de noms permet aux classes de d nir simplement des variables dinstance et des m thodes priv es, e e e sans avoir a se pr occuper des variables dinstance d nies par des classes d riv es, ou des probl` mes avec des ` e e e e e variables dinstance d nies en dehors de la classe. Remarquez que les r` gles de brouillage ont et dessin es surtout e e e e pour eviter des accidents ; il reste possible dacc der ou de modier une variable consid r e comme priv e. Ceci peut e ee e etre utile, par exemple pour le d boguage, et cest une des raisons pour lesquelles ce trou nest pas combl . (Petite e e bogue : d river une classe en utilisant le m me nom de classe permet lutilisation des variables priv es de la classe de e e e base.)
64
Chapitre 9. Classes
Remarquez que le code pass en argument a exec, eval() ou evalfile() ne consid` re pas le nom de classe de e ` e la classe appelante comme etant le nom de classe courant ; cest un effet similaire a celui de linstruction global, ` limit a du code qui a et compil en m me temps. La m me restriction sapplique a getattr(), setattr() et e` e e e e ` delattr(), de m me quaux r f rences directes a dict . e ee ` Voici lexemple dune classe qui impl mente ses propres m thodes e e tous les attributs dans une variable priv e. e
class AttributsVirtuels: __vdict = None __vdict_name = locals().keys()[0] def __init__(self): self.__dict__[self.__vdict_name] = {} def __getattr__(self, name): return self.__vdict[name] def __setattr__(self, name, value): self.__vdict[name] = value
getattr
et
setattr
et enregistre
9.7
En Vrac
Il est parfois utile de disposer dun type de donn es semblable au record du Pascal ou au struct du C, pour lier e quelques donn es nomm es. Une d nition de classe vide peut servir a cela : e e e `
class Employe: pass john = Employe() # Cre un enregistrement vide dEmploye e # Remplit les champs de lenregistrement john.nom = John Doe john.dept = computer lab john.salaire = 1000
Un bout de code Python qui attend des donn es dun certain type abstrait peut souvent recevoir a la place une classe e ` qui simule les m thodes de ce type de donn es. Par exemple, si vous avez une fonction qui met en forme des donn es e e e issues dun objet chier, vous pouvez d nir une classe avec des m thodes read() et readline() qui prend les e e donn es dun tampon et passer celui-ci comme argument. e e Les objets m thode dinstance poss` dent eux-m mes des attributs : m.im self est lobjet duquel la m thode est e e e instance, et m.im func est lobjet fonction correspondant a la m thode. ` e
9.8
Les Exceptions Peuvent Etre des Classes
Les exceptions d nies par lutilisateur ne sont pas limit es a etre des chanes de caract` res elles peuvent etre aussi e e ` e identi s comme des classes. En utilisant ce m canisme, on peut d nir des hi rarchies extensibles dexceptions. e e e e Il y a deux formes s mantiques valides pour linstruction raise : e
9.7. En Vrac
65
raise Classe, instance raise instance
Dans la premi` re forme, instance doit etre une instance de Classe ou dune de ses classes d riv es. La seconde e e e forme est un raccourci pour
raise instance.__class__, instance
Une clause dexception peut lister des classes et des chanes de caract` res. Une classe dans une clause dexception est e compatible avec une exception si celle ci est la m me classe ou une classe qui en est d riv e (mais pas en sens inverse e e e une clause dexception qui liste une classe d riv e nest pas compatible avec une classe de base). Par exemple, le e e 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 et invers es (except B en premier), le code aurait afch B, B, e e e B cest la premi` re clause except qui convient qui est ex cut e. e e e Lorsquun message derreur est afch pour une exception non g r e qui est une classe, le nom de la classe est afch , e ee e puis deux-points, un espace, et nalement, linstance convertie en chane de caract` res a travers la fonction int gr e e ` e e str().
66
Chapitre 9. Classes
CHAPITRE
DIX
Et Maintenant ?
Esp rons que ce tutoriel ait renforc votre int r t pour Python. O` pouvez-vous aller maintenant ? e e ee u Vous devriez lire, ou au moins feuilleter, la Library Reference, qui offre un mat riel de r f rence complet (quoique e ee succinct) sur des types, des fonctions et des modules qui peuvent vous faire economiser beaucoup de temps en ecrivant des programmes en Python. La distribution standard de Python inclut enorm ment de code, en C comme en Python ; e il y a des modules pour lire des botes aux lettres U NIX, rechercher des documents via HTTP, g n rer des nombres e e al atoires, interpr ter des options de ligne de commande, ecrire des programmes CGI, comprimer des donn es, et bien e e e davantage ; parcourir la Library Reference devrait vous donner une id e de ce qui est disponible. e 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 dispose de miroirs dans plusieurs endroits du monde, en Europe, au Japon et en Australie ; un miroir peut etre plus rapide dacc` s que le site principal, suivant votre e position g ographique. Un site plus informel est http ://starship.skyport.net, qui contient nombre de pages personnelles e en rapport avec Python ; beaucoup de gens y ont plac des programmes t l chargeables. e ee Pour des probl` mes ou des questions sur Python, vous pouvez poster dans le groupe de discussion comp.lang.python, e ou ecrire a 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 r ponses), des e suggestions dapports nouveaux, et des annonces de nouveaux modules. Avant de poster, soyez s r davoir consult la u e liste de Foire Aux Questions (Frequently Asked Questions ou FAQ) situ e a http ://www.python.org/doc/FAQ.html, et e ` davoir regard dans le r pertoire Misc/ de la distribution source de Python. La FAQ r pond a plusieurs des questions e e e ` qui reviennent sans cesse, et peut d j` contenir la solution a votre probl` me. ea ` e
67
68
ANNEXE
Edition dEntree Interactive et Substitution Historique

Quelques versions de linterpr teur Python supportent l dition de la ligne dentr e courante et la substitution histoe e e rique, des commodit s semblables a celles du shell Korn et du shell GNU Bash. Ceci est impl ment en utilisant la e ` e e librairie GNU Readline, qui supporte l dition a la vi et a la emacs. Cette librairie a sa propre documentation, que je e ` ` ne dupliquerai pas ici ; toutefois, les bases peuvent etre vite expliqu es. e Ce chapitre ne documente pas les capacit s d dition du paquetage PythonWin de Mark Hammond ou lenvironnement e e bas sur Tk, IDLE, distribu avec Python. Le rappel dhistorique de ligne de commande qui fonctionne dans les e e fen tres DOS sous NT et dautres variantes de DOS et Windows est encore un autre bestiau. e
A.1 Edition de Ligne

Si elle est support e, l dition de ligne dentr e est active lorsque linterpr teur afche un prompt primaire ou see e e e condaire. La ligne courante peut etre edit e en utilisant les caract` res de contr le conventionnels dEmacs. Les plus e e o importants sont : C-A (Control-A) d place le curseur en d but de ligne, C-E en n de ligne, C-B d place dune position e e e vers la gauche, C-F vers la droite. Backspace efface le caract` re a gauche du curseur, C-D le caract` re a droite. C-K e ` e ` tue (efface) le reste de la ligne a droite du curseur, C-Y rappelle la derni` re chane tu e. C-tiret-bas d fait le dernier ` e e e changement r alis ; il peut etre r p t pour un effet cumul . e e e ee e
A.2 Substitution Historique

La substitution historique fonctionne ainsi. Toutes les lignes dentr e non-vides sont enregistr es dans un tampon e e dhistorique, et lorsquun nouveau prompt est afch , vous etes dans une nouvelle ligne a la n de ce tampon. C-P e ` d place dune ligne vers le haut (vers larri` re) dans lhistorique, C-N vers le bas. Toute ligne de lhistorique peut etre e e edit e ; un ast risque apparat en d but de ligne avant le prompt pour indiquer que la ligne a et modi e. Appuyer e e e e e sur Entr e passe la ligne courante a linterpr teur. C-R commence une recherche incr mentale en arri` re ; C-S une e ` e e e recherche en avant.
A.3 Denition des Touches

Les associations des touches aux commandes et dautres param` tres de la biblioth` que Readline peuvent etre red nis e e e en placant des commandes dinitialisation dans le chier $HOME/.inputrc. Les d nitions de raccourcis clavier ont e la forme
69
nom-de-touche: nom-de-fonction
ou bien
"chane": nom-de-fonction
et les options sont modi es avec e

set nom-option valeur
Par exemple :
` # Je prf`re ldition a la vi: e e e set editing-mode vi # Edition sur une seule ligne: set horizontal-scroll-mode On # Redfinir quelques touches: e Meta-h: backward-kill-word "\C-u": universal-argument "\C-x\C-r": re-read-init-file
Remarquez que laction li e a la tabulation en Python est dins rer une tabulation, au lieu de laction par d faut de e e e Readline, qui est la compl tion de noms. Si vous insistez, vous pouvez red nir cela avec e e
Tab: complete
dans le chier $HOME/.inputrc. (Bien s r, cela rend plus difcile lindentation des lignes de continuation. . .) u La compl tion automatique des noms de variable et de module est disponible en option. Pour lactiver dans le mode e interactif de linterpr teur, rajouter ceci a votre chier $HOME/.pythonrc : e `
import rlcompleter, readline readline.parse_and_bind(tab: complete)
Ceci lie la touche TAB a la fonction de compl tion, donc appuyer deux fois sur TAB afche les suggestions de ` e compl tion ; celles-ci sont cherch es parmi les noms dinstructions, les variables locales actuelles et les noms de e e module disponibles. Pour des expressions avec un point comme string.a, la compl tion sera r alis e jusquau . e e e puis les compl tions correspondant aux attributs suivants seront sugg r es. Remarquez que cela peut amener a ex cuter e ee ` e du code propre a une application si un objet avec une m thode getattr () apparat dans lexpression. ` e
A.4 Commentaire
Cette commodit est un enorme pas en avant par rapport aux versions plus anciennes de linterpr teur ; n anmoins, e e e quelques vux restent a remplir : ce serait bien que lindentation soit sugg r e sur les lignes de continuation (lin` ee terpr teur sait si un lex` me dindentation est requis par la suite). Le m canisme de compl tion pourrait se servir de e e e e la table de symboles de linterpr teur. Une commande pour v rier (voire sugg rer) l quilibre des parenth` ses, des e e e e e quotes, etc. serait aussi tr` s utile. e
70
Annexe A. Edition dEntree Interactive et Substitution Historique
ANNEXE
Historique et Licence
B.1 Historique du logiciel
Python a et cr e au d but des ann es 1990 par Guido van Rossum au Stichting Mathematisch Centrum (CWI) au e e e e Pays-Bas en tant que successeur dun langage appel ABC. Guido est lauteur principal de Python, bien quil inclue e de nombreuses contributions de la part dautres personnes. La derni` re version diffus e par le CWI a et Python 1.2. e e e En 1995, Guido a continu son travail sur Python au Corporation for National Research Initiatives (CNRI) de Reston, e en Virginie (USA) o` il a diffus plusieurs versions de ce logiciel. Python 1.6 a et la derni` re des versions diffus es u e e e e par le CNRI. En 2000, Guido et l quipe de d veloppement centrale de Python sont partis a BeOpen.com pour former e e ` l quipe BeOpen PythonLabs. Python 2.0 a et la premi` re et seule version diffus e depuis BeOpen.com. e e e e A la suite de la sortie de Python 1.6, et apr` sque Guido van Rossum ait quitt CNRI pour travailler avec des e e d veloppeurs de logiciel commercial, il est apparu clairement que la capacit dutiliser Python avec du logiciel dispoe e nible sous la Licence Publique G n rale GNU (GPL) etait tr` s souhaitable. Le CNRI et la Free Software Foundation e e e (FSF) ont travaill ensemble pour mettre au point des changement de formulation dans la licence Python. Python 1.6.1 e est essentiellement la m me chose que Python 1.6, avec quelques bogues mineurs r gl s, et avec une licence diff rente e e e e qui permet aux versions suivantes d tre compatibles GPL. Python 2.0.1 est un travail d riv de Python 1.6.1, de m me e e e e que de Python 2.0. Apr` s que Python 2.0 ait et ait et diffus par BeOpen.com, Guido van Rossum et les autres d veloppeurs des e e e e e PythonLabs ont rejoint Digital Creations. Toute la propri t intellectuelle ajout e a partir de ce moment, incluant ee e ` Python 2.0.1 et ses versions alpha et beta, est poss d e par la Python Software Foundatio (PSF), une organisation e e sans but lucratif construite sur le mod` le de lApache Software Foundation. Voir http ://www.python.org/psf/ pour plus e dinformations a propos de la PSF. ` Merci aux nombreux volontaires ext rieurs qui ont travaill sous la direction de Guido pour rendre ces diffusions e e possibles.
` B.2 Termes et conditions dacces ou de toute autre utilisation de Python

PSF LICENSE AGREEMENT 1. This LICENSE AGREEMENT is between the Python Software Foundation (PSF), and the Individual or Organization (Licensee) accessing and otherwise using Python 2.0.1 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.0.1 alone or in any derivative version, provided, however, that PSFs License Agreement and PSFs notice of copyright, i.e., Copyright c 2001 Python Software Foundation ; All Rights Reserved are retained in Python 2.0.1 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.0.1 or any part thereof, 71
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.0.1. 4. PSF is making Python 2.0.1 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.0.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.0.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.0.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. 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.0.1, Licensee agrees to be bound by the terms and conditions of this License Agreement. BEOPEN.COM TERMS AND CONDITIONS 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. 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 OPEN SOURCE GPL-COMPATIBLE LICENSE AGREEMENT 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. 72 Annexe B. Historique et Licence
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. ACCEPT CWI PERMISSIONS STATEMENT AND DISCLAIMER
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. ========================================================== ` B.2. Termes et conditions dacces ou de toute autre utilisation de Python 73
La version traduite en francais de ce document, r sultat du travail initial de plusieurs traducteurs (Olivier Berger, Daniel e Calvelo Aros, Bruno Li nard) a et assembl e et mise a jour par Olivier Berger dans le cadre du projet b n vole e e e ` e e de traduction en francais de la documentation Python. Pour contribuer au projet, ou obtenir une mise a 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 et mis-` -jour r guli` rement pour tenir compte des evolutions du document original. La pr sente version est a jour par e a e e e ` rapport a la V2.0.1. Pri` re de bien vouloir me signaler (olberger@club-internet.fr) toute erreur de traduction, ou vos ` e remarques concernant cette traduction. Les questions concernant le langage Python ou le contenu du pr sent document e sont a adresser directement a lauteur. ` `
74
Annexe B. Historique et Licence

Langue

Python Tutoriel FR

Transféré par

Informations du document

Titre original

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

Python Tutoriel FR

Transféré par

Droits d'auteur :

Formats disponibles

Tutoriel Python

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

June 22, 2001

PythonLabs E-mail: python-docs@python.org

` TABLE DES MATIERES

8.2 8.3 8.4 8.5 8.6 9

Pour vous Mettre en Appetit

Chapitre 1. Pour vous Mettre en Appetit

Utilisation de lInterpreteur Python

standard, pour la m me raison expliqu e dans le paragraphe pr c dent.) e e e e

` 2.1.1 Passage de Parametres

2.1.2 Mode Interactif

LInterpreteur et Son Environnement

2.2.1 Gestion des Erreurs

Chapitre 2. Utilisation de lInterpreteur Python

lexception KeyboardInterrupt, qui peut etre g r e par une instruction try. ee

2.2.2 Scripts Python Executables

2.2.3 Le Fichier de Demarrage Interactif

2.2. LInterpreteur et Son Environnement

` Une Introduction Informelle a Python

Utiliser Python comme Calculatrice

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

Une valeur peut etre affect e a plusieurs variables simultan ment : e ` e

` Chapitre 3. Une Introduction Informelle a Python

3.1. Utiliser Python comme Calculatrice

` 3.1.2 Chanes de Caracteres

ce qui safcherait de la facon suivante :

Affiche cette notice dusage hte auquel il faut se connecter o

produit lafchage suivant :

` Chapitre 3. Une Introduction Informelle a Python

Usage: trucmuche [OPTIONS] -h o -H hte

Affiche cette notice dusage o hte auquel il faut se connecter

Cest ok Cest ok Ca cest faux

3.1. Utiliser Python comme Calculatrice

Voici un invariant utile des op rations de d coupage : s[ :i] + s[i :] egale s. e e

` Chapitre 3. Une Introduction Informelle a Python

>>> mot[-1] A >>> mot[-2] p >>> mot[-2:] pA >>> mot[:-2] Hel

3.1.3 Chanes Unicode

3.1. Utiliser Python comme Calculatrice

` Chapitre 3. Une Introduction Informelle a Python

>>> u"" aou u\344\366\374 >>> str(u"") aou \303\244\303\266\303\274

3.1. Utiliser Python comme Calculatrice

La fonction int gr e len() sapplique aussi aux listes : e e

` Chapitre 3. Une Introduction Informelle a Python

Premiers Pas Vers la Programmation

Une virgule nale emp che le retour chariot apr` s lafchage : e e

3.2. Premiers Pas Vers la Programmation

DAutres Outils de Controle dExecution

Chapitre 4. DAutres Outils de Controle dExecution

Chapitre 4. DAutres Outils de Controle dExecution

>>> print fib(0) None

Encore Plus sur la Denition de Fonctions

4.7.1 Valeurs dArgument par Defaut

4.7. Encore Plus sur la Denition de Fonctions

Chapitre 4. DAutres Outils de Controle dExecution

` 4.7.2 Arguments a Mot-Cle

pourrait etre appel e de lune des facons suivantes : e

mais les appels suivants seraient tous invalides :

4.7. Encore Plus sur la Denition de Fonctions

Elle pourrait etre appel e comme ceci : e

et bien s r, elle ecrirait : u

4.7.3 Listes dArguments Arbitraires