aragne python : module de base v1.5 05-03-2003...

ARAGNE PYTHON : module de base V1.5 05-03-2003

Formation BankSys 1

PPPPPPPPYYYYYYYYTTTTTTTTHHHHHHHHOOOOOOOONNNNNNNN

2003 http://www.aragne.com


Formation BankSys 2

:: Structure du cours Python ::

.: Module 1 : les bases :.Introduction ..................................................................................................... 4

Installer python................................................................................................. 4 Modifier sa variable d'environnement. .................................................................. 5 L'interpréteur mode console. ............................................................................. 6 L'interpréteur mode graphique IDLE. ................................................................... 6 Format d'un fichier Python.................................................................................. 7 Lancement d'un programme python..................................................................... 7

Les spécificités de Python par rapport aux autres langages..................................... 8 Le délimitation des blocs .................................................................................... 8 Le typage dynamique......................................................................................... 8 Les noms de variables et les mots réservés. ......................................................... 8

Structure des programmes Python .....................................................................10 Aide pour Python .............................................................................................11 Les types de données .......................................................................................14

Les données numériques ..................................................................................14 Les chaînes de caractères [] ..............................................................................14

Indiçage de la chaîne ....................................................................................... 15 Opérations sur les chaînes de caractères : .......................................................... 16

Les listes [ ] ....................................................................................................19 Les dictionnaires { }.........................................................................................21 Les tuple ( ).....................................................................................................22

Les structures de contrôles................................................................................25 Délimiteurs de blocs. ........................................................................................25 L'instruction de test : IF ....................................................................................26 Les boucles WHILE ...........................................................................................26 Les boucles FOR..............................................................................................27

L'instruction FOR et les listes ............................................................................ 27 La création fonctionnelle de listes à l'aide de FOR ................................................ 27 L'instruction FOR et les dictionnaires .................................................................. 28 L'instruction FOR et la fonction RANGE ............................................................... 29

Sortir d'une boucle : BREAK...............................................................................29 Retourner au début de la boucle : l'instruction CONTINUE .....................................29 PASS : l'instruction qui ne fait rien :-).................................................................30

Fonctions ........................................................................................................31 Définition ........................................................................................................31 Création d'une fonction : DEF():.........................................................................31 Passage d'arguments par mots-clés ...................................................................32 Passage d'arguments par mots-clés avec valeur par défaut. ..................................33 Passage d'un nombre variable d'arguments ........................................................33 Passage d'un nombre variable d'arguments avec valeur par défaut.........................34 Quelques infos supplémentaires sur la fonction : ..................................................34

Lambda ......................................................................................................... 34 Apply ............................................................................................................ 35 Map .............................................................................................................. 35 NONE............................................................................................................. 36

Importation de modules....................................................................................37 Sans son espace de nom...................................................................................37 Avec son espace de nom ...................................................................................38 PythnonPath ....................................................................................................38


Formation BankSys 3

La gestion des erreurs ......................................................................................40 Les exceptions ................................................................................................40 Gérer une exception ........................................................................................40

Try: except:.................................................................................................... 40 Try : finally :................................................................................................... 41

Provoquer une exception ...................................................................................41 Les entrées/sorties...........................................................................................43

Le chemin d'accès ............................................................................................43 Les fichiers .....................................................................................................43

Création d'un fichier ........................................................................................ 43 Ecrire des données dans le fichier ...................................................................... 43 Fermeture d'un fichier ...................................................................................... 44 Ecrire le contenu d'une liste dans le fichier.......................................................... 44 Lecture dans un fichier ..................................................................................... 44 Connaître la position de la 'tête de lecture' dans le fichier ..................................... 45 Positionner la 'tête de lecture' dans le fichier....................................................... 45 Exemple : copier des fichiers............................................................................. 45 Enregistrement et restitution de variables au format divers : PICKLE ..................... 47

Filter - Reduce .................................................................................................49 Filter...............................................................................................................49 Reduce ...........................................................................................................49

Classes, objets, attributs...................................................................................50 Utilité des classes.............................................................................................50

La dérivation .................................................................................................. 51 Définition d'une classe élémentaire.....................................................................51 Attributs (ou variables) d'instance ......................................................................52 Passage d'objets comme arguments lors de l'appel d'une fonction ..........................53 Similitude et unicité..........................................................................................54 Objets composés d'objets..................................................................................55 Objets comme valeurs de retour d'une fonction....................................................56 Les objets sont modifiables................................................................................56

Classes, méthodes, héritage ..............................................................................58 Définition d'une méthode ..................................................................................58 La méthode "constructeur" ................................................................................60 La méthode __str__ .........................................................................................61 Espaces de noms des classes et instances ...........................................................62 Héritage..........................................................................................................63 Modules contenant des librairies de classes .........................................................65

Un exemple sur les classes................................................................................66 Les chaînes __doc__ : documentez votre code.....................................................70 Le module __builtins__ ....................................................................................72 Le module string .............................................................................................74 Le module math ..............................................................................................75 Le module os ..................................................................................................76 Le module sys ................................................................................................78 Le module socket ............................................................................................79 Ressources......................................................................................................80

Ouvrages ........................................................................................................80 Sites Python essentiels : ...................................................................................80 Sites Python essentiels en français : .................................................................. 81


Formation BankSys 4

IInnttrroodduuccttiioonn Pourquoi Python ?

• Il est orienté Objet • Il est libre • Il est portable • Il est puissant • Il est interopérable • Il est facile à utiliser.

Python est à la fois, un langage de programmation, mais aussi interpréteur qui permet d'exécuter un programme python.

Installer python Sur le site officiel de python, http://www.python.org, vous pouvez télécharger le module python nécéssaire à votre OS. Sous Microsoft Windows, téléchargez Python-2.2.2.exe Depuis votre explorateur de Windows, double-cliquez sur ce fichier. Python va alors s'installer sur votre machine. Un lien est placé dans votre menu démarrage. Il existe deux manière d'accéder à Python :

• le mode console (fenêtre dos)

Fig 01 : Python en mode console texte


Formation BankSys 5

• le mode graphique (environnement graphique de développement IDLE)

Fig 02 : Python en mode console graphique

Modifier sa variable d'environnement. Afin de pouvoir appeler votre console python ou d'exécuter un script Pyhton de n'importe où sur votre machine, il est nécessaire de renseigner à Windows à quel endroit se trouve Python. Pour cela il faut modifier le chemin de recherche PATH de votre variable d'environnement.

Fig 03


Formation BankSys 6

Démarrer >> Paramètres >> Panneau de configuration >> icône Système >> onglet Avancé

Fig 04 Variables d'environnement >> Path >> Bouton Modifier >> Dans le champs, entrer le chemin vers Python. Dans ce cas : C:\Program Files\Python2.2;

L'interpréteur mode console. Plusieurs manières de lancer la console sous windows : Démarrer >> Programmes >> Accessoires >> Invite de commande DOS La console s'affiche à l'écran. Taper Python [enter] OU Démarrer >> Exécuter >> python.exe Vous êtes dans l'environnement python. Voir Fig 01

L'interpréteur mode graphique IDLE. Un environnement de développement graphique appelé IDLE est livré dans votre package. Il se situe dans votre répertoire Python22\tools\idle\idle.py Voir Fig 02


Formation BankSys 7

Format d'un fichier Python. Un fichier python source porte l'extension .py exemple : test.py Techniquement parlant, les programmes Python sont d'abord compilés (c'est-à-dire traduits) en une forme intermédiaire appelée bytecode, elle même analysée par l'interpréteur. La phase de compilation est cachée et est automatique, ce qui accélère les performances de Python en tant qu'interpréteur. Le fichier bytecode ou pré compilé porte l'extension .pyc exemple : test.pyc

Lancement d'un programme python. Lancer la console et taper python test.py [enter] 'bonjour le monde' Lancer la console. Lancer Python. A l'invite du prompt Python >>>print 'Bonjour le monde' Bonjour le monde Pour sortir de la console python, [CTRL]+[C] Pour sortir de IDLE console graphique python, [CTRL]+[D]


Formation BankSys 8

LLeess ssppéécciiffiicciittééss ddee PPyytthhoonn ppaarr rraappppoorrtt aauuxx aauuttrreess llaannggaaggeess

Le délimitation des blocs En Python, les blocs de code ne sont pas délimités par des point-virgules ou des accolades ouvrantes et fermantes, des begin et des end comme dans d'autres langages comme le C, Java ou Perl, mais par l'utilisation de l'indententation. Un exemple : def plusPetitPlusGrand(a, b): if a < b: print "%d est plus petit que %d" % (a, b) else: print "%d n'est pas plus petit que %d" % (a, b) if __name__ == "__main__": plusPetitPlusGrand(5, 12) Vous le constatez, le code est beaucoup plus lisible et plus compact. Veillez à garder une indentation homogène : soit des tabulations, soit des espaces (toujours le même nombre).

Le typage dynamique En Python, pas besoin de déclarer les variables avant de les utiliser. Cela élimine une contrainte souvent assez lourde dans d'autres langages mais implique plus de rigueur dans l'écriture du code. >>> a = "vil rat noir élu." >>> type(a) # quel est le type de a ? <type 'string'> # a est une chaîne de caractères >>> a = 1 >>> type(a) <type 'int'> # a est un entier

Les noms de variables et les mots réservés. Sous Python, les noms de variables doivent obéir à quelques règles simples :

•un nom de variable est une séquence de lettres (a _ z ,A_ Z) et de chiffres (0 _ 9), qui doit toujours commencer par une lettre. •seules les lettres ordinaires sont autorisées. Les lettres accentuées, les cédilles, les espaces, les caractères spéciaux tels que $, #, @, etc. sont interdits, à l'exception du caractère _ (souligné). • la casse est significative (c.à.d. que les caractères majuscules et minuscules sont distingués).

!!! Aragne, aragne, ARAGNE sont donc des variables différentes. Soyez attentifs ! Prenez l'habitude d'écrire l'essentiel des noms de variables en caractères minuscules (y compris la première lettre).


Formation BankSys 9

Par convention on utilise une nom de variable débutant par une majuscule pour désigner une classe. Il s'agit d'une simple convention, mais elle est largement respectée. N'utilisez les majuscules qu'à l'intérieur même du nom, pour en augmenter éventuellement la lisibilité, comme dans tableDesMatieres, par exemple. En plus de ces règles, ajoutons encore que vous ne pouvez pas utiliser comme noms de variables les 28 "mots réservés" ci-dessous (ils sont utilisés par le langage lui-même) :

and continue else for import not raise assert def except from in or returnbreak del exec global is pass try class elif finally if lambda print while


Formation BankSys 10

SSttrruuccttuurree ddeess pprrooggrraammmmeess PPyytthhoonn On pourrait simplifier en disant qu'en python nous créons des objets ou nous utilisons des objets déjà créés et nous "faisons des choses" à ces objets. Ces objets peuvent être internes à Python ou peuvent avoir été créés en C ou en Python. D'un point de vue plus concret, les programmes python peuvent être décomposés en :

• instructions •modules •objets

Les programmes sont composés de modules. Les modules contiennent des instructions. Les instructions créent et manipulent des objets. Voici quelques types d'objets que nous allons étudier dans les prochaines pages :

Type d'objet. Exemple d'usage. Nombre 3.1415, 1234,999L, 3+4j Chaine 'trappiste', "d'orval" Liste [1, [2, 'trois'], 4]

Dictionnaire {'bleue':10, 'rouge':6, 'tripple':8} Tuple (1, 'rochefort', 12, 'fromage') Fichier texte = open('cdrom', 'r').read()



AAiiddee ppoouurr PPyytthhoonn 1° Dans votre interpréteur IDLE tapez : >>> import string >>>dir(string) ['_StringType', '__builtins__', '__doc__', '__file__', '__name__', '_float', '_idmap', '_idmapL', '_int', '_long', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'atof', 'atof_error', 'atoi', 'atoi_error', 'atol', 'atol_error', 'capitalize', 'capwords', 'center', 'count', 'digits', 'expandtabs', 'find', 'hexdigits', 'index', 'index_error', 'join', 'joinfields', 'letters', 'ljust', 'lower', 'lowercase', 'lstrip', 'maketrans', 'octdigits', 'printable', 'punctuation', 'replace', 'rfind', 'rindex', 'rjust', 'rstrip', 'split', 'splitfields', 'strip', 'swapcase', 'translate', 'upper', 'uppercase', 'whitespace', 'zfill'] Ceci vous liste l'ensemble des méthodes disponibles pour la classe STRING. 2° Dans votre interpréteur IDLE tapez : >>> from pydoc import help >>> help Welcome to Python 2.2! This is the online help utility. If this is your first time using Python, you should definitely check out the tutorial on the Internet at http://www.python.org/doc/tut/. Enter the name of any module, keyword, or topic to get help on writing Python programs and using Python modules. To quit this help utility and return to the interpreter, just type "quit". To get a list of available modules, keywords, or topics, type "modules", "keywords", or "topics". Each module also comes with a one-line summary of what it does; to list the modules whose summaries contain a given word such as "spam", type "modules spam". help> A ce moment, par exemple entrez Topics pour accéder à la table des matières : help> topics Here is a list of available topics. Enter any topic name to get more help. ASSERTION DEBUGGING LITERALS SEQUENCEMETHODS1ASSIGNMENT DELETION LOOPING SEQUENCEMETHODS2ATTRIBUTEMETHODS DICTIONARIES MAPPINGMETHODS SEQUENCES ATTRIBUTES DICTIONARYLITERALS MAPPINGS SHIFTING AUGMENTEDASSIGNMENT ELLIPSIS METHODS SLICINGS BACKQUOTES EXCEPTIONS MODULES SPECIALATTRIBUTES BASICMETHODS EXECUTION NAMESPACES SPECIALIDENTIFIERS BINARY EXPRESSIONS NONE SPECIALMETHODS BITWISE FILES NUMBERMETHODS STRINGMETHODS BOOLEAN FLOAT NUMBERS STRINGS



CALLABLEMETHODS FORMATTING OBJECTS SUBSCRIPTS CALLS FRAMEOBJECTS OPERATORS TRACEBACKS CLASSES FRAMES PACKAGES TRUTHVALUE CODEOBJECTS FUNCTIONS POWER TUPLELITERALS COERCIONS IDENTIFIERS PRECEDENCE TUPLES COMPARISON IMPORTING PRINTING TYPEOBJECTS COMPLEX INTEGER PRIVATENAMES TYPES CONDITIONAL LISTLITERALS RETURNING UNARY CONVERSIONS LISTS SCOPING UNICODE help> Pour revenir dans votre espace de travail : help> quit You are now leaving help and returning to the Python interpreter. If you want to ask for help on a particular object directly from the interpreter, you can type "help(object)". Executing "help('string')" has the same effect as typing a particular string at the help> prompt. >>> 3° la fonctionnalité d'introspection : Par exemple, la description complète de la fonction open, est contenue dans la variable __builtins__.open.__doc__ . Exemple pratique : >>> f=open('temp\trappiste.txt', w) Traceback (most recent call last): File "<pyshell#23>", line 1, in ? f=open('temp\trappiste.txt', w) NameError: name 'w' is not defined >>> print __builtins__.open.__doc__ open(filename[, mode[, buffering]]) -> file object Open a file. The mode can be 'r', 'w' or 'a' for reading (default), writing or appending. The file will be created if it doesn't exist [etc] >>> F=open'temp\trappiste.txt', 'w') >>> 4° http://www.python.org/doc/current/ref/ref.html En visitant le site de référence de Python vous trouverez une liste exhaustive de ces outils. Il est également disponible Off Line dans votre répertoire Python\doc\ref\ref.html ou lorsque vous êtes dans la console graphique (IDLE), en utilisant le menu 'help'.



Fig 06

Fig 07



LLeess ttyyppeess ddee ddoonnnnééeess

Les données numériques Dans ce tableau, les différents types de numériques que vous offre Python

Type Notes Exemple Entiers Normalement 32 bits 421 ; -12 ; 0

Entiers longs Taille illimitée 65422187446642186540L

Virgules flottantes Taille entre E-308 et E+308.

Intègrent soit un point, soit la lettre e ou E pour les puissances de dix.

1.23 ; 2E2 ; 6.0e-204

Nombres complexes Taille illimitée. Possèdent une partie réelle et une partie imaginaire 5+7j ; 3+0j ; 4.5j

Nombres octaux et hexadécimaux Les octaux commencent par '0' et les hexadécimaux par '0x' 0177 ; 0x4E2F

Les constantes octales sont précédées de 0. Attention si vous écrivez 012 , Python l'interprète comme un octale et retourne donc 10 Les constantes hexadécimales sont précédées de 0x ou de 0X. Quelques manipulations : >>>abs(-42) #valeur absolue 42 >>>2**4 #puissance 16 >>>pow(2,4) #puissance 16 Python fournit toute une série d'outils et de modules pour la manipulation numérique par exemple le module math >>> import math >>> math.pi 3.1415926535897931

Les chaînes de caractères " " Les chaînes de caractères, en Python, se placent entre simples quotes, doubles quotes ou triples quotes. Elles ne peuvent contenir que des caractères. Elles sont des séquences non modifiables directement. On utilise indifféremment les simples et les doubles quotes pour les textes assez courts. On peut placer des simples et doubles quotes entre des triples quotes. >>> print "Programmer en %s, c'est 'fun'." %'Python' Programmer en Python, c'est 'fun' >>> print '"Exemple : " %i * %i = %i'%(12, 12, 144) "Exemple : " 12 * 12 = 144



>>> print """Ce texte peut comporter des "doubles quotes" ... ou des 'simples quotes'. Les caractères d'échappement ... comme \\n (retour à la ligne) ou \\t (tabulation) doivent ... commencer par un anti-slash.""" Ce texte peut comporter des " doubles quotes" ou des 'simples quotes'. Les caractères d'échappement comme \n (retour à la ligne) ou \t (tabulation) doivent commencer par un anti-slash.

Indiçage de la chaîne L'indice va jusqu'à l'élément dont on donne sa position sans l'inclure.

Fig 05

Opérations sur les chaînes de caractères :

Concaténation de chaînes de caractères >>> 'Bobo ' + 'casse ' + 'la croûte'

Bobo casse la croûte Dans ce cas, on parle de surcharge de l'opérateur + qui sert d'abord à additionner des nombres, mais dans le cas de deux ou plusieurs strings, Python effectue une concaténation. Longueur de 'Bobo' >>> len("Bobo")

4

Multiplication d'une chaine >>> 'Ni! ' * 4

Ni! Ni! Ni! Ni! Accéder aux éléments d'une chaine >>> alphabet = 'abcdef' # création d'une chaine



>>> alphabet[0] # L'index démarre à 0

'a'

>>> alphabet[1]

'b'

>>> alphabet[:1]

'a'

>>> alphabet[1:]

'bcdef'

>>> alphabet[-1:]

'f'

>>> alphabet[:-1]

'abcde'

>>> alphabet[2]

'c'

Extraction de la chaîne

>>> chaine='westvleteren' >>> chaine[2:4] st Retourne le contenu de la chaîne de l'indice 2 jusqu'au 4 SANS l'inclure.

Modification d'une chaîne

Attention : Les chaînes de caractères sont non modifiables directement : >>> tutu = "ortjographe" Essayons de remplacer ce 'j' en 'h' : >>> tutu[3] = 'h' Traceback (innermost last): File "<pyshell#11>", line 1, in ? tutu[3] = 'h' TypeError: object doesn't support item assignment Python lève une erreur et affiche le TraceBack qui vous permet d'identifier l'erreur. Il vous indique l'endroit où l'interpréteur a déclenché (line 1), l'instruction sur laquelle il cale et le type d'erreur. Pour modifier une chaîne, il faut en créer une nouvelle ou recréer la chaîne à modifier à partir de sous-chaînes. Exemple : >>> tutu = "ortjographe" >>> tutu = tutu[:3] + 'h' + tutu[4:] >>> tutu



'orthographe'

Appartenance à une chaine de caractère

>>> chaine='alain' >>> 'l' in chaine 1 >>>'a' in chaine 1 Le 1 signifie que le caractère appartient à la chaîne (true) Parcourir la chaîne au moyen d'une boucle

for c in chaine: print c a l a i n Surcharge de l'opérateur %

% qui est l'opérateur modulo sur les nombres, peut-être surchargé par Python lorsqu'il travaille avec des chaînes. >>>"La Chimay %s titre a %d degre"%("bleue",10) 'la Chimay bleue titre a 10 degre' %s : string %d : décimal Code de formatage des chaînes

Code Signification %s Chaîne (ou tout autre objet) %c Caractère %d Entier décimal %u Entier non-signé %o Entier octal %x Entier hexadécimal

Outils de traitement des chaînes Python fournit une série de modules utilitaires pour manipuler les chaînes. Le module string est le plus utilisé. Dans votre interpréteur tapez >>> import string >>> dir(string) ['_StringType', '__builtins__', '__doc__', '__file__', '__name__', '_float', '_idmap', '_idmapL', '_int', '_long', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'atof', 'atof_error', 'atoi', 'atoi_error', 'atol', 'atol_error', 'capitalize', 'capwords', 'center', 'count', 'digits', 'expandtabs', 'find', 'hexdigits', 'index', 'index_error', 'join', 'joinfields', 'letters', 'ljust', 'lower', 'lowercase', 'lstrip', 'maketrans', 'octdigits', 'printable', 'punctuation', 'replace', 'rfind', 'rindex', 'rjust', 'rstrip', 'split', 'splitfields', 'strip', 'swapcase', 'translate', 'upper', 'uppercase', 'whitespace', 'zfill']



Voici les différentes méthodes disponibles pour l'objet string. Et voici comment utiliser ces différentes méthodes. Créons d'abord une chaîne. >>> chaine='orval' >>> chaine.upper() ORVAL >>>chaine.find('V') -1 >>>int('42') 42 >>>chaine.split('v') ['or', 'al'] >>> chaine.replace ('al','et') orvet

Les listes [ ] La liste est l'objet de collection le plus souple de Python. Une liste peut contenir tout de sorte d'objets : nombres, caractères, chaînes, et même d'autres listes. La liste peut être modifiée directement sur place, contrairement aux chaînes. En fait, les listes sont vraiment des tableaux C à l'intérieur de l'interpréteur python. Les références aux objets de la liste sont comme des pointeurs comme dans le langage C. Mais, Python ne manipule pas la référence, mais suit la référence vers l'objet sur lequel il pointe, ainsi vos programmes manipulent uniquement des objets. Quelques manipulations sur les listes Déclaration d'une liste :

>>>L1=[ ] Liste à 4 éléments indicés de gauche à droite et de 0 à 3

>>>L2=[0,1,2,3] >>>L2[0] 0 >>>L2[2] 2



Liste comprenant une ou plusieurs autres listes.

>>>liste=['bieres',['chimay','orval','rochefort'],['westvleteren','westmalle','achel']] Accès aux éléments de la liste

>>>liste[1] ['chimay', 'orval', 'rochefort'] >>>liste[2][1] 'westmalle' >>> liste[2][1][1] 'e' Parcours de la liste dans une boucle

>>> for elem in liste: print elem, bieres ['chimay', 'orval', 'rochefort'] ['westvleteren', 'westmalle', 'achel'] Appartenance à la liste IN

>>> 'bieres' in liste 1 Le 1 signifie True. Le mot 'bieres' est bien dans la liste >>> 'orval' in liste 0 >>> 'orval' in liste[1]

Longueur de la liste

>>>len (L2) 4 >>>len (liste) 3 Concaténation de deux listes

>>> [1,2,3]+['a','b','c'] [1, 2, 3, 'a', 'b', 'c'] Modification d'une liste sur place par indiçage

>>>liste[0]='trapis' >>>liste ['trapis', ['chimay', 'orval', 'rochefort'], ['westvleteren', 'westmalle', 'achel']] Modification d'une liste sur place par tanche

>>> liste ['trapis', ['chimay', 'orval', 'rochefort'], ['westvleteren', 'westmalle', 'achel']] >>> liste[0:1]=["trappistes","belges"] >>> liste ['trappistes', 'belges', ['chimay', 'orval', 'rochefort'], ['westvleteren', 'westmalle', 'achel']]



Ajout à la fin d'une liste

>>> liste.append("good for you") >>> liste ['trappistes', 'belges', ['chimay', 'orval', 'rochefort'], ['westvleteren', 'westmalle', 'achel'], 'good for you'] Ajout dans la liste

>>> liste.insert(4,"is") >>> liste ['trappistes', 'belges', ['chimay', 'orval', 'rochefort'], ['westvleteren', 'westmalle', 'achel'], 'is','good for you'] Trier les éléments de la liste

>>> liste[3].sort() >>> liste ['trappistes', 'belges', ['chimay', 'orval', 'rochefort'], ['achel', 'westmalle', 'westvleteren'], 'is','good for you'] Effacer des éléments dans une liste.

>>> del liste[4:6] >>> liste ['trappistes', 'belges', ['chimay', 'orval', 'rochefort'], ['achel', 'westmalle', 'westvleteren']] >>> del liste[3][0] >>> liste ['trappistes', 'belges', ['chimay', 'orval', 'rochefort'], ['westmalle', 'westvleteren']]

Les dictionnaires { } Si les listes sont des collections ordonnées d'objets, les dictionnaires sont des collections non-ordonnées. Dans les listes, les éléments sont stockés et récupérés par déplacement. L[2]='coucou' Dans les dictionnaires, les éléments sont stockés et récupérés par clés. C'est là, la principale différence entre les listes et les dictionnaires. Si les listes sont des tableaux de références d'objets, les dictionnaires sont des tables non-ordonnées de références d'objets. En interne, Python implémente les dictionnaires comme des tables de hachage, ce qui donne un accès très rapide aux données. Quelques manipulations sur les dictionnaires Déclaration d'un dictionnaire :

>>>dico={} Dictionnaire à 3 éléments :



>>> dico={'bleue':20, 'rouge':7, 'tripple':8} Dans ce dictionnaire la clé est un objet de type chaîne : 'bleue' 'rouge' 'tripple'. La valeur étant le % d'alcool par volume. Indiçage par clé >>> dico['bleue'] 20 Liste des éléments du dictionnaire

>>> dico.items() [('bleue', 20), ('tripple', 8), ('rouge', 7)] Liste des clès

>>> dico.keys() ['bleue', 'tripple', 'rouge'] Liste des valeurs

>>> dico.values() [20, 7, 8] Appartenance

>>> dico.has_key('tripple') 1 Retourne 1 pour Vrai (true) >>> dico.has_key('orval') 0 Longueur du dictionnaire (nombres d'entrées dans le dico)

>>> len(dico) 3 Ajout d'une valeur dans le dictionnaire

La clé est d'abord précisée et ensuite on passe la valeur dico['westveleteren']=12 >>> dico {'westveleteren': 12, 'bleue': 20, 'tripple': 8, 'rouge': 7}

Modification du dictionnaire

>>> dico['bleue']=10 >>> dico {'westveleteren': 12, 'bleue': 10, 'tripple': 8, 'rouge': 7} Destruction d'un élément du dictionnaire

>>> del dico['westveleteren'] >>> dico {'bleue': 10, 'tripple': 8, 'rouge': 7} Voici un exemple plus complexe et plus réaliste de l'utilisation d'un dictionnaire. Nous allons créer un dictionnaire qui associe les noms des abbayes de la Trappe (les clés) et les noms des provinces où elles se situent (les valeurs)



>>> dico = {'Luxembourg':'Orval','Namur':'Rochefort','Hainaut':'Chimay','Flandres orientale':'Westmalle', 'Anvers':'Westvleteren'} >>> dico {'Hainaut': 'Chimay', 'Flandres orientale': 'Westmalle', 'Namur': 'Rochefort', 'Anvers': 'Westvleteren', 'Luxembourg': 'Orval'} Nous allons récupérer le nom de l'abbaye en l'indexant avec le nom de la province >>> province='Hainaut' >>> abbaye=dico[province] >>> abbaye 'Chimay'

Les tuple ( ) Le dernier type de collection est le tuple. Le tuple construit un groupe d'objets simples. Ils sont utilisés exactement comme une liste, excepté qu'ils ne peuvent être changés sur place, ils ne sont donc pas modifiables directement. Il faudra créer un autre tuple pour toute modification, ajout ou suppression d'un objet. Ils sont accédés par déplacement et peuvent contenir tout type d'objet simple ou composé (listes, dico, tuple). Comme ils ne sont pas directement modifiables, les tuple ne peuvent grandir ni diminuer de taille sans la création d'un autre tuple. Quelques manipulations sur les tuple. Création d'un tuple vide

>>> tup=() >>> tup () Création d'un tuple à un élément

>>> tup=(0,) >>> tup (0,) !! Remarquez la virgule après le premier élément. Si vous omettez la virgule, il s'agit d'une affectation simple d'une variable >>> tup=(0) >>> tup 0 Preuve, dans le premier cas, l'accès à la valeur se fait par indiçage >>> tup=(0,) >>> tup[0] 0 ou encore : >>> type(tup) <type 'tuple'> Tandis que dans le second cas, l'accès par indiçage lève une erreur Python >>> tup=(0) >>> tup[0]



Traceback (most recent call last): File "<pyshell#62>", line 1, in ? tup[0] TypeError: unsubscriptable object Ou encore : >>> type(tup) <type 'int'> Création d'un tuple à 5 éléments

>>> tup=(0,1,2,3,4,5) >>> tup (0, 1, 2, 3, 4, 5) Une autre manière de faire >>> tup= 1,2,4,5,3 >>> tup (1, 2, 4, 5, 3) Dans ce cas, Python autorise l'omission des parenthèses si le contexte ne prête pas à confusion. !!! Il est cependant fortement conseillé d'utiliser les parenthèses. !!! Tuple avec inclusion

>>> tup=('alain', 'denis',('orval', 'chimay')) >>> tup ('alain', 'denis', ('orval', 'chimay')) Accès par indiçage

>>> tup[0] 'alain' >>> tup[2][0] 'orval' Une tranche de tuple

>>> tup[0:2] ('alain', 'denis') !! remarquez qu'il n'inclut pas l'élément 2. Longueur du tuple

>>> len(tup) 3 Concaténation de 2 tuple

>>> tup2=('olivier', 'rochefort') >>> tup+tup2 ('alain', 'denis', ('orval', 'chimay'), 'olivier', 'rochefort') Test d'appartenance au tuple

>>> 'alain' in tup



1 >>> 'orval' in tup 0 >>> 'orval' in tup[2] 1 Le 1 : vrai true, l'objet appartient au tuple Le 0 : faux false, l'objet n'appartient pas au tuple 'orval' appartient au 'sous' tuple. (Inclusion de tuple)



LLeess ssttrruuccttuurreess ddee ccoonnttrrôôlleess

Délimiteurs de blocs. En python les blocs d'instructions ne sont pas délimités par des { }, des begin end, … Les instructions ne se terminent pas par des ; ou autre signe de ponctuation. Python détecte les limites de blocs par l'analyse de l'indentation des lignes: toutes les instructions indentées de la même façon appartiennent au même bloc de code. L'indentation peut consister en n'importe quelle combinaison d'espaces et de tabulations. La seule contrainte est de toujours respecter la même indentation dans tout le code.

Fig 07

Des blocs de code peuvent être imbriqués en ajoutant de l'indentation. Les lignes d'en-tête se terminent par : . Voici un petit exemple : def afficher(mot, biere): print mot if mot =='goloum': print ('bonjour Mon Maitre') elif mot =='saroman': print ('Attention voila le Mal') if biere =='chimay': print ('A la tienne saroman') else: print('y a personne') Une instruction 'trop longue' peut s'étendre à la ligne suivante en lui collant le \ après la dernière lettre >>> print \ ('bonjour') bonjour



L'instruction de test : IF L'instruction IF (si) prend la forme d'un test IF suivi d'un ou plusieurs tests conditionnels ELIF (sinon, si) et se termine par un bloc optionnel ELSE (sinon). If <test01>: <instruction 1> <instruction …> elif <test02>: <instruction a> else: <instruction xx> !!! Notez la présence des : à la fin des en-tête. En pratique les parties ELIF et ELSE peuvent être omises. Il n'existe pas d'instruction SWITCH ou CASE en Python. Nous utilisons le IF avec ELIF if biere = "bleue": degre="10" elif biere="tripple": degre="8" elif biere="rouge": degre="6" else: print "cette catégorie n'existe pas"

Les boucles WHILE Expression de contrôle de boucle. Le test de contrôle se fait en début, avant que les instructions du corps ne soient exécutées. Tant que le test est vrai, les instructions du corps de boucle se répètent. Forme générale : while <test>: <instruction01> <instruction…> else : <instruction> Exemple : >>> a=0 >>> b=10 >>> while a<b: print a, a=a+1 0 1 2 3 4 5 6 7 8 9



Les boucles FOR La boucle FOR est une forme générique d'itération de séquence. Elle est utilisée pour balayer tout les objets qui répondent aux opérations d'indiçage et de séquence comme les chaînes, les listes et les tuple. Forme générale : for <cible> in <objet>: <instruction> else: <instruction> Le nom <cible> qui suit le mot réservé for est celui que vous choisissez pour la variable destinée à contenir successivement tous les éléments de la séquence. Cette variable est définie automatiquement (c.à.d. qu'il est inutile de la définir au préalable), et son type est automatiquement adapté à celui de l'élément de la séquence qui est en cours de traitement (rappel : dans le cas d'une liste, tous les éléments ne sont pas nécessairement du même type). Le nom <objet> qui suit le mot réservé in est celui de la séquence qu'il faut traiter.

L'instruction FOR et les listes >>> liste = ['chimay','orval','westmalle'] >>> for trappiste in liste: print 'longueur de la chaine', trappiste, '=', len(trappiste)

longueur de la chaine chimay = 6 longueur de la chaine orval = 5 longueur de la chaine westmalle = 9

>> divers = ['cheval', 3, 17.25, [5, 'Jean']] >> for e in divers: print e cheval 3 17.25 [5, 'Jean'] Bien que les éléments de la liste divers soient tous de types différents (une chaîne de caractères, un entier, un réel, une liste), on peut affecter successivement leurs contenus à la variable e, sans qu'il s'ensuive des erreurs (ceci est rendu possible grâce au typage dynamique des variables Python).

La création fonctionnelle de listes à l'aide de FOR Python 2.0 a introduit un nouveau concept très intéressant: les mutations de listes ou création fonctionnelle de liste (list comprehension ou list mapping en anglais). C'est un moyen très pratique d'appliquer une fonction sur chaque élément d'une liste afin d'en produire une nouvelle. Un exemple simple: >>> maliste = [num*2 for num in range(1, 11)] >>> print maListe [2,4,6,8,10,12,14,16,18,20]

Qui est l'équivalent de: >>> maliste2 = [] >>> for num in range(1, 11): >>>... maliste2.append(num*2)



L'idée est de pouvoir créer des listes d'une manière plus simple et sans passer par map, filter ou lambda. Ce qui permet de rendre le code plus clair. Chaque list comprehension consiste en une expression suivie d'une clause for, puis zéro ou plusieurs clauses for ou if. Le résultat sera une liste résultant de l'évaluation de l'expression dans le contexte des clauses for et if qui la suivent. Si l'expression s'évalue en un tuple, elle doit être mise entre parenthèses. Quelques exemples plus complexes: La table de deux autrement: >>> table_de_deux = [num for num in range(1, 21) if num % 2 == 0] >>> table_de_deux [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Des fruits et des légumes: >>> from pprint import pprint # 'pretty print' ou la jolie impression. >>> fruits = ['pommes', 'oranges', 'bananes'] >>> legumes = ['choux rouges', 'navets', 'carottes'] >>> pprint(["des %s et des %s" % (fruit, legume) for fruit in fruits for legume in legumes]) >>> ['des pommes et des choux rouges' 'des pommes et des navets' 'des pommes et des carottes' 'des oranges et des choux rouges' 'des oranges et des navets' 'des oranges et des carottes' 'des bananes et des choux rouges' 'des bananes et des navets' 'des bananes et des carottes']

Quelles sont les possibilités pour obtenir 6 avec 3 dés à 6 faces ? >>> print [(x, y, z)\ ... for x in range(1, 7)\ ... for y in range(1, 7)\ ... for z in range(1, 7)\ ... if x + y + z == 6] [(1, 1, 4), (1, 2, 3), (1, 3, 2), (1, 4, 1), (2, 1, 3), (2, 2, 2), (2, 3, 1), (3, 1, 2), (3, 2, 1), (4, 1, 1)]

L'instruction FOR et les dictionnaires >>> dico {'Hainaut': 'Chimay', 'Flandres orientale': 'Westmalle', 'Namur': 'Rochefort', 'Anvers': 'Westvleteren', 'Luxembourg': 'Orval'} >>> for trappe in dico.keys(): print ' ', trappe, '\t', dico[trappe] Hainaut Chimay Flandres orientale Westmalle Namur Rochefort Anvers Westvleteren Luxembourg Orval Les dictionnaires ne sont pas des séquences, vous ne pouvez pas les parcourir directement avec une instruction for, comme pour des listes ou des chaînes. Donc, pour passer en revue tous les éléments du dictionnaire, nous faisons appel à la méthode keys. Ensuite nous imprimons la clé (trappe) et nous imprimons la valeur en indiçant le dico par sa clé dico[trappe].



L'instruction FOR et la fonction RANGE RANGE est une fonction indépendante de FOR qui retourne rapidement une liste d'entier >>> range(5) [0, 1, 2, 3, 4] >>> range(2,10) [2, 3, 4, 5, 6, 7, 8, 9] >>> range(2,10,2) [2, 4, 6, 8] Utilisée à l'aide de FOR, elle va lui fournir un indice de boucle : >>> for i in range(3): print i, 'euro' 0 euro 1 euro 2 euro Combinée avec la méthode LEN, nous allons pouvoir travailler sur la longueur d'une chaîne, d'une liste, ... >>> chaine='boire avec moderation' >>> for i in range(len(chaine)):print i,chaine[i], '::', 0 b :: 1 o :: 2 i :: 3 r :: 4 e :: 5 :: 6 a :: 7 v :: 8 e :: 9 c :: 10 :: 11 m :: 12 o :: 13 d :: 14 e :: 15 r :: 16 a :: 17 t :: 18 i :: 19 o :: 20 n :: Nous prenons donc la longueur de la chaîne et l'utilisons comme paramètre pour le range qui affecte la valeur d'indiçage de la boucle. Ensuite nous imprimons l'indice i, l'élément courant de la chaîne avec une concaténation de ::

Sortir d'une boucle : BREAK Pour interrompre le flux d'une boucle, nous utiliserons l'instruction BREAK. while <condition 1> : <instructions diverses> if <condition 2> : <instructions diverses> break if <condition 3>: break etc.

Retourner au début de la boucle : l'instruction CONTINUE L'instruction CONTINUE permet d'éviter les instructions imbriquées >>> x=10 >>> while x: x=x-1 if x % 2 != 0: continue print x, 8 6 4 2 0



CONTINUE retourne au début de la boucle; de ce fait l'instruction print qui est dans la boucle n'est pas exécutée. Print ne sera exécutée que si CONTINUE n'est pas exécutée. !! Continue peut sauter des morceaux de programmes. Il peut donc se comporter comme un goto et donc doit être utilisé avec beaucoup de doigté.

PASS : l'instruction qui ne fait rien :-) L'instruction PASS est souvent utilisée pour coder un corps vide, pour une instruction composée… Cela permet de déjà architecturer un programme, un module ou une classe sans avoir développé toutes les instructions. >>> def rien(): pass >>> rien() >>> x=rien() >>> print x None



FFoonnccttiioonnss

Définition Une fonction regroupe une série d'instructions, ce qui s'avère très utile lorsqu'elle est utilisée plusieurs fois dans un programme. L'appel à une fonction pourra aussi se faire à l'aide de paramètres qui peuvent varier lors de chaque appel. Forme générale : def <nom_fonction>(arg1, arg2, ...., argN): <instructions> return <valeur>

Création d'une fonction : DEF(): Def(): crée un objet fonction et lui donne un nom. Le nom fourni est affecté à l'objet fonction. Le nom fourni devient alors la référence à l'objet fonction. Exemple : 1. >>> def bonjour(): 2. print 'bonjour' 3. >>> bonjour() 4. bonjour 1. création de la fonction bonjour. Remarquez les : et les () obligatoires 2. instruction dans le corps de la fonction 3. appel de la fonction bonjour. Remarquez les () 4. résultat de l'exécution. Retour d'un résultat de fonction à l'appelant : RETURN 1. >>> def date_jour(): 2. import time 3. date_jour=time.asctime(time.localtime(time.time())) 4. return date_jour 5. >>> date_jour() 6. 'Mon Dec 23 16:54:16 2002' 1. création de la fonction date_jour 2. importation du module time pour le traitement des dates 3. affectation de la variable date_jour 4. renvoi du résultat 5. appel de la fonction 6. résultat affiché



Passage d'arguments par mots-clés Voici un exemple de passage de paramètre >>> def euro(fb): return fb * 40.3399 >>> euro(1500) 60509.849999999999 >>> euro(1) 40.3399 >>> euro(6) 242.0394 Ecrivons une petite fonction qui génère aléatoirement un mot de passe constitué de lettres et de chiffres. Sauvegardons cette fonction dans un fichier sous le nom password.py. Nous venons de créer un module contenant une fonction. 1. def password (nom, prenom): 2. import string, whrandom 3. s=string.letters + string.digits 4. cle=whrandom.choice(s) 5. for i in range(whrandom.choice([4,5,6])): 6. cle = cle + whrandom.choice(s) 7. print nom, prenom, ':', cle 8. return nom, prenom, cle 9. if __name__=="__main__": 10. import sys 11. nom = sys.argv[1] 12. prenom = sys.argv[2] 13. password(nom, prenom) 1. déclaration de la fonction 2. importation des modules STRING et WHRANDOM 3. affectation d'une variable s qui contient toutes les lettres minuscules et majuscules ainsi que

les 10 chiffres (abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789) 4. cle reçoit un choix aléatoire des lettres et des chiffres contenus dans s 5. une boucle parcourt cle et sélectionne entre 5 à 8 caractères pour former la cle 6. le nouveau caractère sélectionné au hasard est ajouté à cle 7. impression des variables nom, prenom, cle 8. renvoie des variables nom, prenom, cle 9. lors de l'appel du module cette instruction permet l'exécution du module.(Code d'autotest): vrai uniquement si le fichier est exécuté depuis la ligne de commande par exemple; faux lors de son importation comme bibliothèque. 10. importation du module sys 11. la variable nom est affectée par le premier argument passé lors de l'appel du module 12. la variable prenom est affectée par le second argument passé lors de l'appel du module 13. appel de la méthode avec passage des arguments Appelons, passons les paramètres et exécutons notre module depuis la console DOS : python password.py Meurant Alain



Résultat : Meurant Alain : Vx9L6K Lorsque des arguments sont passé par mots-clés, leur ordre n'a pas d'importance, Python assure lui-même la correspondance par nom et non pas par position.

Passage d'arguments par mots-clés avec valeur par défaut. Au moment ou l'on crée la définition, on affecte une valeur par défaut aux arguments passés. Reprenons de l'exemple de l'euro : >>> def euro(fb=0): return fb * 40.3399 >>> euro(1500) 60509.849999999999 >>> euro(1) 40.3399 >>> euro(6) 242.0394 Si aucun paramètre n'est fourni, fb prend comme valeur 0 et retourne un résultat. >>> euro() 0.0

Passage d'un nombre variable d'arguments non-nommés Lorsque le nombre d'arguments à passer est variable, il est possible de passer les arguments en utilisant *args. Les arguments sont alors placés dans un tuple car non modifiable (augmente la sécurité et évite une modification ailleurs dans le programme). En utilisant le FOR on peut alors parcourir *args et récupérer les arguments passés. Exemple : >>> def addition (*args): somme=0 for elem in range(len(args)): somme=somme+int(args[elem]) print somme appel de la fonction avec un argument >>> addition(1) 1 appel de la focntion avec plusieurs arguments >>> addition(1,2,3) 6



Passage d'un nombre variable d'arguments non-nommés et nommés. Lorsque le nombre d'arguments à passer est variable, et que l'on souhaite donner une valeur par défaut aux arguments, nous allons utiliser **args. Les arguments sont alors placés dans un dictionnaire. Exemple : >>> def f1(*args, **kwargs): return args, kwargs Appellons f1 sans lui passer d'argument. >>> f1() ((), {}) Il nous retourne un tuple et un dictionnaire vide. Passons maintenant des arguments sans valeurs et avec valeurs prédéfinies >>> f1(2,3,4,x=0,Y=2) ((2, 3, 4), {'Y': 2, 'x': 0}) Nous obtenons un tuple et un dictionnaire. Rappellons au passage que le dictionnaire est organisé par python sur le principe d'une table de hashage, c'est donc Python qui choisit "l'ordre". L'interrogation se fera par clé et non pas indiçage comme dans le tuple. Exemple : >>> def f1(*args, **kwargs): return args[0:2], kwargs['y'] >>> f1(1,2,3,y=9) ((1, 2), 9)

Quelques infos supplémentaires sur la fonction :

Lambda . crée une fonction anonyme. . est une expression et non une instruction. . le corps de lambda est une simple expression et pas un bloc d'instructions exemple : >>> lam=lambda x,y,z:x+y+z >>> lam(4,1,5) 10 Autre exemple avec modification d'un argument lors de l'appel >>> lam=lambda a="bra",b="ppi", c="ste":a+b+c appel sans passage d'argument >>> lam() 'brappiste



appel avec passage d'argument(s) >>> lam('tra') 'trappiste'

Apply . appelle des fonctions avec des tuple en arguments sans connaître le nombre d'arguments. Reprenons notre fonction addition() : >>> def addition (*args): somme=0 for elem in range(len(args)): somme=somme+int(args[elem]) print somme Utilisons apply : >>> apply(addition,(12,3,5)) 20 >>> apply(addition,(12,3,4,5)) 24 >>> apply(addition,(12,3,5,10,4,100)) 134

Map . exécute une fonction sur les éléments d'une séquence et collecte les résultats . remplace avantageusement le FOR dans certains cas. Exemple : Voici une petite fonction qui retourne un prix en euro >>> def euro(x): return x/40.3399 >>> euro(40) 0.99157409909295757 Nous avons maintenant une liste de prix à convertir en euro. Avec FOR : >>> prix=[852, 1034, 56734] >>> maj=[] >>> for i in prix: maj.append(i/40.3399) >>> maj [21.120528310679997, 25.632190461552955, 1406.3991234484963] Avec MAP : >>> map(euro, prix) [21.120528310679997, 25.632190461552955, 1406.3991234484963]



Avec MAP et LAMBDA : >>> map((lambda x: x/40.3399), prix) [21.120528310679997, 25.632190461552955, 1406.3991234484963]

NONE La fonction retourne NONE si elle n'utilise pas une instruction return L'instruction return n'est pas obligatoire. Lorsqu'elle est terminée, la fonction ne fait rien. Elle retourne NONE. Exemple : Une fonction qui imprime l'argument passé >>> def rien(x): print x affectation de x par appel de la fonction >>> x=rien('biere') biere impression de la variabel x retourne None >>> print x None La fonction est un objet comme les nombres ou les chaînes.



IImmppoorrttaattiioonn ddee mmoodduulleess Ce chapitre présente la notion de module en Python. Le module est l'unité d'organisation de programme de plus haut niveau pour les programmes, qui regroupe le code et les données de programme pour en faciliter la structuration et la réutilisation. Comme les unit de Pascal, les modules de Python vont contenir des méthodes et des classes définies utilisables par d'autres programmes. Il va donc falloir indiquer à ces programmes où prendre ces bouts de code. En python, nous parlons d'importation. Les modules sont gérés par : Import : permet à un client de récupérer d'un module dans son entièreté From : permet à un client de récupérer certains noms issus d'un module Reload : fournit une méthode de rechargement du module sans avoir besoin d'arrêter Python. Python nous offre deux possibilités pour importer :

•Importer une méthode d'un module: importation avec espace de nom >>> from os import chdir •Importer le module en entier: importation sans espace de nom >>> import time

Sans son espace de nom import <module> Dans ce cas vous importez la totalité du module. Dès lors, lorsque vous désirez utiliser une méthode du module importé, vous allez devoir d'abord donner le nom du module et ensuite le nom de la méthode. Forme générale : import module module.methode() Exemple : voici comment procédez pour utiliser la méthode getcwd() du module os. >>> import os >>> print os.getcwd() /produits/bieres/trappistes Le module os contient les services courants du système d'exploitation. La méthode getcwd() récupère le répertoire de travail [getcwd = 'get current working directory']



Avec son espace de nom from <module> import <method> Seule la méthode est importée et non tout le module. Dans ce cas, il n'y a plus besoin d'utiliser le nom du module pour appeler une méthode. >>> from os import getcwd >>> print getcwd() d:\temp !!! Veillez à ce que le nom de la méthode d'un module ne soit pas identique au nom de la méthode d'un autre module. exemple : la méthode open() qui existe en standard et la méthode open() du module os. Dans ce cas, préférez la première solution : os.open() Si vous devez utiliser plusieurs méthodes d'un même module, vous pouvez importer toutes les méthodes du module comme ceci : from <module> import * >>> from math import * On peut mélanger les deux solutions suivant l'utilité : >>> import sys, os, cgi >>> from stat import * >>> from time import localtime

PythnonPath Pour importer un module, il faut qu'il soit dans le PYTHONPATH. Qu'est-ce donc que cela ? Le PYTHONPATH est une variable d'environnement composées de tous les chemins vers les répertoires contenant les modules Python. Vous pouvez ajouter vous-même des chemins vers les répertoires où vous placez vos modules. Afin de modifier le pythonpath, vous devez utiliser la méthode append de la liste sys.path du module OS. Voici le contenu de sys.path : >>> import os >>> print os.sys.path ['D:\\Program Files\\Developpement\\Python22\\Tools\\idle', 'D:\\Program Files\\Developpement\\Python22\\Tools\\idle', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\DLLs', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\lib', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\lib\\lib-tk',



'D:\\PROGRA~2\\DEVELO~1\\PYTHON22', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\lib\\site-packages'] Voici comment ajouter un chemin d'accès à vos modules : >>> os.sys.path.append('D:\\mon_projet\\mes_modules') Vérification : >>> print os.sys.path ['D:\\Program Files\\Developpement\\Python22\\Tools\\idle', 'D:\\Program Files\\Developpement\\Python22\\Tools\\idle', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\DLLs', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\lib', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\lib\\lib-tk', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\lib\\site-packages', 'D:\\mon_projet\\mes_modules'] (Voir aussi dans le fichier FILE de ILDE la rubrique PATH BROWSER)



LLaa ggeessttiioonn ddeess eerrrreeuurrss

Les exceptions Lorsqu'un comportement anormal survient, Python déclenche un mécanisme appelé exception. Une exception est typée : IndexError ValueError SyntaxError Les exceptions sont déclenchées par Python en cas d'erreur dans le code ou par vous. Dans les deux cas, la gestion de l'exception se fera par TRY. Quant RAISE, cette instruction va nous permettre de provoquer une exception.

Gérer une exception Gérer les exceptions : 2 variantes possibles.

•try : except : •try : finally :

Try: except: Grâce à l'instruction try, vous allez pouvoir intercepter l'erreur. Si une erreur survient, le code continue à s'exécuter dans la partie except, ce qui permet de protéger le code avec élégance. C'est l'interpréteur qui déclenche l'exception. Forme générale : Try : <instructions> except <nom> <instructions> except <nom>, <donnee> : #dans le cas ou nom est déclenché : récupère une donnée supplémentaire <instructions> else : <instructions>

Sans la gestion de l'erreur :

Nous créons une méthode à laquelle nous envoyons une liste et un index. Ensuite nous demandons d'imprimer l'élément n de la liste >>> def gaffe(liste, n): print liste[n] Appel de la méthode gaffe avec une liste de 4 éléments et un index de valeur 4 qui se trouve hors de la liste. D'où une erreur python. >>> gaffe([0,1,2,3], 4) Traceback (most recent call last): File "<pyshell#12>", line 1, in ? gaffe([0,1,2,3], 4) File "<pyshell#11>", line 2, in gaffe print liste[n] IndexError: list index out of range



Python lève IndexError et donne le traceback. Rupture du code.

Avec gestion de l'erreur :

>>> try: gaffe([0,1,2,3], 4) except IndexError: print 'Erreur !' Erreur ! Python lève l'erreur IndexError, que nous interceptons avec le try. L'erreur correspondant à except, le bloc d'instruction est exécuté. Le code peut alors continuer proprement.

Try : finally : L'autre variante de l'instruction TRY est une spécialisation et concerne les actions de terminaison. Si une clause FINALLY est utilisée dans un TRY, son bloc d'instructions est toujours exécuté "à la sortie" par Python, qu'une exception se soit produite ou non. Forme générale : try : <instrcutions> finally : <instructions>

Provoquer une exception Pour déclencher une exception, nous allons utiliser l'instruction RAISE. Deux manières de procéder :

•Déclencher une exception >>> raise <nom>

•Déclencher une exception et passer une donnée au déclencheur

>>> raise <nom>, <donnee> <nom> peut être une exception intégrée à Pyhton (exe IndexError) ou le nom d'un objet de type chaîne de caractères arbitraires que vous avez défini dans votre programme. Exemple : Créons une fonction f1 qui imprime un message. >>> def f1(): print 'fonction1' Créons ensuite une fonction f2 que nous n'avons pas le temps de développer et dans lequel nous allons lever une exception >>> def f2(): raise 'NotImplemented'



Créons enfin une troisième fonction qui appelle les deux précédente et exécutons là >>> def f3(): f1() f2() >>> f3() fonction1 Traceback (most recent call last): File "<pyshell#14>", line 1, in ? f3() File "<pyshell#13>", line 3, in f3 f2() File "<pyshell#9>", line 2, in f2 raise 'NotImplemented' NotImplemented La fonction 1 est bien exécutée. La fonction 2 retourne l'erreur levée. La gestion de raise trouve toute son importance dans l'utilisation des classes que nous verrons plus loin.



LLeess eennttrrééeess//ssoorrttiieess

Le chemin d'accès Par défaut Python travaille dans son répertoire courant. C'est là qu'il va chercher ou créer les fichiers que vous allez manipuler. Il est donc nécessaire de vouloir modifier le chemin de travaille de Python. Pour cela nous allons utiliser une méthode CHDIR issue du module OS. >>> from os import chdir >>> chdir("Disque:/chemin/repertoire_de_travail") exemple : >>> from os import chdir >>> chdir ("d:/temp") Python va maintenant travailler avec des fichiers se trouvant dans d:\temp

Les fichiers Un fichier est un containeur de stockage de données sur l'ordinateur géré par le système d'exploitation. Python manipule les fichiers quasiment comme le C le fait. Dans tous les cas le texte du fichier prend la forme de chaînes dans Python. Voici quelques manipulations sur les fichiers

Création d'un fichier Nous allons créer un fichier trappistes.txt dans le répertoire temp de la racine Pour cela, nous allons utiliser la méthode de fichier OPEN avec l'option w pour writing. Open attend deux paramètres : le nom du fichier et le mode d'opération 'w' pour écrire, 'r' pour lire, 'a' pour ajouter des infos !!! Vérifiez bien que le répertoire temp existe sinon, Python lève une erreur >>> trappe=open('/tmp/trappistes.txt', 'w') Traceback (most recent call last): File "<pyshell#82>", line 1, in ? trappe=open('/tmp/trappistes.txt', 'w') IOError: [Errno 2] No such file or directory: '/tmp/trappistes.txt'

Ecrire des données dans le fichier >>> trappe.write('chimay\n') Ecriture de chimay et passage à la ligne. !! Si à ce moment, vous visionnez le contenu du fichier trappistes.txt avec le notepad par exemple, vous n'y verrez rien. Il est indispensable de fermer le fichier.



Fermeture d'un fichier >>> trappe.close() Reprenez votre notepad et visionnez le contenu de votre fichier.

Ecrire le contenu d'une liste dans le fichier >>> liste=['chimay', 'orval', 'rochefort', 'westmalle', 'westvleteren'] >>> for i in liste: trappe.write(i+'\n') >>> trappe.close() Lorsque vous utilisez l'option 'w' avec open, il écrase le contenu du fichier et y écrit les nouvelles informations. Si vous désirez ajouter des infos, utilisez l'option 'a' pour append. La nouvelle info est alors stockée en fin de fichier >>> trappe=open('/temp/trappistes.txt', 'a') >>> trappe.write('trappiste') >>> trappe.close()

Lecture dans un fichier >>> trappe=open('/temp/trappistes.txt', 'r') Le fichier est maintenant ouvert en mode lecture 'r'. Trois méthodes sont à notre disposition pour lire les informations du fichier.

Lecture d'une ligne dans le fichier

>>> info=trappe.readline() >>> info 'chimay\n' info est de type chaîne. >>> type(info) <type 'str'> Remarquez qu'il affiche le caractère de retour de ligne \n Donc pour une chaîne 'propre' >>> info[:-1] 'chimay'

Lecture du fichier ligne par ligne dans une chaine

>>> info=trappe.readlines() >>> info ['orval\n', 'rochefort\n', 'westmalle\n', 'westvleteren\n', 'trappiste'] Remarquez qu'il commence à lire à la seconde ligne du fichier car la première a déjà été lue par notre instruction précédente. Nous pourrions utiliser l'image d'une tête de lecture qui s'arrête à l'endroit de la dernière information lue. Nous allons maintenant voir comment manipuler et positionner cette tête de lecture dans le fichier.



Lecture d'un bloc prédéfini d'octets

>>> info=trappe.read(15) >>> info 'chimay\norval\nro' Avec la méthode read(), vous pouvez entrer un nombre d'octets qui sont lus. Nous en verrons l'utilité dans un exemple ci-dessous sur la copie de deux fichiers. !!! Notez que le \n est considéré comme un seul octet.

Connaître la position de la 'tête de lecture' dans le fichier >>> trappe=open('/temp/trappistes.txt', 'r') >>> trappe.tell() 0L La méthode TELL indique où se situe la 'tête de lecture' après la dernière lecture et juste avant la suivante. Au moment de l'ouverture du fichier, la 'tête de lecture' est au début du fichier. Donc 0L. 'L' >> long integer : pas de limite dans le comptage Effectuons maintenant une lecture de ligne dans le fichier >>> info=trappe.readline() >>> info 'chimay\n' >>> trappe.tell() 8L La tête de lecture est en position 8. Remarquez qu'il prend en compte le traitement '\n' qui gère le retour à la ligne.

Positionner la 'tête de lecture' dans le fichier >>> trappe.seek(8) >>> trappe.tell() 8L La méthode SEEK positionne la tête de lecture à l'endroit où va débuter la prochaine lecture. Pour revenir en début de fichier : >>> trappe.seek(0) >>> trappe.tell() 0L

Exemple : copier des fichiers Il va de soi que les boucles de programmation s'imposent lorsque l'on doit traiter un fichier dont on ne connaît pas nécessairement le contenu à l'avance. L'idée de base consistera à lire ce fichier morceau par morceau, jusqu'à ce que l'on ait atteint la fin du fichier. La fonction ci-dessous illustre cette idée. Elle copie l'entièreté d'un fichier, quelle que soit sa taille, en transférant des portions de 50 octets à la fois :



01. def copieFichier(source, destination): 02. fs = open(source, 'r') 03. fd = open(destination, 'w') 04. while 1: 05. txt = fs.read(50) 06. if txt =="": 07. break 08. fd.write(txt) 09. fs.close() 10. fd.close() 11. return 12. if __name__=="__main__": 13. import sys 14. source=sys.argv[1] 15. destination=sys.argv[2] 16. copieFichier(source, destination) 01. déclaration de la fonction 02. ouverture en mode lecture du fichier source dont le chemin et le nom sont passés en

paramètres 03. ouverture en mode écriture du fichier destination dont le chemin et le nom sont passés en

paramètres. (Si le fichier n'existe pas, il est créé). 04. boucle while toujours vraie 05. lecture du fichier source par bloc de 50 caractères 06. test sur le contenu de txt. Si == "", fin du fichier donc… 07. break : sortie de la boucle while. 08. écriture du bloc de texte qui vient d'être lu. 09. le fichier source est fermé. 10. le fichier de destination est fermé. 11. return vers l'appelant. Pas nécessaire. 12. lors de l'appel du module cette instruction permet l'exécution du module.(Code d'autotest). 13. appel de la méthode avec passage des arguments. 14. importation du module sys. 15. la variable source est affectée par le premier argument passé lors de l'appel du module :

chemin+nom du fichier. 16. la variable destination est affectée par le second argument passé lors de l'appel du module:

chemin + nom du fichier. 17. appel de la méthode avec passage des arguments. Dans votre console DOS tapez par exemple : D:\Projet\Aragne\cours_python\exercices>python copieFichier.py d:\temp\trappiste s.txt d:\biere.txt python >>> Appel de python. copieFichier.py >>> Appel du module copierFichier.py. d:\temp\trappiste s.txt >>> Passage du paramètre pour le fichier source. d:\biere.txt >>> Passage du paramètre pour le fichier destination.



Enregistrement et restitution de variables au format divers : PICKLE L'argument de la méthode write() doit être une chaîne de caractères. Avec ce que nous avons appris jusqu'à présent, nous ne pouvons donc enregistrer d'autres types de valeurs qu'en les transformant d'abord en chaînes de caractères. Nous pouvons réaliser cela à l'aide de la fonction intégrée str() : >>> x = 52 >>> f=open('/temp/variables.txt', 'w') >>> f.write(str(x)) >>> f.close() Si nous enregistrons les valeurs numériques en les transformant d'abord en chaînes de caractères, nous risquons de ne plus pouvoir les re-transformer correctement en valeurs numériques lorsque nous allons relire le fichier. Exemple : Créons trois variables numériques et écrivons les dans un fichier. >>> a = 5 >>> b = 2.83 >>> c = 67 >>> f = open('/temp/varaibles.txt', 'w') >>> f.write(str(a)) >>> f.write(str(b)) >>> f.write(str(c)) >>> f.close() Maintenant ouvrons notre fichier et relisons nos variables. >>> f = open('/temp/variables.txt', 'r') >>> print f.read() 52.8367 >>> f.close() Nous avons enregistré trois valeurs numériques. Mais comment pouvons-nous les distinguer dans la chaîne de caractères résultante, lorsque nous effectuons la lecture du fichier ? C'est impossible ! Rien ne nous indique d'ailleurs qu'il y a là trois valeurs plutôt qu'une seule, ou 2, ou 4, ... Il existe plusieurs solutions à ce genre de problèmes. L'une des meilleures consiste à importer un module Python spécialisé : le module pickle 38 . Voici comment il s'utilise : >>> import pickle >>> a=2 >>> b=345.456 >>> c=123.25 >>> f = open('/temp/variables.txt', 'w') >>> pickle.dump(a, f) >>> pickle.dump(b, f)



>>> pickle.dump(c, f) >>> f.close() >>> f = open('/temp/variables.txt', 'r') >>> t = pickle.load(f) >>> print t, type(t) 2 <type 'int'> >>> t = pickle.load(f) >>> print t, type(t) 345.456 <type 'float'> >>> t = pickle.load(f) >>> print t, type(t) 123.25 <type 'float'> >>> f.close() Nous constatons que les variables gardent leur type de départ. La fonction dump() du module pickle attend deux arguments : le premier est la variable à enregistrer, le second est l'objet fichier dans lequel on travaille. La fonction pickle.load() effectue le travail inverse, c.à.d. la restitution de chaque variable avec son type. Visionnez le contenu de votre fichier variables.txt avec le notepad : Nous constatons que l'objet est sauvé avec son type.

Fig 08.



FFiilltteerr -- RReedduuccee

Filter

Filter(fonction, liste) prend deux paramètres: une fonction et une liste. Il applique la fonction à chaque élément de la liste et retourne une liste contenant les objets pour lesquels la fonction a évalué l'objet à VRAI. un exemple: >>> ma_liste = [1,2,3,4,5,6,7,8,9] >>> def ma_func(lst): >>> return lst < 4 >>> print filter(ma_func, ma_liste) [1,2,3] Si on passe None comme fonction à filter, il retourne les objets non nul. Pour rappel, les objets nuls sont l'objet None, les chaînes de caractères vides, zéro et les (listes, dictionnaires et tuples) vides. >>> ma_liste = ["tutu", "", 1, 0, ['une', 'autre', 'liste'], None, []] >>> print filter(none, ma_liste) ['tutu', 1, ['une ', 'autre', 'liste']] "" string évaluée à faux [] liste évaluée à faux

Reduce Reduce(fonction, sequence [,initialiseur]) applique une fonction de deux arguments cumulativement aux éléments d'une séquence de la gauche vers la droite jusqu'à réduire la séquence à un seul élément. (Résultat + élément suivant de la liste) Exemple: comment joindre une liste de répertoires en un chemin alors que os.path.join ne prend que deux arguments ? >>> import os >>> liste_de_repertoires = ['usr', 'lib', 'python', 'distutils'] >>> print reduce(os.path.join, liste_de_repertoires) /usr/lib/python/distutils



CCllaasssseess,, oobbjjeettss,, aattttrriibbuuttss Les chapitres précédents vous ont déjà mis en contact à plusieurs reprises avec la notion d'objet. Vous savez donc déjà qu'un objet est toujours construit par instanciation à partir d'une classe (c.à.d. en quelque sorte une "catégorie" ou un "type" d'objet). Nous allons à présent examiner comment vous pouvez vous-mêmes définir de nouvelles classes d'objets. Il s'agit là d'un sujet relativement ardu, mais vous l'aborderez de manière très progressive, en commençant par définir des classes d'objets très simples, que vous perfectionnerez ensuite. Attendez-vous cependant à rencontrer des objets de plus en plus complexes par après. Comme les objets de la vie courante, les objets informatiques peuvent être très simples ou très compliqués. Ils peuvent être composés de différentes parties, qui sont elles-mêmes des objets, ceux-ci étant faits à leur tour d'autres objets plus simples, etc.

Utilité des classes Les classes sont les principaux outils de la programmation orientée objet (Object Oriented Programming ou OOP). Ce type de programmation permet de structurer les logiciels complexes en les organisant comme des ensembles d'objets qui interagissent, entre eux et avec le monde extérieur. Le premier bénéfice de cette approche de la programmation consiste dans le fait que les différents objets utilisés peuvent être construits indépendamment les uns des autres (par exemple par des programmeurs différents) sans qu'il n'y ait de risque d'interférence. Ce résultat est obtenu grâce au concept d'encapsulation : la fonctionnalité interne de l'objet et les variables qu'il utilise pour effectuer son travail, sont en quelque sorte "enfermés" dans l'objet. Les autres objets et le monde extérieur ne peuvent y avoir accès qu'à travers des procédures bien définies. Plus concrètement, l'utilisation de classes dans vos programmes vous permettra (entre autres choses) d'éviter au maximum l'emploi de variables globales. Vous devez savoir en effet que l'utilisation de variables globales comporte des risques, surtout dans les programmes volumineux, parce qu'il est toujours possible que de telles variables soient modifiées ou même redéfinies n'importe où dans le corps du programme (et ce risque s'aggrave particulièrement si plusieurs programmeurs différents travaillent sur un même logiciel). Un second bénéfice résultant de l'utilisation des classes est la possibilité qu'elles offrent de construire de nouveaux objets à partir d'objets préexistants, et donc de réutiliser des pans entiers d'une programmation déjà écrite (sans toucher à celle-ci !), pour en tirer une fonctionnalité nouvelle. Cela est rendu possible grâce au concept de dérivation.



La dérivation C' est le mécanisme qui permet de construire une classe "enfant" au départ d'une classe "parente". L'enfant ainsi obtenu hérite de toutes les propriétés et de toute la fonctionnalité de son ancêtre, auxquelles on peut ajouter ce que l'on veut. La programmation orientée objet est optionnelle sous Python. Vous pouvez donc mener à bien de nombreux projets sans l'utiliser, avec des outils plus simples tels que les fonctions. Sachez cependant que les classes constituent des outils pratiques et puissants.

Définition d'une classe élémentaire Pour créer une nouvelle classe d'objets Python, on utilise l'instruction class. Nous allons donc apprendre à utiliser cette instruction, en commençant par définir un type d'objet très rudimentaire, lequel sera simplement un nouveau type de donnée. Nous avons déjà utilisé différents types de données jusqu'à présent, mais c'était à chaque fois des types intégrés dans le langage lui-même. De manière très simple, il faut considérer la classe comme une fabrique à objet. Ces objets seront manipulés par le biais de leurs atrributs et de leurs méthodes. Nous allons maintenant créer un nouveau type composite : le type Point. Ce type correspondra au concept de point en Mathématique. Dans un espace à deux dimensions, un point est caractérisé par deux nombres (ses coordonnées x et y). On parlera par exemple du point (25,17). Une manière naturelle de représenter un point sous Python serait d'utiliser pour les coordonnées deux valeurs de type float. Nous voudrions cependant combiner ces deux valeurs dans une seule entité, ou un seul objet. Pour y arriver, nous allons définir une classe Point() : >>> class Point: "Définition d'un point mathématique" Les définitions de classes peuvent être situées n'importe où dans un programme, mais on les placera en général au début (ou bien dans un module à importer). L'exemple ci-dessus est probablement le plus simple qui se puisse concevoir. Une seule ligne nous a suffi pour définir le nouveau type d'objet Point(). Remarquons d'emblée que :

•L'instruction class est un nouvel exemple d'instruction composée. N'oubliez pas le double point : obligatoire à la fin de la ligne, et l'indentation du bloc d'instructions qui suit. Ce bloc doit contenir au moins une ligne. Dans notre exemple ultra-simplifié, cette ligne n'est rien d'autre qu'un simple commentaire, la string de documentation de la classe (Par convention, si la première ligne suivant l'instruction class est une chaîne de caractères, celle-ci pourra être



incorporée automatiquement dans un dispositif de documentation des classes qui fait partie intégrante de Python. Prenez donc l'habitude de toujours placer une chaîne décrivant la classe à cet endroit. Faites de même pour les fonctions. (Voir le chapitre : Les chaînes __doc__ : documentez votre code. P.71)

•Rappelez-vous aussi la convention qui consiste à toujours donner aux classes des noms qui commencent par une majuscule. Dans la suite de ce texte, nous respecterons encore une autre convention qui consiste à associer à chaque nom de classe une paire de parenthèses, comme nous le faisons déjà pour les noms de fonctions.

Nous venons de définir une classe Point(). Nous pouvons dès à présent nous en servir pour créer des objets de ce type, par instanciation. Créons par exemple un nouvel objet p1: >>> p1 = Point() Après cette instruction, la variable p1 contient la référence d'un nouvel objet Point(). Nous pouvons dire également que p1 est une nouvelle instance de la classe Point(). Attention : comme les fonctions, les classes auxquelles on fait appel dans une instruction doivent toujours être accompagnées de parenthèses (même si aucun argument n'est transmis). Nous verrons un peu plus loin que les classes peuvent être appelées avec des arguments.

Attributs (ou variables) d'instance L'objet que nous venons de créer est une coquille vide. Nous pouvons ajouter des composants à cet objet par simple assignation, en utilisant le système de qualification des noms par points: >>> p1.x = 3.0 >>> p1.y = 4.0 Les variables ainsi définies sont des attributs de l'objet p1, ou encore des variables d'instance. Elles sont incorporées, ou plutôt encapsulées dans l'objet. Le diagramme d'état ci-dessous montre le résultat de ces affectations : la variable p1 contient la référence indiquant l'emplacement mémoire du nouvel objet, qui contient lui-même les deux attributs x et y.

On peut utiliser les attributs d'un objet dans n'importe quelle expression, comme toutes les variables ordinaires :



>>> print p1.x 3.0 >>> print p1.x**2 + p1.y**2 25.0 Du fait de leur encapsulation dans l'objet, les attributs sont des variables distinctes d'autres variables qui pourraient porter le même nom. Par exemple, l'instruction x = p1.x signifie : "extraire de l'objet référencé par p1 la valeur de son attribut x, et assigner cette valeur à la variable x". Il n'y a pas de conflit entre la variable x et l'attribut x de l'objet p1. L'objet p1 contient en effet son propre espace de noms, indépendant de l'espace de nom principal où se trouve la variable x. Que se passe-t-il si nous essayons d'afficher l'instance elle-même ? >>> print p1 <__main__.Point instance at 00B1C64C> Ceci indique, comme vous l'aurez certainement bien compris tout de suite, que p1 est une instance de la classe Point() et qu'elle est définie au niveau principal du programme. Elle a reçu de Python un identifiant unique, qui apparaît ici en notation hexadécimale. !!! Remarque importante : Nous venons de voir qu'il est très aisé d'ajouter un attribut à un objet en utilisant une simple instruction d'assignation telle que p1.x = 3.0 On peut se permettre cela sous Python (c'est une conséquence de l'assignation dynamique des variables), mais cela n'est pas vraiment recommandable, comme vous le comprendrez plus loin. Nous n'utiliserons donc cette façon de faire que de manière occasionnelle, et uniquement dans le but de simplifier nos explications concernant les attributs d'instances. La bonne manière de procéder sera développée dans le chapitre suivant.

Passage d'objets comme arguments lors de l'appel d'une fonction Les fonctions peuvent utiliser des objets comme paramètres (elles peuvent également fournir un objet comme valeur de retour). Par exemple, vous pouvez définir une fonction telle que celle-ci : >>> def affiche_point(p): print "coord. horizontale =", p.x, "coord. verticale =", p.y Le paramètre p utilisé par cette fonction doit être un objet de type Point(), puisque l'instruction qui suit utilise les variables d'instance p.x et p.y. Lorsqu'on appelle cette fonction, il faut donc lui fournir un objet de type Point() comme argument. Essayons avec l'objet p1 : >>> affiche_point(p1) coord. horizontale = 3.0 coord. verticale = 4.0



Similitude et unicité Dans la langue parlée, les mêmes mots peuvent avoir des significations fort différentes suivant le contexte dans lequel on les utilise. La conséquence en est que certaines expressions utilisant ces mots peuvent être comprises de plusieurs manières différentes (expressions ambiguës). Le mot "même", par exemple, a des significations différentes dans les phrases : "Charles et moi avons la même voiture" et "Charles et moi avons la même mère". Dans la première, ce que je veux dire est que la voiture de Charles et la mienne sont du même modèle. Il s'agit pourtant de deux voitures distinctes. Dans la seconde, j'indique que la mère de Charles et la mienne constituent en fait une seule et unique personne. Lorsque nous traitons d'objets logiciels, nous pouvons rencontrer la même ambiguïté. Par exemple, si nous parlons de l'égalité de deux objets Point(), cela signifie-t-il que ces deux objets contiennent les mêmes données (leurs attributs), ou bien cela signifie-t-il que nous parlons de deux références à un même et unique objet ? Considérez par exemple les instructions suivantes : >>> p1 = Point() >>> p1.x = 3 >>> p1.y = 4 >>> p2 = Point() >>> p2.x = 3 >>> p2.y = 4 >>> print (p1 == p2) 0 Ces instructions créent deux objets p1 et p2 qui restent distincts, même s'ils ont des contenus similaires. La dernière instruction teste l'égalité de ces deux objets (double signe égale), et le résultat est zéro ce qui signifie que l'expression entre parenthèses est fausse : il n'y a donc pas égalité. On peut confirmer cela d'une autre manière encore : >>> print p1 <__main__.Point instance at 00C2CBEC> >>> print p2 <__main__.Point instance at 00C50F9C> L'information est claire : les deux variables p1 et p2 référencent bien des objets différents. Essayons autre chose, à présent : >>> p2 = p1 >>> print (p1 == p2) 1 Par l'instruction p2 = p1, nous assignons le contenu de p1 à p2. Cela signifie que désormais ces deux variables référencent le même objet. Les variables p1 et p2 sont



des alias l'une de l'autre. Le test d'égalité dans l'instruction suivante retourne cette fois la valeur 1, ce qui signifie que l'expression entre parenthèses est vraie : p1 et p2 désignent bien toutes deux un seul et unique objet, comme on peut s'en convaincre en essayant encore : >>> p1.x = 7 >>> print p2.x 7 >>> print p1 <__main__.Point instance at 00C2CBEC> >>> print p2 <__main__.Point instance at 00C2CBEC>

Objets composés d'objets Supposons maintenant que nous voulions définir une classe pour représenter des rectangles. Pour simplifier, nous allons considérer que ces rectangles seront toujours orientés horizontalement ou verticalement, et jamais en oblique. De quelles informations avons-nous besoin pour définir de tels rectangles ? Il existe plusieurs possibilités. Nous pourrions par exemple spécifier

• la position du centre du rectangle (deux coordonnées) et préciser sa taille (largeur et hauteur). • les positions du coin supérieur gauche et du coin inférieur droit. • la position du coin supérieur gauche et la taille.

Admettons ce soit cette dernière méthode qui soit retenue. Définissons donc notre nouvelle classe : >>> class Rectangle: "définition d'une classe de rectangles" ... et servons nous-en tout de suite pour créer une instance : >>> boite = Rectangle() >>> boite.largeur = 50.0 >>> boite.hauteur = 35.0 Nous créons ainsi un nouvel objet Rectangle() et deux attributs. Pour spécifier le coin supérieur gauche, nous allons utiliser une instance de la classe Point() que nous avons définie précédemment. Ainsi nous allons créer un objet à l'intérieur d'un autre objet ! >>> boite.coin = Point() >>> boite.coin.x = 12.0 >>> boite.coin.y = 27.0 Pour accéder à un objet qui se trouve à l'intérieur d'un autre objet, on utilise la qualification des noms hiérarchisée (à l'aide de points) que nous avons déjà rencontrée à plusieurs reprises. Ainsi l'expression boite.coin.y signifie "Aller à l'objet



référencé dans la variable boite. Dans cet objet, repérer l'attribut coin, puis aller à l'objet référencé dans cet attribut. Une fois cet autre objet trouvé, sélectionner son attribut y." Vous pourrez peut-être mieux vous représenter à l'avenir les objets composites, à l'aide de diagrammes similaires à celui que nous reproduisons ci-dessous :

Objets comme valeurs de retour d'une fonction Nous avons vu plus haut que les fonctions peuvent utiliser des objets comme paramètres. Elles peuvent également transmettre une instance comme valeur de retour. Par exemple, la fonction trouveCentre() ci-dessous doit être appelée avec un argument de type Rectangle() et retourne un objet Point(), lequel contiendra les coordonnées du centre du rectangle. >>> def trouveCentre(box): p = Point() p.x = box.coin.x + box.largeur/2.0 p.y = box.coin.y + box.hauteur/2.0 return p Pour appeler cette fonction, vous pouvez utiliser l'objet boite comme argument : >>> centre = trouveCentre(boite) >>> print centre.x, centre.y 37.0 44.5

Les objets sont modifiables Nous pouvons changer les propriétés d'un objet en assignant de nouvelles valeurs à ses attributs. Par exemple, nous pouvons modifier la taille d'un rectangle (sans modifier sa position), en réassignant ses attributs hauteur et largeur : >>> boite.hauteur = boite.hauteur + 20 >>> boite.largeur = boite.largeur – 5 Nous pouvons faire cela sous Python, parce que dans ce langage les propriétés des objets sont toujours publiques. D'autres langages établissent une distinction nette entre attributs publics (accessibles de l'extérieur de l'objet) et attributs privés (qui sont accessibles seulement aux algorithmes inclus dans l'objet lui-même).



Comme nous l'avons déjà signalé plus haut (à propos de la définition des attributs par assignation simple, depuis l'extérieur de l'objet), modifier de cette façon les attributs d'une instance n'est pas une pratique recommandable, parce qu'elle contredit l'un des objectifs fondamentaux de la programmation orientée objet, qui vise à établir une séparation stricte entre la fonctionnalité d'un objet (telle qu'elle a été déclarée au monde extérieur) et la manière dont cette fonctionnalité est réellement implémentée dans l'objet (et que le monde extérieur n'a pas à connaître). Plus concrètement, nous devrons veiller désormais à ce que les objets que nous créons ne soient modifiables en principe que par l'intermédiaire de méthodes mises en place spécifiquement dans ce but, comme nous allons l'expliquer dans le chapitre suivant.



CCllaasssseess,, mméétthhooddeess,, hhéérriittaaggee Les classes que nous avons définies dans le chapitre précédent ne sont finalement rien d'autre que des espaces de noms particuliers, dans lesquels nous n'avons placé jusqu'ici que des variables (les attributs d'instance). Il nous faut à présent doter ces classes d'une fonctionnalité. L'idée de base de la programmation orientée objet consiste en effet à regrouper dans un même ensemble (l'objet) à la fois un certain nombre de données (ce sont les variables ou attributs d'instance) et les algorithmes destinés à effectuer divers traitements sur ces données (ce sont les méthodes, c.à.d. des fonctions encapsulées). Objet = [ attributs + méthodes ] Cette façon d'associer dans une même "capsule" les propriétés d'un objet et les fonctions qui permettent d'agir sur elles, correspond chez les concepteurs de programmes à une volonté de construire des entités informatiques dont le comportement se rapproche du comportement des objets du monde réel qui nous entoure.

Définition d'une méthode Pour illustrer notre propos, nous allons définir une nouvelle classe Horaire, qui nous permettra d'effectuer toute une série d'opérations sur des instants, des durées, etc. : >>> class Horaire: "Définition d'une classe temporelle pour l'horaire de la journee" Créons à présent un objet de ce type, et ajoutons-lui des variables d'instance pour mémoriser les heures, minutes et secondes : >>> instant = Horaire() >>> instant.heure = 11 >>> instant.minute = 34 >>> instant.seconde = 25 A titre d'exercice, écrivez maintenant vous-même une fonction affiche_heure() , qui serve à visualiser le contenu d'un objet de classe Horaire() sous la forme conventionnelle "heure:minute:seconde". Appliquée à l'objet instant créé ci-dessus, cette fonction devrait donc afficher 11:34:25 : >>> print affiche_heure(instant) 11:34:25 Votre fonction ressemblera probablement à ceci : >>> def affiche_heure(t): print str(t.heure) + ":" + str(t.minute) + ":" + str(t.seconde) Si par la suite vous utilisez fréquemment des objets de la classe Horaire(),il y a gros à



parier que cette fonction d'affichage vous sera fréquemment utile. Il serait donc probablement fort judicieux d'encapsuler cette fonction affiche_heure() dans la classe Horaire() elle-même, de manière à s'assurer qu'elle soit toujours automatiquement disponible chaque fois que l'on devra manipuler des objets de la classe Horaire(). Une fonction qui est ainsi encapsulée dans une classe s'appelle une méthode. Vous avez déjà rencontré des méthodes à de nombreuses reprises (et vous savez donc déjà qu'une méthode est bien une fonction associée à une classe d'objets). Définition concrète d'une méthode : On définit une méthode comme on définit une fonction, avec cependant deux différences :

•La définition d'une méthode doit être placée à l'intérieur de la définition d'une classe, de manière à ce que la relation qui lie la méthode à la classe soit clairement établie. •Le premier paramètre utilisé par une méthode doit toujours être (par convention) le mot "self". Ce mot désigne l'instance à laquelle la méthode sera associée, dans les instructions faisant partie de la définition. (La définition d'une méthode comporte donc toujours au moins un paramètre, alors que la définition d'une fonction peut n'en comporter aucun).

Voyons comment cela se passe en pratique : Pour réécrire la fonction affiche_heure() comme une méthode de la classe Horaire(), il nous suffit de déplacer sa définition à l'intérieur de celle de la classe, et de changer le nom de son paramètre : >>> class Horaire: "Nouvelle classe temporelle pour l'horaire de la journee " def affiche_heure(self): print str(self.heure) + ":" + str(self.minute) + ":" + str(self.seconde) La définition de la méthode fait maintenant partie du bloc d'instructions indentées après l'instruction class. Notez bien l'utilisation du mot réservé self , qui se réfère donc à toute instance susceptible d'être créée à partir de cette classe. Essai de la méthode dans une instance : Nous pouvons dès à présent instancier un objet de notre nouvelle classe Horaire() : >>> maintenant = Horaire() Si nous essayons d'utiliser un peu trop vite notre nouvelle méthode, ça ne marche pas: >>> maintenant.affiche_heure() AttributeError: 'Horaire' instance has no attribute 'heure'



C'est normal : nous n'avons pas encore créé les attributs d'instance. Il faudrait faire par exemple : >>> maintenant.heure = 13 >>> maintenant.minute = 34 >>> maintenant.seconde = 21 >>> maintenant.affiche_heure() 13:34:21 Nous avons déjà signalé au chapitre précédent qu'il n'est pas recommandable de créer les attributs d'instance en dehors de l'objet lui-même, ce qui conduit (entre autres désagréments) à des erreurs comme celles que nous venons de rencontrer. Voyons donc à présent comment nous pouvons mieux faire.

La méthode "constructeur" L'erreur que nous avons rencontrée au paragraphe précédent n'est pas très plaisante. Il serait de loin préférable que la méthode affiche_heure() puisse toujours afficher quelque chose, même si nous n'avons encore fait aucune manipulation sur l'objet nouvellement créé. En d'autres termes, il serait judicieux que les variables d'instance soient prédéfinies elles aussi à l'intérieur de la classe, avec de préférence pour chacune d'elles une valeur "par défaut". Pour obtenir cela, nous allons faire appel à une méthode particulière, que Python exécutera automatiquement lors de l'instanciation d'un objet à partir de sa classe. Une telle méthode est souvent appelée un constructeur. On peut y placer tout ce qui semble nécessaire pour initialiser automatiquement l'objet que l'on crée. Sous Python, une méthode est automatiquement reconnue comme un constructeur si on lui donne le nom réservé __init__ (deux caractères "souligné", le mot init, puis encore deux caractères "souligné"). Exemple : >>> class Horaire: "Encore une nouvelle classe temporelle pour l'horaire de la journee " def __init__(self): self.heure =0 self.minute =0 self.seconde =0 def affiche_heure(self): print str(self.heure) + ":" + str(self.minute) + ":" + str(self.seconde) >>> tstart = Horaire() >>> tstart.affiche_heure() 0:0:0 L'intérêt de cette technique apparaîtra plus clairement si nous ajoutons encore quelque chose. Comme toute méthode qui se respecte, la méthode __init__() peut être dotée de



paramètres. Ceux-ci vont jouer un rôle important, parce qu'ils vont permettre d'instancier un objet et d'initialiser certaines de ses variables d'instance, en une seule opération. Dans l'exemple ci-dessus, veuillez donc modifier la définition de la méthode __init__() comme suit : def __init__(self, hh=0, mm=0, ss=0): self.heure = hh self.minute = mm self.seconde = ss Les arguments qui seront transmis à la méthode __init__() sont ceux que nous placerons dans les parenthèses qui accompagnent le nom de la classe, dans l'instruction d'instanciation. Voici par exemple la création et l'initialisation simultanées d'un nouvel objet Horaire() : >>> recreation = Horaire(10, 15, 18) >>> recreation.affiche_heure() 10:15:18 Puisque les variables d'instance possèdent maintenant des valeurs par défaut, nous pouvons aussi créer de tels objets Horaire() en omettant un ou plusieurs arguments : >>> rentree = Horaire(10, 30) >>> rentree.affiche_heure() 10:30:0

La méthode __str__ La méthode __str__ traite la manière dont l'objet va se présenter si nous le manipulons comme une chaine. Reprenons notre classe et ajoutons lui une méthode __str__ class Horaire:

"classe temporelle pour la realisation d'un horaire" def __init__(self, hh=0, mm=0, ss=0):

self.heure=hh self.minute=mm self.seconde=ss

def affiche_heure(self):

print str(self.heure) + ":" + str(self.minute) + ":" + str(self.seconde)

def __str__(self): return('Horaire ' + str(self.heure) + ':' + str(self.minute) + ':' +

str(self.seconde)) Instancions notre classe dans un nouvel objet h h=Horaire(10,20,00) Imprimons l'objet h et c'est __str__ qui entre en action. >>> print h Horaire 10:20:0



Espaces de noms des classes et instances Les variables définies à l'intérieur d'une fonction sont des variables locales, inaccessibles aux instructions qui se trouvent à l'extérieur de la fonction. Cela vous permet d'utiliser les mêmes noms de variables dans différentes parties d'un programme, sans risque d'interférence. Pour décrire la même chose en d'autres termes, nous pouvons dire que chaque fonction possède son propre espace de noms, indépendant de l'espace de noms principal. Les instructions se trouvant à l'intérieur d'une fonction peuvent accéder aux variables définies au niveau principal, mais en lecture seulement : elles peuvent utiliser les valeurs de ces variables, mais pas les modifier (à moins de faire appel à l'instruction global). Il existe donc une sorte de hiérarchie entre les espaces de noms. Nous allons constater la même chose à propos des classes et des objets. En effet :

•chaque classe possède son propre espace de noms. Les variables qui en font partie sont appelées les attributs de la classe. •chaque objet instance (créé à partir d'une classe) obtient son propre espace de noms. Les variables qui en font partie sont appelées variables d'instance ou attributs d'instance. • les classes peuvent utiliser (mais pas modifier) les variables définies au niveau principal. • les instances peuvent utiliser (mais pas modifier) les variables définies au niveau de la classe et les variables définies au niveau principal.

Considérons par exemple la classe Horaire() définie plus haut. A la fin de la page précédente, nous avons instancié deux objets de cette classe : recreation et rentree. Chacun a été initialisé avec des valeurs différentes, indépendantes. Nous pouvons modifier et réafficher ces valeurs à volonté dans chacun de ces deux objets sans que l'autre n'en soit affecté : >>> recreation.heure = 12 >>> rentree.affiche_heure() 10:30:0 >>> recreation.affiche_heure() 12:15:18 Veuillez à présent encoder et tester l'exemple ci-dessous : 01. >>> class Espaces: 02. ma_var = 33 03. def affiche(self): 04. print ma_var, Espaces.ma_var, self.ma_var 05. >>> ma_var = 12 06. >>> essai = Espaces() 07. >>> essai. ma_var = 67



09. >>> essai.affiche() 12 33 67 10. >>> print ma_var, Espaces. ma_var, essai. ma_var 12 33 67 Dans cet exemple, le même nom ma_var est utilisé pour définir trois variables différentes : 02. une dans l'espace de noms de la classe, 05. une autre dans l'espace de noms principal 07. une dernière dans l'espace de nom de l'instance. 04. comment accéder à ces trois espaces de noms de l'intérieur d'une classe en utilisant la qualification par points. 09. comment accéder à ces trois espaces de noms au niveau principal, en utilisant la qualification par points. Notez encore une fois l'utilisation de self pour désigner l'instance.

Héritage Les classes constituent le principal outil de la programmation orientée objet (Object Oriented Programming ou OOP), qui est considérée de nos jours comme la technique de programmation la plus performante. L'un des principaux atouts de ce type de programmation réside dans le fait que l'on peut toujours se servir d'une classe préexistante pour en créer une nouvelle qui possédera quelques fonctionnalités supplémentaires. Le procédé s'appelle dérivation. Il permet de créer toute une hiérarchie de classes allant du général au particulier. Nous pouvons par exemple définir une classe Mammifere(), qui contiendra un ensemble de caractéristiques propres à ce type d'animal. A partir de cette classe, nous pourrons alors dériver une classe Primate(), une classe Rongeur(), une classe Carnivore(), etc., qui hériteront de toutes les caractéristiques de la classe Mammifere(), en y ajoutant leurs propres spécificités. Au départ de la classe Carnivore(), nous pourrons ensuite dériver une classe Belette(), une classe Loup(), une classe Chien(), etc., qui hériteront encore une fois de toutes les caractéristiques de la classe parente avant d'y ajouter les leurs. Exemple : >>> class Mammifere: caract1 = "il allaite ses petits ;" >>> class Carnivore(Mammifere): caract2 = "il se nourrit de la chair de ses proies ;" >>> class Chien(Carnivore): caract3 = "son cri s'appelle aboiement ;" >>> mirza = Chien() >>> print mirza.caract1, mirza.caract2, mirza.caract3 il allaite ses petits ; il se nourrit de la chair de ses proies ;



son cri s'appelle aboiement ; Dans cet exemple, nous voyons que l'objet mirza , qui est une instance de la classe Chien(), hérite non seulement de l'attribut défini pour cette classe, mais également des attributs définis pour les classes parentes. Vous voyez également dans cet exemple comment procéder pour dériver une classe à partir d'une classe parente : on utilise l'instruction class , suivie comme d'habitude du nom que l'on veut attribuer à la nouvelle classe, et on place entre parenthèses le nom de la classe parente. Notez bien que les attributs utilisés dans cet exemple sont des attributs des classes (et non des attributs d'instances). L'instance mirza peut accéder à ces attributs, mais pas les modifier : 01. >>> mirza.caract2 = "son corps est couvert de poils" 02. >>> print mirza.caract2 03. son corps est couvert de poils 04. >>> fido = Chien() 05. >>> print fido.caract2 06. il se nourrit de la chair de ses proies ; 01. l'attribut caract2 de la classe Carnivore() n'est pas modifié comme on pourrait le croire à la lecture de la ligne 03.

04 à 06 Nous pouvons le vérifier en créant une nouvelle instance fido. Si vous avez bien assimilé les paragraphes précédents, vous aurez compris que l'instruction de la ligne 01 crée une nouvelle variable d'instance associée seulement à l'objet mirza. Il existe donc dès ce moment deux variables avec le même nom caract2 : l'une dans l'espace de noms de l'objet mirza, et l'autre dans l'espace de noms de la classe Carnivore(). Comment faut-il alors interpréter ce qui s'est passé aux lignes 02 et 03 ? Comme nous l'avons vu plus haut, l'instance mirza peut accéder aux variables situées dans son propre espace de noms, mais aussi à celles qui sont situées dans les espaces de noms de toutes les classes parentes. S'il existe des variables aux noms identiques dans plusieurs de ces espaces, laquelle sera-t-elle sélectionnée lors de l'exécution d'une instruction comme celle de la ligne 02 ? Pour résoudre ce conflit, Python respecte une règle de priorité fort simple. Lorsqu'on lui demande d'utiliser la valeur d'une variable nommée alpha, par exemple, il commence par rechercher ce nom dans l'espace local (le plus "interne", en quelque sorte). Si une variable alpha est trouvée dans l'espace local, c'est celle-là qui est utilisée, et la recherche s'arrête. Sinon, Python examine l'espace de noms de la structure parente, puis celui de la structure grand-parente, et ainsi de suite jusqu'au niveau principal du programme. A la ligne 02 de notre exemple, c'est donc la variable d'instance qui sera utilisée. A la ligne 05, par contre, c'est seulement au niveau de la classe grand-parente qu'une variable répondant au nom caract2 peut être trouvée. C'est donc celle-là qui est



affichée.

Modules contenant des librairies de classes Les modules Python servent à regrouper des librairies de classes et de fonctions. A titre d'exercice de révision, vous allez encoder les lignes d'instruction ci-dessous dans un module (c.à.d. un fichier) que vous nommerez formes.py Nous en profiterons également pour revoir la technique de formatage des chaînes class Rectangle: "Classe de rectangles" def __init__(self, longueur =30, largeur =15): self.L = longueur self.l = largeur self.nom = "rectangle" def perimetre(self): return "(%s + %s) * 2 = %s" % (self.L, self.l,(self.L + self.l)*2) def surface(self): return "%s * %s = %s" % (self.L, self.l, self.L*self.l) def mesures(self): print "Un %s de %s sur %s" % (self.nom, self.L, self.l) print "a une surface de %s" % (self.surface(),) print "et un périmètre de %s\n" % (self.perimetre(),) class Carre(Rectangle): "Classe de carrés" def __init__(self, cote =10): Rectangle.__init__(self, cote, cote) self.nom ="carré" if __name__ == "__main__": r1 = Rectangle(15, 30) r1.mesures() c1 = Carre(13) c1.mesures() Une fois ce module enregistré, vous pouvez l'utiliser de deux manières :

•vous en lancez l'exécution comme celle d'un programme ordinaire, •vous l'importez dans un script quelconque ou depuis la ligne de commande, pour en utiliser les classes :

>>> import formes >>> f1 = formes.Rectangle(27, 12) >>> f1.mesures() Un rectangle de 27 sur 12 a une surface de 27 * 12 = 324 et un périmètre de (27 + 12) * 2 = 78 >>> f2 = formes.Carre(13) >>> f2.mesures()



Un carré de 13 sur 13 a une surface de 13 * 13 = 169 et un périmètre de (13 + 13) * 2 = 52 On voit dans ce script que la classe Carre() est construite à partir de la classe Rectangle() dont elle hérite de toutes les caractéristiques. En d'autres termes, la classe Rectangle() est une classe parente de la classe Carre(). Quant à l'instruction : if __name__ == "__main__": placée à la fin du module, elle sert à déterminer si le module est "lancé" en tant que programme (auquel cas les instructions qui suivent doivent être exécutées), ou au contraire utilisé comme une librairie de classes importée ailleurs. Dans ce cas cette partie du code est sans effet.

UUnn eexxeemmppllee ssuurr lleess ccllaasssseess #! /usr/bin/python # Voiture-10.py # ############# # # Voilà de quoi fabriquer des voitures en série. # Une usine, la classe Voiture, va permettre de fabriquer des modèles # différents en fonction de paramètres passés lors de l'initialisation. # Il reste Ã faire démarrer la voiture, la faire rouler un certain # nombre de kilomètres, puis de la faire s'arrêter. class Voiture: _demarrage = "Je suis une %s qui démarre." _action = "J'ai roulé %d %s : " def __init__(self, modele, bruit="Vroum", phrase_d_arret="Je m'arrête."): self.modele = modele self.arret = phrase_d_arret self.vrombissement = bruit def demarrer(self): print self._demarrage % self.modele def rouler(self, trajet): self.compteur = 0 while self.compteur < trajet.longueur : self.compteur = self.compteur + 1 # Si le compteur est à 1, on va choisir unite_singulier if self.compteur == 1: choix = trajet.unite_singulier else: choix = trajet.unite_pluriel print (self._action % (self.compteur, choix) ) + self.vrombissement * self.compteur def arreter(self): print self.arret + '\n' # La classe Trajet class Trajet:



def __init__(self, distance, unite="kilomètre", unites=None): self.longueur = distance self.unite_singulier = unite if unites is None : self.unite_pluriel = unite + 's' else: self.unite_pluriel = unites def __str__(self): if self.longueur > 1: choix = self.unite_pluriel else: choix = self.unite_singulier return "%d %s" % (self.longueur, choix) # La classe Course class Course: """Une course, instance de Course, - porte un nom - est définie par un trajet on peut y inscrire des voitures et enfin, courir la course. """ def __init__(self, nom, trajet): """Une course se définit par - un nom - un trajet. """ self.nom = nom self.trajet = trajet self.voitures = [] def __str__(self): """Affiche une représentation de la course sous forme de chaîne de caractères.""" return """ ************************************************************ * Il s'agit de la course appelée %s. * La distance à parcourir est de %s. ************************************************************ """ % (self.nom, self.trajet) def inscrire_voiture(self, voiture): """Prends un voiture (instance de la classe Voiture) en paramètre et l'ajoute à la liste des voiture qui pourront courir. """ self.voitures.append(voiture) def courir(self): print self if len(self.voitures): for voiture in self.voitures: voiture.demarrer() voiture.rouler(self.trajet) voiture.arreter() else: print """ La course ne sera pas courue par manque de participants. """ def test(): # on définit une course qui comportera un nom et un trajet



course = Course("Les Boucles de Spa", Trajet(6, "kilomètre")) # on crée une seat puis on l'inscrit à la course seat = Voiture("Seat Cordoba") course.inscrire_voiture(seat) # on crée une deuch' que l'on inscrit à la course deuch = Voiture("Deux Poils", "Prrrrtt") course.inscrire_voiture(deuch) # et enfin une f40 qu'on inscrit pareillement f40 = Voiture("Ferrari F40", "Vraaoum", "Je bloque pile poil grâce à mes freins à disque.") course.inscrire_voiture(f40) # puis, on lance la course course.courir() test() ### sortie : ##************************************************************ ##* Il s'agit de la course appelée Les Boucles de Spa. ##* La distance à parcourir est de 6 kilomètres. ##************************************************************ ## ##Je suis une Seat Cordoba qui démarre. ##J'ai roulé 1 kilomètre : Vroum ##J'ai roulé 2 kilomètres : VroumVroum ##J'ai roulé 3 kilomètres : VroumVroumVroum ##J'ai roulé 4 kilomètres : VroumVroumVroumVroum ##J'ai roulé 5 kilomètres : VroumVroumVroumVroumVroum ##J'ai roulé 6 kilomètres : VroumVroumVroumVroumVroumVroum ##Je m'arrête. ## ##Je suis une Deux Poils qui démarre. ##J'ai roulé 1 kilomètre : Prrrrtt ##J'ai roulé 2 kilomètres : PrrrrttPrrrrtt ##J'ai roulé 3 kilomètres : PrrrrttPrrrrttPrrrrtt ##J'ai roulé 4 kilomètres : PrrrrttPrrrrttPrrrrttPrrrrtt ##J'ai roulé 5 kilomètres : PrrrrttPrrrrttPrrrrttPrrrrttPrrrrtt ##J'ai roulé 6 kilomètres : PrrrrttPrrrrttPrrrrttPrrrrttPrrrrttPrrrrtt ##Je m'arrête. ## ##Je suis une Ferrari F40 qui démarre. ##J'ai roulé 1 kilomètre : Vraaoum ##J'ai roulé 2 kilomètres : VraaoumVraaoum ##J'ai roulé 3 kilomètres : VraaoumVraaoumVraaoum ##J'ai roulé 4 kilomètres : VraaoumVraaoumVraaoumVraaoum ##J'ai roulé 5 kilomètres : VraaoumVraaoumVraaoumVraaoumVraaoum ##J'ai roulé 6 kilomètres : VraaoumVraaoumVraaoumVraaoumVraaoumVraaoum ##Je bloque pile poil grâce à mes freins à disque. ##



Exercice : Définissez une classe CompteBancaire(), qui permettra d'instancier des objets tels que compte1, compte2, etc. Le constructeur de cette classe permettra d'initialiser deux attributs d'instance nom et solde, avec les valeurs par défaut 'Dupont' et 1000. Trois autres méthodes seront définies : depot() permettra d'ajouter une somme au solde retrait() permettra de retirer une somme du solde affiche() permettra d'afficher le nom du titulaire et le solde de son compte. Exemple d'utilisation de cette classe : >>> compte1 = CompteBancaire('Duchmol', 800) >>> compte1.depot(350) >>> compte1.retrait(200) >>> compte1.affiche() Le solde du compte bancaire de Duchmol est de 950 euros.



LLeess cchhaaîînneess ____ddoocc____ :: ddooccuummeenntteezz vvoottrree ccooddee.. Voyons comment s'utilisent les chaînes '__doc__' qui sont d'une très grande utilité pour documenter votre code ainsi que pour obtenir des informations sur l'utilisation des modules avec lesquels vous n'êtes pas encore totalement familiers. Il est possible de commencer la déclaration d'un module, d'une classe, d'une méthode ou d'une fonction par une chaîne de caractères qui peut être utilisée pour documenter le code. Cette chaîne doit être une constante et être placée avant la première instruction. Considérons le code du module suivant : #-- fichier module1.py -- """Ceci est un module d'exemple.""" def fonct(param): "documentation de la fonction 'fonct'." print param class Exemple: """Documentation de la Classe 'Exemple'""" def __init__(self,x): "methode constructrice de la classe Exemple" self.data=x #-- module1.py -- On peut ensuite "interroger" le module de la manière suivante : >>> import module1 >>> print module1.__doc__ Ceci est un module d'exemple. >>> print module1.fonct.__doc__ documentation de la fonction 'fonct'. >>> print module1.Exemple.__doc__ Documentation de la Classe 'Exemple'. >>> print module1.Exemple.__init__.__doc__ methode constructrice de la classe Exemple Il est également possible d'utiliser l'attribut '__dict__' du module pour avoir la liste des variables, fonctions et classes qu'il définit : >>> print module1.__dict__.keys() ['fonct', '__doc__', 'Exemple', '__file__', '__name__', '__builtins__'] Les symboles __file__ , __name__ et __builtins__ sont définis automatiquement par tous les modules et ils correspondent respectivement

•au nom du fichier depuis lequel le module a été chargé, •au nom du module et à une référence •au module __builtins__ qui est importé automatiquement et donc toujours disponible.



La plupart des modules Python utilisent ces chaînes de descriptions qui peuvent être utilisées comme aide en ligne. Par exemple, si l'on veut savoir ce que fait la fonction hypot du module math, il suffit de faire afficher la chaîne de documentation de cette fonction : >>> import math >>> print math.hypot.__doc__ hypot(x,y) Returns the Euclidean distance, sqrt(x*x + y*y). Les chaînes __doc__ constituent la méthode standard de documentation du code Python et tend dans la plupart des cas à remplacer les commentaires. Nous vous conseillons très fortement d'utiliser cette technique lorsque vous écrirez du code qui aura vocation d'être réutilisable ou d'être examiné par quelqu'un d'autre que vous.



LLee mmoodduullee ____bbuuiillttiinnss____ Ce module est importé automatiquement et contient les fonctions de base de Python. La table suivante donne un aperçu de chacune d'entre elles. Note: les paramètres suivis du signe '?' sont optionnels.

Fonction Description abs(x) Retourne la valeur absolue d'un nombre. apply(fonct, params) Appelle la fonction avec le tuple de paramètres spécifié.

callable(x) Retourne 1 si x est une méthode ou une fonction, retourne 0 sinon.

chr(x) Retourne la chaîne contenant le caractère dont le code ASCII est x.

cmp(x, y) Retourne -1, 0 ou 1, selon que x est inférieur, égal ou supérieur à x.

coerce(x, y) Retourne un tuple contenant x et y convertis dans le même type.

delattr(objet, nom) Efface l'attribut correspondant de l'objet (équivalent à del objet.nom).

dir(objet) Retourne la liste des attributs de l'objet. divmod(x,y) Retourne le tuple (x/y, x%y).

eval(code,global?,local?) Exécute l'expression (chaîne ou code retourné par la fonction compile()) passée en paramètre dans l'environnement local, ou ceux passés en paramètres.

execfile(fichier,global?,local?) Exécute le code contenu dans le fichier passé en paramètre.

filter(fonct, liste) Retourne une liste constituée des éléments de 'liste' pour lesquels la fonction 'fonct' retourne une valeur vraie.

float(x) converti le paramètre en nombre flottant. getattr(objet, nom) Retourne la valeur de l'attribut 'nom' de l'objet 'objet'.

globals() Retourne un dictionnaire contenant tous les symboles définis globalement.

hasattr(objet, nom) Retourne vrai si l'objet a un attribut nommé 'nom'.

hex(x) Retourne une chaîne donnant la représentation hexadécimale dex.

id(objet) Retourne un entier unique correspondant à 'objet' (dans l'implementation actuelle de Python c'est l'adresse mémoire à laquelle l'objet est stocké).

input(prompt?)

Lit une chaîne entrée au clavier. Si 'prompt' est spécifié, cette chaîne est d'abord affichée. >>> c=input() 'alain' >>> c 'alain'

int(x) Converti x en un nombre entier.

isinstance(objet, classe-ou-type?)

Retourne la valeur booléenne vraie ou fausse selon que l'objet est une instance de classe. Si le deuxième paramètre est utilisé, la valeur retournée est vrai si l'objet est du type ou hérite de la classe spécifié.

issubclass(a,b) Retourne la valeur booléenne vraie si 'b' hérite de la classe 'a'.

len(x) Retourne le nombre d'éléments contenus dans l'objet x. En particulier, cette fonction retourne le nombre de caractères si x est une chaîne.

locals() Retourne un dictionnaire contenant tous les symboles définis localement.

long(x) Converti x en un entier long.

map(fonct, liste, ...) Retourne la liste des résultats de l'appel de la fonction 'fonct' avec comme paramètre chacun des éléments de la liste.



max(seq) Retourne l'élément de la séquence ayant la plus grande valeur. min(seq) Retourne l'élément de la séquence ayant la plus petite valeur.

oct(x) Retourne une chaîne donnant la représentation octale (en base 8) de x.

open(fich, mode?, taillebuf?)

Ouvre le fichier 'fich' avec le mode éventuellement spécifié : 'r' pour lecture (mode par défaut si aucun n'est spécifié), 'w' pour écriture. En outre, les signes 'b' (pour un fichier binaire) et '+' (pour dire que l'on désire ouvrir le fichier à la fois en mode lecture et écriture) sont disponibles. Le paramètre 'taillebuf' indique si l'écriture dans le fichier doit utiliser un tampon ou être immédiate. 0 indique que les écritures doivent être immédiates, 1 indique qu'un tampon doit être utilisé, une valeur plus grande indiquant la taille du tampon à utiliser.

ord(x) Retourne le code ASCII du caractère passé en paramètre (c'est-à-dire la fonction inverse de chr() ).

pow(x, y, z?) Retourne x à la puissance y. Si le troisième paramètre est utilisé, cette fonction retourne (x^y) % z.

range(début?, fin, pas?) Retourne la liste des entiers de 'début' à 'fin' en incrémentant à chaque fois de 'pas'. Les valeurs par défaut de 'début' et 'pas' sont (respectivement) zéro et +1.

raw_input() Lit une ligne de caractères sur l'entrée standard en supprimant le retour à la ligne final.

reduce(fonct, liste, init?) Applique successivement 'fonct' par paire d'arguments, en utilisant éventuellement 'init' comme valeur initiale.

reload(module) Réimporte un module déjà importé. repr(x) Donne une chaîne représentant l'objet x. Idem que `x`.

round(x, n?) Arrondi le nombre en virgule flottante x à n décimales après la virgule (zéro par défaut).

setattr(obj, nom, valeur) Assigne une valeur à une donnée membre d'un objet (Idem que obj.nom=valeur).

tuple(seq) Converti une séquence en tuple. type(obj) Retourne le type de l'objet spécifié.

xrange(début?, fin, pas?) Idem que range mais retourne les entiers un par un au lieu de construire une liste.



LLee mmoodduullee ssttrriinngg Bien qu'elles ne fassent pas partie des fonctions de base du langage, les fonctions du module 'string' sont indispensables au développement de la plupart des applications.

Fonction Description atof(s) Converti une chaîne de caractères en nombre à virgule flottante.

atoi(s,base?), atol(s,base?)

Converti une chaîne de caractères en (respectivement) un entier ou entier long. Le deuxième paramètre est optionnel et précise la base à utiliser (10 par défaut).

find(s,sub,start?) Recherche la position de la première occurrence de la chaîne 'sub' dans la chaîne 's' en commençant la recherche au start-ième caractère (0 par défaut).

count(s,sub,start?) Compte le nombre d'occurrences de 'sub' dans 's' en commençant au start-ième caractère.

split(s) Retourne une liste d'éléments constituée en coupant la chaîne 's' entre chaque caractère espace.

splitfields(s,sep) Idem que split, mais utilise la séquence 'sep' comme séparateur.

join(x) Concatène une liste ou un tuple de chaînes de caractères en ajoutant un espace entre chaque élément (inverse de la fonction split).

joinfields(x,sep) Idem que join, mais la chaîne 'sep' et utilisée à la place du caractère espace (Inverse de la fonction splitfields).

strip(x) Enlève les caractères espace situés au début et la fin de la chaîne. upper(x) Converti tous les caractères en majuscule. lower(x) Converti tous les caractères en minuscule.



LLee mmoodduullee mmaatthh Le module 'math' défini les fonctions nécessaires pour faire la plupart des calculs mathématiques et scientifiques courants. Outre les variables e et pi, ce module défini également les fonctions suivantes : Fonction Description

fmod(x,y) Retourne le reste de la division de x par y (modulo). log10(x) Logarithme en base 10 de x. sqrt(x) Racine carré.

modf(x) Retourne un tuple contenant les parties fractionnaire et entière de x. >>> math.modf(3.14159) (0.14159, 3.0)

sin(x) cos(x) tan(x)

Respectivement : sinus, cosinus et tangente de x.

frexp(x) Retourne un tuple contenant la mantise et l'exposant de x lorsqu'il est exprimé en notation scientifique binaire.

exp(x) Retourne la constante e à la puissance x. acos(x) asin(x) atan(x)

Respectivement : arc-cosinus, arc-sinus et arc-tangente de x.

atan2(x,y) Équivalent à atan(x/y)

floor(x) Retourne la valeur entière de x sous forme de nombre réel : >>> math.floor(3.14159) 3.0

fabs(x) Retourne la valeur absolue du nombre x : >>> math.fabs(-3.14) 3.14

log(x) Retourne le logarithme Népérien de x. pow(x,y) Retourne x^y. hypot(x,y) Calcul de la distance euclidienne : sqrt(x*x+y*y). ldexp(x,i) Retourne x*2^i (Inverse de la fonction 'frexp'). cosh(x) sinh(x) tanh(x)

Respectivement : cosinus hyperbolique, sinus hyperbolique et tangente hyperbolique.

ceil(x) Retourne l'entier immédiatement supérieur à x sous forme de nombre réel : >>> math.ceil(3.14) 4.0



LLee mmoodduullee ooss Le module 'os' est en quelque sorte un alias qui va conduire au chargement d'un module différent en fonction de la plate-forme utilisée. Sous linux, la directive 'import os' importera en fait le module 'posix', sur d'autres plate-formes ce pourra être 'nt', 'dos', 'mac', 'os2', ou 'ce'. Ce module est un peu 'fourre-tout' dans la mesure où il regroupe un grand nombre de fonctions dont la seule caractéristique commune est que leur implémentation est différente d'une plate-forme à une autre. La plupart d'entre elles concernent les entrées/sorties et plus généralement l'interaction avec le système d'exploitation. Ce module comportant un grand nombre de fonctions, seules les plus utiles sont listées dans le tableau suivant.

Fonction Description getcwd() Retourne une chaîne référençant le répertoire courant.

listdir(répertoire) Retourne la liste de toutes les entrées contenues dans le répertoire passé en paramètre.

chown(path,uid,gid) Change le propriétaire et le groupe du fichier ou répertoire donné. rename(src, dest) Renomme le fichier 'src' en 'dest'. remove(path), unlink(path)

Efface le fichier donné.

mkdir(path, mode?) Crée un répertoire. rmdir(path) Effacement d'un répertoire.

system(commande) Exécution d'une commande shell. La valeur retournée par la fonction est celle qui a été retourné par la commande.

symlink(src,dest) Création d'un lien symbolique de 'src' vers 'dest'. link(src,dest) Création d'un lien "hard" de 'src' vers 'dest'.

environ

Dictionnaire contenant toutes les variables d'environnement du processus : >>> print os.environ['TMP'] C:\DOCUME~1\AMEURA~1.VOY\LOCALS~1\Temp

popen(commande, mode?, bufsize?)

Ouvre un pipe vers la commande shell mentionnée. Le mode peut être 'r' (lecture; mode par défaut) ou 'w'. Le paramètre 'mode' a le même rôle que pour la fonction open. Le code de retour de la commande est celui retourné par la fonction close() sur l'objet fichier retourné par popen().

fork() Forke un nouveau processus. La valeur retournée est zéro dans le processus fils et le PID du processus fils dans le père.

kill(pid,signal) Envoie un signal à un processus.

curdir

Chaîne utilisée par le système d'exploitation pour désigner le répertoire courant (c.à.d. '.' sous UNIX/Windows et ':' sous Mac). Cette variable ainsi que celle qui suivent doivent impérativement être utilisées lorsque vous manipulez des noms de fichiers pour garantir la portabilité de vos applications.

pardir Chaîne utilisée par le système d'exploitation pour désigner le répertoire parent (c.à.d. '..' sous UNIX/Windows et '::' sous Mac).

sep Chaîne utilisée par le système d'exploitation pour séparer les répertoires dans un chemin d'accès (c.à.d. '/' sous UNIX, '\' sous Windows et ':' sous Mac).

linesep Chaîne correspondant à la fin de ligne sur l'OS utilisé, c.à.d. : '\n' sous UNIX, '\r' sous Macintosh et '\r\n' sous Windows).



LLee mmoodduullee ssyyss Ce module contient les variables propres au fonctionnement de l'interpréteur ainsi que quelques unes permettant d'identifier la plate-forme en cours d'utilisation. Note : Le tableau suivant n'est pas exhaustif. Seul les attributs et fonctions les plus utiles y sont mentionnés

Attributs Description

argv Liste constituée du nom de la commande et de ses paramètres ayant été utilisés pour démarrer le script Python.

builtin_module_names Retourne la liste des modules qui ont été compilés dans l'interpréteur Python.

exit(valeur) Termine l'interpréteur Python en levant l'exception SystemExit et en retournant valeur au processus appelant.

version

Affiche une chaîne indiquant la version de l'interpréteur. (Celle qui est affichée par défaut au lancement de l'interpréteur) >>> sys.version '2.2.1 (#34, Apr 9 2002, 19:34:33) [MSC 32 bit (Intel)]'

platform

Retourne une chaîne identifiant le système d'exploitation sur lequel l'interpréteur Python tourne ('linux2' pour la version Linux). >>> sys.platform 'win32'

modules Renvoie un dictionnaire dont les clés sont les noms des modules qui ont été chargés.

path

Contient la liste des répertoires dans lequel l'interpréteur tentera de trouver les modules à importer. >>> sys.path ['D:\\Program Files\\Developpement\\Python22\\Tools\\idle', 'D:\\Program Files\\Developpement\\Python22\\Tools\\idle', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\DLLs', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\lib', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\lib\\lib-tk', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22', 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\lib\\site-packages']

ps1, ps2 Donne les chaînes utilisées comme prompts primaires et secondaires. Leur valeur par défaut sont respectivement '>>>' et '...'.

stdin, stdout, stderr Renvoie les objets, de type fichier, utilisés comme (respectivement) entrée de l'interpréteur, sortie par défaut et affichage des erreurs et des prompts.

getrefcount(obj) Retourne le nombre de variables qui référencent l'objet 'obj'.

executable Retourne le path complet de l'interpréteur Python en cours d'utilisation.>>> sys.executable 'D:\\PROGRA~2\\DEVELO~1\\PYTHON22\\pythonw.exe'



LLee mmoodduullee ssoocckkeett Ce module fourni les primitives de base pour opérer sur les sockets. Sur les plates-formes UNIX, il gère IP et les sockets 'Unix domain'. Sur les autres systèmes d'exploitation, il gère seulement IP. En plus des fonctions mentionnées dans le tableau qui suit (qui reprennent noms et fonctionnalités de leur équivalent dans la bibliothèque C standard), le module socket défini également le type 'SocketType' auquel appartiennent les sockets.

Fonction Description

socket(famille,type,proto?)

Ouvre une socket du type donné. La 'famille' peut être soit AF_INET (IP), soit AF_UNIX (UNIX Domain). Le paramètre 'type' indique si la socket est de type flux (SOCK_STREAM) ou datagramme (SOCK_DGRAM). Le paramètre 'proto' (dont la valeur par défaut est zéro) spécifie optionnellement le protocole à utiliser.

fromfd(df,famille,type,proto?) Crée un objet de type socket à partir d'un descripteur de fichier donné. Les autres paramètres sont identiques à ceux de la fonction socket().

gethostname() Retourne le nom de la machine hôte.

gethostbyname(nom-d-hôte)

Retourne sous forme de chaîne de caractères l'adresse IP d'un hôte à partir de son nom : >>> print socket.gethostbyname('localhost') 127.0.0.1

gethostbyaddr(hôte)

Retourne un tuple contenant le nom d'hote, une liste d'alias et une liste d'adresses IP pour la machine donnée. Le paramètre doit être une chaîne représentant le nom de la machine ou son adresse IP : >>> print socket.gethostbyaddr('voyageur') ('voyageur', [], ['172.17.2.7'])

getservbyname(service,protocole)

Retourne le numéro de port en fonction du nom d'un service et de son type (TCP ou UDP) : >>> print socket.getservbyname('www', 'tcp') 80 >>> print socket.getservbyname('domain', 'udp') 53 Web et DNS utilisent donc 80 et 53 comme ports respectifs.

getprotobyname(nom)

Retourne le numéro correspondant au protocole mentionné : >>> print socket.getprotobyname('tcp') 6 >>> print socket.getprotobyname('icmp') 1

ntohs(), ntohl() Converti des entiers (respectivement) 16 ou 32 bits de l'ordre réseau vers l'ordre de la plate-forme hôte.

htons(), htonl() Converti des entiers (respectivement) 16 ou 32 bits de l'ordre de la plate-forme hôte vers l'ordre réseau.



RReessssoouurrcceess

Ouvrages BEAZLEY D.M., Python Essential reference, New Riders Publishing, 2000, ISBN 0-7357-0901-7 LUNDH F., Python Standard Libary, Editions O'Reilly, 2001, ISBN 0-596-00096-0 LUTZ M., Python Précis & Concis, Editions O'Reilly, 2000, ISBN 2-84177-111-3 LUTZ M. ASCHER D., Introduction à Python, Editions O'Reilly, 2000, ISBN 2-84177-089-3 LUTZ M., Python Précis & Concis 2end édition, UK, Editions O'Reilly, 2002, ISBN 2-84177-160-1 LUTZ M., Python Pocket Reference 2nd edition, FR, Editions O'Reilly, 2002, ISBN 0-596-00189-4 HAMMOND M. & ROBINSON A., Python, programming on Win32, Editions O'Reilly, 2000, 1-56592-621-8

Sites Python essentiels : Site officiel de Python : Téléchargement libre des différentes versions de Python, documentation originale, textes de référence, multitude de liens vers d'autres sites ... http://www.python.org http://www.jython.org/ J Python (Une version de Python produisant du bytecode Java) http://aspn.activestate.com/ASPN/Downloads/VisualPython Visual Python (module permettant la programmation d'objets 3D) http://www.vex.net/parnassus/ Vaults of Parnassus : Site de référence donnant accès à un grand nombre d'applications libres écrites en Python http://www.python.org/doc/current/ref/ref.html En visitant le manuel de référence de Python vous trouverez une liste exhaustive de ces outils. Il est également disponible Off Line dans votre répertoire Python\doc\ref\ref.html http://www.python-eggs.org/links.html http://diveintopython.org/fr/ http://aspn.activestate.com/ASPN/Python/Cookbook/ http://pychecker.sourceforge.net/ http://www.wxpython.org/ http://www.pythonapocrypha.com/ http://www.mcmillan-inc.com/python_index.html http://directory.google.com/Top/Computers/Programming/Languages/Python/FAQs,_Help,_and_Tutorials/ Python et Windows: http://starship.python.net/crew/mhammond/



Sites Python essentiels en français : Python Blanc Bleu Belge : ce site attrayant propose divers tutoriaux de Python pour débutants, consultables en ligne. http://www.p3b.org Cours de programmation Python Ce cours expérimental destiné aux élèves de l'enseignement secondaire belge (plus de 250 pages à l'heure actuelle) vous est proposé ci-dessous en téléchargement gratuit. http://www.ulg.ac.be/cifen/inforef/swi/python.htm http://wikipython.tuxfamily.org/moin.cgi http://frpython.sourceforge.net/ http://www.linuxfrench.net/article.php3?id_article=918 http://www.chez.com/pyresources/docs/extpy/book1.htm http://membres.lycos.fr/droche/article_tcl/article.html http://freezope1.nipltd.net/salvatore/Forum/Python/ http://perso.club-internet.fr/olberger/python/index.html http://www.univ-pau.fr/~bruel/Enseignements/TER/InterfacePython/python.html http://www-gtr.iutv.univ-paris13.fr/Cours/Mat/Python

aragne python : module de base v1.5 05-03-2003...

Documents