Initiation Python

5/26/2018 Initiation Python

1/108

Initiation Python par lexemple

DocumentationVersion 1.5.0

Raphal MARVIE

23 February 2012


2/108


3/108

Table des matires

1 Avant-propos 3

2 Introduction 5

2.1 Un peu dhistoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2 Python, quoi bon ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.3 Python ou pas Python ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3 Premiers pas en Python 7

3.1 Utilisation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73.2 Structures de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83.3 Constructions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.4 Autres lments sur les squences . . . . . . . . . . . . . . . . . . . . . . . . 223.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

4 Quelques modules etbuilt-in 27

4.1 Dfinition et utilisation de modules . . . . . . . . . . . . . . . . . . . . . . . 274.2 Quelques modules standards . . . . . . . . . . . . . . . . . . . . . . . . . . . 304.3 Built-in en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

5 Plongeon dans les objets 41

5.1 Des objets, rien que des objets . . . . . . . . . . . . . . . . . . . . . . . . . . 415.2 Structures des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465.3 Les objets, version avance . . . . . . . . . . . . . . . . . . . . . . . . . . . 485.4 Les exceptions en python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515.5 Toujours propos des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . 535.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

6 Python et XML 59

6.1 XML, avec une vision DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . 596.2 Naviguer dans un arbre DOM . . . . . . . . . . . . . . . . . . . . . . . . . . 616.3 Accder aux informations dun noeud . . . . . . . . . . . . . . . . . . . . . . 63

i


4/108

6.4 Construire un document XML . . . . . . . . . . . . . . . . . . . . . . . . . . 656.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

7 Python et la persistance de donnes 69

7.1 Fichiers DBM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

7.2 Pickle et Shelve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 717.3 Python et SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

8 Python et les interfaces graphiques 77

8.1 Python et Tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 778.2 Petit tour des widgets courants . . . . . . . . . . . . . . . . . . . . . . . . . . 848.3 Autres widgets prt lemploi . . . . . . . . . . . . . . . . . . . . . . . . . . 908.4 Autres extensions disponibles . . . . . . . . . . . . . . . . . . . . . . . . . . 928.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

9 Conclusion 93

10 Remerciements, historique et faire 95

10.1 Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9510.2 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9510.3 faire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

11 GNU Free Documentation License 97

11.1 Preamble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9711.2 Applicability and Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . 97

11.3 Verbatim Copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9911.4 Copying in Quantity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9911.5 Modifications. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10011.6 Combining Documents. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10111.7 Collections of Documents . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10211.8 Aggregation with Independent Works . . . . . . . . . . . . . . . . . . . . . . 10211.9 Translation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10211.10 Termination. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10311.11 Future Revisions of this License . . . . . . . . . . . . . . . . . . . . . . . . . 10311.12 Addendum : How to use this License for your documents. . . . . . . . . . . . 103

ii


5/108

Initiation Python par lexemple Documentation, Version 1.5.0

Contents :

Table des matires 1


6/108


2 Table des matires


7/108

CHAPITRE 1

Avant-propos

Ce support propose une initiation au langage Python par lexemple. Il fait suite une formationdune semaine et comportant 6 cours. Cette version essaye de complter les transparents, maisne regroupe malheureusement pas tout le discours accompagnant la prsentation des transpa-rents. La formation se faisant en salle machine, tous les exemples taient tests interactivementpendant le cours. Cette approche est volontairement conserve ici et il est conseill dutiliserce support avec un interprteur lanc pour voir ce qui se passe.

Ce support de cours est destin un public tant familier avec au moins un langage de pro-grammation, si possible orient objet, et tre familier avec les notions dobjet. Ce support nestpas un cours de programmation, ni un cours complet sur le langage Python, il ne reprsentequune initiation diffrentes choses que lon peut faire avec Python.

La version utilise dans ce support est la 2.7. Les premiers complments de ce support sont lesdocuments associs au langage Python comme la librairie standard, le manuel de rfrence, oubien le tutoriel officiel (tous les trois disponibles sur le site officielhttp ://www.python.org).

Sans ambition dtre suffisant, la mise en ligne de ce support a pour unique objectif dtreventuellement utile. Toute remarque concernant ce support est toujours la bienvenue !

r.m.

Copyright (c) 2003-2012, Raphael MARVIE

Permission is granted to copy, distribute and/or modify this document

under the terms of the GNU Free Documentation License, Version 1.2 orany later version published by the Free Software Foundation. A copy

of the license is included in the section entitled "GNU Free

Documentation License".

3
http://www.python.org/http://www.python.org/


8/108


4 Chapitre 1. Avant-propos


9/108

CHAPITRE 2

Introduction

2.1 Un peu dhistoire

Python est un langage de programmation objet interprt. Son origine est le langage de scriptdu systme dexploitationAmoeba(1990). Il a t dvelopp par Guido Von Rossum au CWI, lUniversit dAmsterdam et nomm par rapport auMonthy Pythons Flying Circus.

Depuis, Python est devenu un langage de programmation gnraliste (comp.lang.python estcr en 1994). Il offre un environnement complet de dveloppement comprenant un interprteurperformant et de nombreux modules. Un atout indniable est sa disponibilit sur la grandemajorit des plates-formes courantes (BeOS, Mac OS X, Unix, Windows).

Python est un langage open sourcesupport, dvelopp et utilis par une large communaut :300 000 utilisateurs et plus de 500 000 tlchargements par an.

2.2 Python, quoi bon?

Pour rsumer Python en quatre points forts. QualitLutilisation de Python permet de produire facilement du code volutif et mainte-

nable et offre les avantages de la programmation oriente-objet. ProductivitPython permet de produire rapidement du code comprhensible en relguant

nombre de dtails au niveau de linterprteur. PortabilitLa disponibilit de linterprteur sur de nombreuses plates-formes permet lex-

cution du mme code sur un PDA ou un gros systme 1. IntgrationLutilisation de Python est parfaitement adapte lintgration de composants crit

dans un autre langage de programmation (C, C++, Java avec Jython). Embarquer un inter-prteur dans une application permet lintgration de scripts Python au sein de programmes.

Quelques caractristiques intressantes : langage interprt (pas de phase de compilation explicite) pas de dclarations de types (dclaration laffectation)

gestion automatique de la mmoire (comptage de rfrences)1. Mme si un tel cas semblerait un peu bizarre.

5


10/108


programmation orient objet, procdural et fonctionnel par nature dynamique et interactif possibilit de gnrer du byte-code (amliore les performances par rapport une interprta-

tion perpetuelle) interactions standards (appels systmes, protocoles, etc.) intgrations avec les langages C et C++

2.3 Python ou pas Python ?

Comme tout langage de programmation Python nest pas la solution ultime tous les besoins.Toutefois, on retrouve son utilisation dans diffrents contextes [successtory] comme Google, laNASA, YouTube, Industrial Light & Magic, le projetOne Laptop Per Child, lenvironnementOpie sur pocket PC, etc. Python est donc adapt pour raliser de grosses applications.

Quand Python ? Python est un trs bon langage pour le dveloppement agile cite{agile} etitratif. Il permet dtre ractif et vite le cycle lourd programmer / compiler / tester. Deplus, le langage permet de vrifier trs rapidement des hypothses de mise en oeuvre. Unefois la solution ralise en Python, il est alors toujours possible de loptimiser davantageen re-dveloppant certain de ses composants en C++ par exemple.Python permet de produire des applications facilement extensibles non seulement par ledveloppeur mais aussi dans certains cas par lusager (de nombreuses librairies scienti-fiques sont disponibles).Enfin, Python est un bon candidat pour lautomatisation de tches systmes. Le systmedadministration de la distribution Gentoo Linuxportageest dvelopp en Python. Une

partie au moins du support de lintgration continue chez Google est fait en Python.Quand pas python ?

Dynamicitest rarement compatible avec haute performance, Python nest donccertainement pas le meilleur langage pour faire du traitement intensif (calcul nu-mrique, extraction de donnes, etc.). Mais il reste trs pertinent pour piloter cetype dapplications.Dans certain cas, les usagers prfrent limiter lutilisation de Python laspectintgration de composants afin de produire des systmes performants. La versionPython fournit une preuve de conceptou une version fonctionnelle avant de re-

dvelopper les points faibles. Toutefois, les performances de Python sont souventsuffisante pour des applications forte charge (cf. YouTube)

Une dernire remarque pour terminer, Python permet didentifier rapidement une mauvaiseide...

6 Chapitre 2. Introduction


11/108

CHAPITRE 3

Premiers pas en Python

3.1 Utilisation de Python

Python, comme la majorit des langages dit de script, peut tre utilis aussi bien en modeinteractif quen mode script / programme.

Dans le premier cas, il y a un dialogue entre lutilisateur et linterprte : les commandes entrespar lutilisateur sont values au fur et mesure. Cette premire solution est pratique pourraliser des prototypes, ainsi que pour tester tout ou partie dun programme ou plus simplementpour interagir aisment et rapidement avec des structures de donnes complexes. Le listingsuivant prsente comment lancer linterprte (simplement en tapant python linvite du shell 1)et comment en sortir (en tapant Ctrl-D).

$ python

Python 2.7.2 (v2.7.2:8527427914a2, Jun 11 2011, 15:22:34)

[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin

Type "help", "copyright", "credits" or "license" for more information.

>>> print hello world!

hello world!

>>> ^D

$

Pour une utilisation en modescriptles instructions valuer par linterprte sont sauvegardes,comme nimporte quel programme informatique, dans un fichier. Dans ce second cas, lutilisa-teur doit saisir lintgralit des instructions quil souhaite voir valuer laide de son diteurde texte favori, puis demander leur excution linterprte. Les fichiers Python sont identifispar lextension .py. Le listing suivant, linterprte est appel avec en paramtre le nom duprogramme valuer (le traditionnel hello world). Dans le cas dun systme Unix, la premireligne du fichier hello.py prcise quel interprte utiliser pour valuer le fichier si ce dernierest excutable. Il suffit dans ce cas de taper le nom du fichier linvite du shell. :

$ cat hello.py

#! /usr/bin/env python

1. Dans tout ce support linvite du shell sera identifi par la lettre$.

7


12/108


print hello world!

$ python hello.py

hello world!

3.2 Structures de base

3.2.1 Commentaires

Comme dans la majorit des langages de script, les commentaires Python sont dfinis laidedu caractre #. Quil soit utilis comme premier caractre ou non, le # introduit un commen-taire jusqu la fin de la ligne. Comme toujours, les commentaires sont utiliser abondammentavec parcimonie. Il ne faut pas hsiter commenter le code, sans pour autant mettre des com-

mentaires qui napportent rien. Le listing suivant prsente une ligne de commentaire en Python.Les commentaires seront de nouveaux abords en [sub :chap1 :doc] pour lauto-documentation.Les commentaires introduits par #devraient tre rservs au remarques sur le code en sa miseen oeuvre.

>>> # ceci est un commentaire

>>> print bouh # ceci est aussi un commentaire

bouh

3.2.2 Typage en Python

En Python, tout est objet. Quelque soit les donnes que lon manipule, ces donnes sont des ob-jets dont les classes sont dfinies par lusager, ou par lenvironnement Python pour les types debase. Une consquence est que lutilisateur manipule les donnes au travers de rfrences (quidonnent accs aux fonctionnalits des instances). Cette approche permet de rendre homogneles donnes manipules par lutilisateur (comme ctait le cas en SmallTalk). Ainsi, toutes lesdonnes suivantes suivant sont des objets : 1, [2, 3, 4], 5.6, toto, une instance de Foo.

Python est un langage typage dynamique. Ceci ne veut pas dire que les donnes que lonmanipule ne sont pas types, mais que leur type est calcul lors de leur utilisation 2.Dans cecontexte, le type des variables nest pas dfini explicitement par lutilisateur. Ainsi, une mmevariable peut rfrencer dans un programme des objets de types diffrents 3.

>>> x = 1 # x reference un entier

>>> x = toto # x reference desormais une chaine

>>> x = Foo() # x reference desormais une instance de Foo

2. En Python, ce calcul se rsume la possibilit pour lobjet de recevoir un message particulier.3. Il est toutefois noter que cette facilit ne devrait tre utilises que sous couvert du polymorphisme, sans

quoi la lisibilit du programme sen trouve rduite.

8 Chapitre 3. Premiers pas en Python


13/108


3.2.3 Arithmtique

Python permet dexprimer trs simplement des oprations arithmtiques. Dans le cas o tousles oprandes sont des entiers, alors les rsultats seront aussi des entiers. Lorsquau moins undes oprandes est de type rel, alors tous les oprandes sont automatiquement convertis enrels.

>>> x = 1 + 2

>>> y = 5 * 2

>>> y / x

3

>>> y % x

1

>>> y = 5.5 * 2

>>> y

11.0

>>> x = 12.0 / 3

>>> x

4.0

Dans le contexte de larithmtique, les affections peuvent prendre deux formes. Ces deuxformes ont un sens diffrent. Le listing suivant prsente deux affectations qui pourraient trecomprises de manire identique. Toutefois, la premire forme (ligne 2) a pour consquence decrer une nouvelle instance dentier pour contenir lajout de 2 la valeur de x. La secondeforme (ligne 3) ajoute 2 la valeur de xsans crer de nouvelle instance. La manire dcrireune opration a donc un impact sur son valuation.

>>> x = 4

>>> x = x + 2

>>> x += 2

3.2.4 Chanes de caractres

Les chanes de caractres se dfinissent de plusieurs manires en Python. Il est possible duti-liser indiffremment des guillemets simples ou des guillemets doubles. Le choix est souventimpos par le contenu de la chane : une chane contenant des guillemets simples sera dcla-

re avec des guillemets doubles et rciproquement. Pour les autres cas, cest indiffrent. Enfin,comme tout est objet en Python une chane est donc un objet. Le listing suivant dclarer deuxchanes rfrences par xet y. Enfin, la chane rfrence par zest une chane de caractresmulti-lignes (utilisation de trois quotes / guillemets simples ou doubles).

>>> x = hello

>>> y = "world!"

>>> z = hello

... world

3.2. Structures de base 9


14/108


3.2.5 Concatnation

La concatnation de ces chanes de caractres peut prendre deux formes. Dans les deux cas,loprateur + est utilis pour exprimer la concatnation. La forme de la ligne 4 est un raccourcidcriture.

>>> z = x + y

>>> z

hello world!

>>> x += y

>>> x

hello world!

3.2.6 Affichage

Laffichage de chanes de caractres laide de la fonction print peut se faire en concatnantexplicitement des chanes (que ce soit avec loprateur de concatnation ou en utilisant desvirgules) ou en utilisant une chane de formatage comme la fonction printfdu langage C.Cette seconde option est un peu plus puissante, mais aussi un peu plus lourde utiliser. Lelisting suivant prsente trois manire dafficher des chane de caractres.

>>> print I say: + x

I say: hello world!

>>> print x, 2, times

hello world! 2 times

>>> print "I say: %s %d time(s)" % (x, 2)I say: hello world! 2 time(s)

3.2.7 Manipulations

Python offre une mthode simple pour accder aux caractres contenus dans une chane : unechane est manipule comme une squence indexe de caractres. Ainsi, chaque caractre estaccessible directement par son index (le premier tant index 0) en utilisation des crochets.En plus de cet accs unitaire aux caractres, il est possible daccder des sous-chanes en

prcisant la tranche souhaite lindex de dbut (qui est inclus) tant spar de lindex de fin(qui est exclu) par le caractre :. Dans le cas des sous-chanes, la valeur fournie est une copieet non un accs une partie de la chane dorigine.

Le listing suivant donne quelques exemples daccs un caractre (ligne 2), ou une sous-chane pour le reste. La colonne de gauche prsente des accs partir du dbut de la chanes(les index sont positifs). La ligne 6 signifie que lon souhaite le contenu de xdu quatrimecaractre la fin. Enfin, la dernire ligne ralise une copie de la chane x.

>>> x = hello world!

>>> x[4]

o>>> x[2:4]

ll



15/108


>>> x[3:]

lo world!

>>> x[:]

hello world!

Enfin, un index ngatifs prcise que le calcul seffectue depuis la fin de la chane.

>>> x[-3:]

ld!

>>> x[1:-1]

ello world

3.2.8 Listes

LeslistesPython sont des ensemble ordonns et dynamique dlments. Ces ensemble peuventcontenir des lments de diffrents types, leur seul point commun est que ce sont des objets. Etcomme tout est objet, les listes sont elles mmes des objets (instances de la classe list).

Lexemple suivant cre tout dabord deux listes vides avec les deux manires possibles.

>>> mylist = []

>>> mylist2 = list()

Ensuite, aprs avoir dfinix, une liste contenant la chane bar, lentier 12345 et lobjet rf-renc par la variablexest cre.

>>> x = True>>> foo = [bar, 12345, x]

>>> foo

[bar, 12345, True]

Les listes et les chanes ont pour point commun le fait dtre des ensembles ordonns. Laccs un lment dune liste se fait donc aussi par indexation (ligne 1). Il est possible de prendreune partie de liste (ligne 3) et dobtenir une copie de liste (ligne 5). Une copie de liste cre unenouvelle liste, mais partage les lments contenus dans la liste dorigine.

Cette dernire manipulation est trs importante lors de parcours de listes (voir section [sub-

Chap1LoopPbl]) pour ne pas modifier la liste qui est parcourue et se retrouver dans une bouclesans fin.

>>> foo[2]

True

>>> foo[1:]

[12345, True]

>>> bar = foo[:]

Enfin, le contenu de la liste peut tre chang par simple affection en utilisant lindex cible.Comme la liste rfrence par barest une copie de la liste rfrence par foo, le dernier

lment debarnest pas modifi par laffectation du dernier lment de foo.



16/108


>>> foo[2] = 1

>>> foo

[bar, 12345, 1]

>>> bar[-1]

True

Lajout dlments dans une liste se fait laide des mthodes appendpour un ajout en fin deliste, et insert, pour un ajout un index donn. Enfin, la mthode extend ajoute le contenudune liste pass en paramtre la fin de la liste.

>>> foo.append(new)

>>> foo

[bar, 12345, 1, new]

>>> foo.insert(2, new)

>>> foo

[bar, 12345, new, 1, new]

>>> foo.extend([67, 89])

>>> foo

[bar, 12345, new, 1, new, 67, 89]

La mthode indexpermet de connatre lindex de la premire occurrence dun lment dansune liste. Dans le cas o llment fournit en paramtre nest pas prsent, la mthode lvelexception ValueError. Lutilisation de la constructioninretourne quant elle Truesillment est prsent dans la liste et Falsesinon.

>>> foo.index(new)

2

>>> foo.index(34)

Traceback (most recent call last):

File "", line 1, i n ?

ValueError: list.index(x): x not in list

>>> 34 in foo

False

Les listes peuvent tre fusionnes par concatnation. Ces concatnations peuvent aussi bien sefaire par copie que par ajout. La ligne 1 reprsente une concatnation par copie des deux listesexistantes. La ligne 4 prsente une concatnation par ajout dlments une liste existante.

Enfin, la ligne 7 prsente une manire simple de crer une liste par rptition dun motif quidoit tre lui mme une liste.

>>> bar = [0, 1] + [1, 0]

>>> bar

[0, 1, 1, 0]

>>> bar += [2, 3]

>>> bar

[0, 1, 1, 0, 2, 3]

>>> [0, 1] * 3

[0, 1, 0, 1, 0, 1]

AttentionDans le cas dune cration de liste par rptition, les lments ne sont pas dupliqus,mais ce sont leurs rfrences qui sont rptes (et donc prsentes plusieurs fois dans la liste



17/108


finale). Utiliser loprateur*pour la construction de matrice est donc une mauvaise ide cartoutes les lignes seraient alors la mme liste rfrence plusieurs fois.

>>> matrix = [[1, 2, 3]] * 3

>>> matrix

[[1, 2, 3], [1, 2, 3], [1, 2, 3]]>>> matrix[1][1] = 4

>>> matrix

[[1, 4, 3], [1, 4, 3], [1, 4, 3]]

De manire symtrique lajout dlments dans une liste, il est possible den supprimer. Lamthode removepermet de supprimer la premire occurrence dun lment dune liste en ledsignant.

>>> foo.remove(new)

>>> foo

[bar, 12345, 1, new, 67, 89]

Si llment fourni en paramtre nexiste pas dans la liste, lexception ValueError est leve.

>>> foo.remove(34)



ValueError: list.remove(x): x not in list

Loprateur del(delete) permet de dtruire une rfrence un objet Python, ou une partiedune liste 4.

>>> del foo[1:3]

>>> foo

[bar, new, 67, 89]

Dautres formes plus avances de manipulation de listes sont prsentes dans la section[sub :chap1 :listes].

3.2.9 Listes et chanes de caractres

Les listes et les chanes de caractres sont similaire dans leur structure et dans leur manipula-tion. Certaines mthodes disponibles sur les chanes manipulent les deux structures de donnes.

La mthode join disponible sur les chane permet de construire une chane de caractre depuisune liste de chanes. La chane sur laquelle est invoque la mthode join est alors utiliscomme sparateur des diffrents lments de la liste.

>>> ; .join([a, b, c])

a ; b ; c

4. Lorsque la dernire rfrence un objet est dtruite alors lobjet et lui mme effectivement dtruit.



18/108


De manire symtrique, la mthodesplit, disponible sur les chanes, permet de dcomposerune chane de caractres en une liste de sous chanes. Ce dcoupage se fait par rapport un ouplusieurs caractres. Dans le cas o un entier est pass comme second argument, il prcise lenombre maximum de dcoupage.

>>> hello crazy world!.split(" ")[hello, crazy, world!]

>>> hello crazy world!.split(" ", 1)

[hello, crazy world!]

3.2.10 Tuples

Les tuples sont des ensemble ordonns et immuables dlments. Comme les listes, lestuples peuvent contenir des donnes de diffrents types. La premire ligne prsente une dcla-

ration classique (avec des parenthses) alors que la secone ligne prsente la notation abrge.La virgule est importante pour prciser que lon parle dun tuple un lment et non de lavaleur 12. Cette remarque serait valable dans la cas dune dclarationparenthsedun tuple un lment.

>>> foo = (bar, 12345, x)

>>> bar = 12,

Comme les listes, les tuples sont accessibles par indexation, et la construction inpermet detester la prsence dun lment dans le tuple. Cependant, une fois cr le contenu dun tuple nepeut tre modifi.

>>> foo[1]

12345

>>> foo[:-1]

(bar, 12345)

>>> bar in foo

True

>>> foo[1] = 12


File "", line 1, in

TypeError: tuple object does not support item assignment

RemarqueCritres de choix entre une liste et un tuple : les tuples sont plus rapides parcourir que les listes, pour dfinir des constantes, utiliser des tuples.Il est possible de convertir des tuples vers des listes et rciproquement.

>>> list((1, 2, 3))

[1, 2, 3]

>>> foo = tuple([1, 2, 3])

>>> foo

(1, 2, 3)



19/108


Pour terminer, Python offre laffectation multiple pour assigner diffrentes valeurs depuis untuple de manire simultane. Ici encore, les parenthses peuvent tre omises. Il est aussi pos-sible de faire des assignation en cascade.

>>> (x, y, z) = foo

>>> x1

>>> a , b , c = foo

>>> b

2

>>> d = e = b

>>> d

2

>>> e

2

3.2.11 Dictionnaires

Les dictionnaires, parfois appels tableaux associatifs, sont des ensembles non ordonns dl-ments indexs par des cls. Une cl doit obligatoirement tre immuable (chane, entier outuple). Dautre part, une cl est toujours unique.

Un dictionnaire est dclar par deux accolades ou en utilisant le type dict. Il peut tre crvide ou avec des valeurs initiales.

>>> dict1 = {}

>>> dict2 = {foo: 456, 123: bar}

>>> dict3 = dict()

>>> dict4 = dict(foo=456, bar=123)

Lajout et laccs aux lments dun dictionnaire se fait par indexation sur la cl associ llment.

>>> dict1[foo] = 456

>>> dict1[123] = bar

>>> dict1[123]bar

Laffichage dun dictionnaire prsente une liste de paires cl : valeur.

>>> dict1

{123: bar, foo: 456}

>>> dict4

{foo: 456, bar: 123}

Lutilisation de la classe dict pour crer un dictionnaire non vide, ne peut se faire quavec des

chaines (utilisation darguments nomms).



20/108


>>> dict4

{foo: 456, bar: 123}

Les dictionnaires offrent des mthodes pour manipuler les cls. La mthode keys retourne une

liste de toutes les cls du dictionnaire et la mthode has_key retourne True si la cl donn enparamtre est prsente dans le dictionnaire etFalsedans le cas contraire. Il est aussi possibledutiliser loprateurin

>>> dict1.keys()

[123, foo]

>>> dict1.has_key(bar)

False

>>> 123 in dict1

True

La mthode valuesdonne accs une liste des valeurs contenues dans le dictionnaire et lamthodeitemsdonne une liste de tuples, contenant chacun une paire cl, valeur.

>>> dict1.values()

[bar, 456]

>>> dict1.items()

[(123, bar), (foo, 456)]

La modification dune valeur associe une cl se fait simplement en affectant de nouveau lavaleur indexe dans le dictionnaire par la cl en question. Enfin, loprateur delpermet desupprimer une association du dictionnaire.

>>> dict1[123] = 789

>>> dict1

{123: 789, foo: 456}

>>> del dict1[foo]

>>> dict1

{123: 789}

A laides des mthodes de manipulation des cl et des valeurs, il est possible de parcourir undictionnaire de plusieurs manires. Les quelques lignes suivantes donnent deux exemples deparcours.

>>> flames = {windows: bof, unix: cool}

>>> for key in flames.keys():

... print key, is, flames[key]

...

windows is bof

unix is cool

>>> for key, value in flames.items():

... print key, is, value

...

windows is bof

unix is cool



21/108


3.3 Constructions

3.3.1 Structuration et indentation

La structuration dun programme Python est dfinie par son indentation. Le dbut dun blocest dfini par un :, la premire ligne pouvant tre considre comme un en-tte (test, boucle,dfinition, etc.). Le corps du bloc est alors indent de manire plus importante (mais rgulire)que len-tte. Enfin, la fin du bloc est dlimit par le retour lindentation de len-tte. Laconvention en Python est dutiliser quatre espaces pour chaque niveau dindentation. Les blocpeuvent tre imbriqus.

:

Dans le cas de bloc de taille rduite, par exemple une seule instruction, un bloc peut tre dfinisur une seule ligne. Le caractre : sert toujours dlimiter len-tte du corps. Cependant, cetteutilisation nest pas vraiment bnfique quant la lisibilit du code, si ce nest pour faire tenirdu code sur un transparent. Elle est donc viter, lpoque o les caractres taient comptsdans un fichier est bien rvolue.

:

Cette structuration est utilise aussi bien pour dfinir des boucles, des tests, des fonctions, desclasses ou encore des mthodes.

3.3.2 Tests

Conditions boolennes En Python, tout ce qui nest pas faux est vrai. Les conditions boo-lennes fausses se rsument au donnes vide en plus du faux :

False, None, 0, "", [], list(), {}, dict(), (), tuple()

Expression boolennesPython propose les oprateurs de comparaison et les oprateurs boo-len suivants :

=, !=, ==, is

and, or, not

Lutilisation du==permet de comparer lquivalence de valeurs (donc dobjets), alors que ispermet de comparer si deux variables rfrence une mme instance.

>>> l1 = [1, 2, 3]

>>> l2 = [1, 2, 3]

>>> l1 == l2

True

>>> l1 is l2

False

>>> l3 = l1

3.3. Constructions 17


22/108


>>> l3 is l1

True

Python offre une seule construction pour raliser des tests : le if then else. Une particu-larit de cette mise en oeuvre est la possibilit denchaner les tests avec la construction elif.Leelseet leelifsont bien sr optionnels. Enfin, a clauseelifpeut tre utilise plusieursfois dans un mme bloc.

if x == hello:

print hello too!

elif x == bonjour:

print bonjour aussi!

else:

print moi pas comprendre

Depuis la version 2.5, il est aussi possible dutiliser une expression conditionnelle (par opposi-tion laconstructionifdu paragraphe prcdent)

oeufs = 4 if souhaite_une_tarte() else 0

Labsence du switchse justifie par le fait que Python est un langage objet. Dans cette ap-proche, lutilisation du polymorphisme replace naturellement le switch. Lorsque lon ne d-veloppe pas avec une approche objet, le switch se remplace simplement par lutilisation dundictionnaire. Ce dictionnaire contient, par exemple, des fonctions associes des cls (pas n-cessairement des chanes) pour choisir la bonne fonction en fonction du contexte

traitements = {

en: traiter_anglais,

de: traiter_allemand,

fr: traiter_francais,

# etc.

}

def traiter_commande(langue, commande):

traiter = traitements[langue]

traiter(commande)

Les comparaisons entre chanes de caractres se fait selon lordre lexicographique. Les compa-raisons entre listes et tuples se fait lments par lments de la gauche vers la droite.

>>> abc < abd

True

>>> abc < abcd

True

>>> (1, 2, 3) < (1, 2, 4)

True

>>> (1, 2, 3) < (1, 2, 3, 4)

True

>>> (1, 2, 3, 4) < (1, 2, 4)

True



23/108


3.3.3 Boucles

Deux types de boucles sont disponibles : les boucles numres (for) et les boucles bases surun test de fin (while). Ces deux constructions suivent le mme schma : un en-tte qui dcritlvolution de la boucle, un ensemble dinstructions qui sont values chaque tour de boucleet une partie optionnel qui est value en sortie de boucle (introduite par le mot-cl else).Enfin, comme en C les boucles peuvent contenir les branchements continuepour passer litration suivante et breakpour sortir de la boucle (dans ce cas la clause elsenest pasvalue).

Boucles numres

Une boucle for dfinit une variable qui prend successivement toutes les valeurs de la squence(liste ou tuple) parcourue (ligne 1). La clause elseest valu lorsque la squence est puise

et sil ny a pas eu de sortie de boucle avec un break(ligne 3).

for in :

else:

La fonctionrangeproduit une liste de tous les entiers entre une borne infrieur et une bornesuprieur. Cette construction est utile lorsquune boucle forrepose sur lutilisation dune s-quence dentiers. La fonctionrangeest utilisable de trois manires : un seul paramtre spcifiant le nombre dlments (ligne 1),

deux paramtres spcifiant la borne infrieure (inclue) et suprieure (exclue) (ligne 3), trois paramtres spcifiant les bornes et le saut (incrment entre deux lments de la s-

quence) (ligne 5).

>>> range(6)

[0, 1, 2, 3, 4, 5]

>>> range(3, 7)

[3, 4, 5, 6]

>>> range(0, 10, 3)

[0, 3, 6, 9]

Boucleforparcourant une squence de chane.

>>> a = [hello, world]

>>> for elt in a:

... print elt

...

hello

world

Boucle parcourant une liste de valeurs pour accder aux lments dune liste.

>>> for idx in range(len(a)):

... print idx, a[idx]

...



24/108


0 hello

1 world

Sil est ncessaire de parcourir une squence tout en connaissant lindex de llment courant,la fonctionenumerateest une solution plus pythonesque.

>>> for idx, val in enumerate(a):

... print idx, val

...

0 hello

1 world

Enfin, une chane tant une squence de lettre, elle peut tre parcourue comme une squence.

>>> for lettre in bar:

... print lettre

...b

a

r

Boucles avec condition

Une boucle whiledfinit une condition boolenne avec les mme rgles que pour les tests(ligne 1). Tant que cette condition est respecte, les instruction du bloc associ au whilesontvalues. La clause elseest valu lorsque la condition est fausse et quil ny a pas eu desortie de boucle avec unbreak(ligne 3).

while :

else:

La boucle suivante reprsente la boucle minimale dfinissable avec un while. Certes, elle eststupide mais elle permet dillustrer lutilisation du Ctrl-Cpour interrompre un traitement encours dexcution.

>>> while 1:... pass

...

KeyboardInterrupt

3.3.4 Fonctions

Il ny a que des fonctions en Python (et non une distinction entre fonction et procdures commedans certains langages). Une fonction est dfinie avec le mot cl def. Une fonction retourne

toujours une valeur. Si une fonction ne contient pas de clause return, la valeur Noneestalors retourne.



25/108


>>> def fib(n): # suite de fibonacci jusque n

... a, b = 0, 1

... while b < n:

... print b,

... a, b = b, a + b

...

>>> fib(100)

1 1 2 3 5 8 1 3 2 1 3 4 5 5 8 9

Les paramtres dune fonction peuvent tre dfinis avec une valeur par dfaut. A lutilisationde la fonction, ces paramtres sont alors optionnels. Dans le cas dune fonction avec des para-mtres optionnels, lutilisation des paramtres doit tre ordonne, les paramtres sont affectsdans lordre de leur dfinition, ou nomme.

>>> def welcome(name, greeting=Hello, mark=!):

... print greeting, name, mark

...

>>> welcome(world)

Hello world !

>>> welcome(monde, Bonjour)

Bonjour monde !

>>> welcome(world, mark=...)

Hello world ...

Python permet de dfinir des fonctions anonymes, en utilisant la forme lambda 5. Une tellefonction est rduite une simple expression. Cette construction est utile pour passer des fonc-

tions en paramtre dautre fonctions pour les configurer ou dans le cas deslist mappings(voirsection [subChap1List]). Nous verrons un peu plus tard que ce nest pas la seule possibilit.

>>> def compare(a, b, func=(lambda x,y: x < y)):

... return func(a,b)

>>> compare(1, 2)

True

>>> compare(1, 2, func=(lambda x,y: x > y))

False

3.3.5 Documenter

La documentation fait partie intgrante du code. En plus de la possibilit de mettre des com-mentaires avec lutilisation de #, Python offre la possibilit dcrire du code auto-document.Ceci est valable pour les fonctions, les classes et les modules. Une telle documentation dunlment est accessible vie lattribut__doc__de ces diffrents lments. Cette technique estutilisable automatiquement par les environnements intgrs de dveloppement ou par lutilisa-tion de la fonction helpen mode interactif.

La dfinition des commentaires avec #devrait tre rserv aux remarques techniques sur le

code et pour les dveloppeur de llment en question. La documentation doit quant elle tre5. Ici encore, cela sent la programmation fonctionnelle type Lisp plein nez...



26/108


destine au dveloppeurs mais surtout aux utilisateurs de llment document. Elle doit doncreflter le comportement de llment. Cette seconde forme est mettre en parallle avec lajavadocpour les habitu(e)s.

La dfinition de la documentation se fait sur la premire ligne aprs la dclaration en utilisant

des chanes de caractres multi-lignes, mme si la documentation tient sur une seule, en utili-sant des guillemets doubles (ligne 2-5). Une bonne manire de dfinir la documentation est defournir une version courte sur une ligne, de passer une ligne et de fournir des dtails.

>>> def dummy():

... """Cette fonction est du pipeau...

...

... Cette fonction est vraiment du pipeau,

... elle ne fait absolument rien."""

... pass

>>> help(dummy)Help on function dummy in module __main__:

dummy()

Cette fonction est du pipeau...

Cette fonction est vraiment du pipeau,

elle ne fait absolument rien.

3.4 Autres lments sur les squences3.4.1 Fonctions de manipulation de squences

Python offre un certain nombre de fonction permettant dappliquer des traitements sur tous leslments dune squence afin de dfinir des filtres, de raliser des calculs ou de calculer deshashcode.

Filtre

La fonction filter applique la fonction passe en premier argument sur chacun des lmentsde la squence passe en second argument et retourne une nouvelle liste qui contient tous leslments de la squence pour lesquels la fonction a retourn une valeur vrai.

>>> def funct1(val):

... return val > 0

...

>>> filter(funct1, [1, -2, 3, -4, 5])

[1, 3, 5]

>>> def iseven(x):

... return x % 2

...



27/108


>>> filter(iseven, [1, 2, 3, 4, 5, 6])

[1, 3, 5]

Application

La fonctionmapapplique la fonction passe en premier argument sur chacun des lments dela ou des squences passes en paramtre. Dans le cas o plusieurs squences sont passes enparamtre, la fonction doit prendre autant de paramtres quil y a de squences.mapretourneune liste contenant le rsultat de chacun des calculs.

>>> def sum(x, y):

... return x + y

...

>>> map(sum, [1, 2, 3], [4, 5, 6])

[5, 7, 9]>>> map(iseven, [1, 2, 3, 4, 5, 6])

[1, 0, 1, 0, 1, 0]

Rduction

La fonction reduce rduit une squence par lapplication rcursive dune fonction sur chacunde ses lments. La fonction passe comme premier paramtre doit prendre deux arguments.La fonction reduce prend un troisime paramtre optionnel qui est la valeur initiale du calculrcursif.

>>> reduce(sum, [1, 2, 3, 4, 5])

15

>>> reduce(sum, [1, 2, 3, 4, 5], -5)

10

3.4.2 Listes en comprhension

La dfinition de listes en comprhension 6 permet de crer des listes de manire concise sans

utiliser aux fonctionsmap,filter, etc.Lexemple suivant (ligne 2) permet dappliquer une mme opration tous les lments duneliste. Cet exemple est donc similaire lutilisation de la fonction map. La suite (ligne 4) permetde ne slectionner que certains lments de la liste, ici les nombres impaires. Cet exemple estsimilaire lutilisation de la fonction filter. La ligne 6 montre une combinaison des deuxformes, en levant au carr les nombres pairs de la listefoo.

>>> foo = [1, 2, 3, 4]

>>> [elt * 2 for elt in foo]

[2, 4, 6, 8]

6. Comprhension : Ensemble des caractres qui appartiennent un concept et servent le dfinir.Dfinir unensemble en comprhension. Par opposition en extension.

3.4. Autres lments sur les squences 23


28/108


>>> [elt for elt in foo if elt % 2]

[1, 3]

>>> [elt**2 for elt in foo if elt % 2 is 0]

[4, 16]

Il est enfin noter que lutilisation de ces constructions est en gnral plus performante quelutilisation dune boucle for. En effet, leur mise en oeuvre est faite au coeur de linterprteau lieu dtre interprte.

3.4.3 Itrateurs et gnrateurs

Les itrateurs (PEP 234) et les gnrateurs (PEP 255) sont apparus avec les versions 2.2 et 2.3de Python. Ils sont monnaie courante depuis Python 2.4, et leur usage est recommand.

Itrateurs

Lapparition des itrateurs a modifi la philosophie des boucles forpour le parcours de s-quences. Dans les version prcdentes de Python, litration sur une squence se faisait enutilisant lindex pour accder aux lments de la squence. Lorsque la squence tait termine,lexceptionIndexError(voir section [sec :chap3 :exceptions] pour les exceptions) signalaitla fin de litration.

Dsormais, un itrateur est un objet (voir le chapitre [chap3] pour les objets) auquel on demandellment suivant. Lorsquil ny a plus de suivant, lexception StopIteration signale la fin

de litration. Les types de bases comme les listes, dictionnaires, tuples retournent dsormaisdes itrateurs pour leur parcours. Ces itrateurs sont utiliss automatiquement par les bouclesforet par loprateur inpar exemple.

La dfinition dun itrateur peut se faire avec la fonctioniterdes deux manires suivantes :soit largument est une squence (ou fournit un itrateur), soit le paramtre est une fonctionqui sera appele tant que la sentinelle nest pas retourne par la fonction. Lexemple suivantprsente la premire formes.

>>> iter([1,2,3,4])

Gnrateurs

Les gnrateurs peuvent tre considrs comme une volution des listes en comprhension.Syntaxiquement, les []ou list()deviennent des (), comme le montre lexemple suivant.Une des diffrences entre les deux formes concerne lutilisation de la mmoire : un gnrateurne construit pas toute la squence en mmoire a priori, mais chaque lment de la squenceest produit lorsque cest ncessaire. Pour obtenir une squence construite par un gnrateur, ilsuffit de passer le gnrateur en paramtre de la construction dune liste 7.

7. Depuis Python 2.4, la notation des listes en comprhension revient la construction dune liste partir dungnrateur.



29/108


>>> (elt * 2 for elt in foo)

>>> for i in (elt * 2 for elt in foo):

... print i,2 4 6 8

>>> list(elt * 2 for elt in foo)

[2, 4, 6, 8]

La dfinition de fonctions gnrateurs se fait en utilisant le mot cl yield. Le droulement dela fonction est interrompu chaque utilisation de yield, le reste sera valu lorsque lappelantdemandera le prochain lment. Le yield peut tre considr comme un return qui ne metpas fin lexcution de la fonction.

Lorsquil est appel, un gnrateur retourne un itrateur, ce qui permet une utilisation dans une

bouclefor

comme dans lexemple suivant. Cest lutilisation de litrateur retourn qui pilotele droulement du gnrateur : lexcution sarrte sur le yieldqui est valu chaque appeldu suivant sur litrateur.

>>> def generateur():

... i = 0

... while i < 10:

... yield i

... i += 1

...

>>> for i in generateur():

... print i,

...

0 1 2 3 4 5 6 7 8 9

3.4.4 Boucles numres problmatiques

Certaines boucles de manipulation des listes peuvent tre problmatiques, par exemple si laboucle modifie la liste quelle est en train de parcourir. Pour que ce genre de boucle se passebien, et ne soit pas sans fin, il est important dans certains cas de faire une copie de la listepour le parcours et de travailler sur la version originale de la liste. Par dfaut, tout argument estpass par rfrence et donc sans copie (en fait copie de la liste des rfrences et non des objetscontenus) la boucle suivante serait sans fin : Cette boucle rajoute les lments positifs en dbutde liste, comme le premier lment est positif cette boucle est toujours sur llment 1 alorsque la liste ne fait que crotre.

>>> a = [1, -2, 3, -4, 5, -6]

>>> for elt in a [:]:

... if elt > 0: a.insert(0, elt)

...

>>> a

[5, 3, 1, 1, -2, 3, -4, 5, -6]

3.4. Autres lments sur les squences 25


30/108


3.5 Exercices

3.5.1 Manipulations de donnes

Le fichierlistetu.pycontient une liste de 10 dictionnaires. Etudier cette structure de don-nes et dfinir une fonction qui crit chaque fiche sur la sortie standard de la manire suivante(en sautant une ligne entre chaque fiche) :

dossier : 1

nom : doe

prenom : john

universite : lille1

discipline : informatique

niveau : 4

moyenne : 17



31/108

CHAPITRE 4

Quelques modules etbuilt-in

4.1 Dfinition et utilisation de modules

4.1.1 Dfinition

Dans le chapitre prcdent, lensemble des extraits de code ont t saisis de manire interactive.Cette mthode nest pas viable pour les traitements que lon excute plusieurs fois ou que lonsouhaite excuter sur plusieurs machines. Pour rendre le code persistant, la premire solutionest dcrire un programme, cest--dire de saisir le code dans un fichier texte avec lextension.py. Un programme peut ainsi tre excut plusieurs fois. Cependant, mme si ce programme

est correctement structur avec des fonctions, il nest pas possible de rutiliser facilement cesdernires (si ce nest avec un copier-coller qui est une abomination).

Pour capitaliser les dveloppement, Python propose la notion de module. Un module permet defournir des bibliothques de fonctions, structures de donnes, classes, intgrer dans les pro-grammes. Dans le cas de python, produire un module est identique produire un programme :faire un fichier. Les dfinitions contenues dans un fichier sont utilisable globalement ou unitai-rement. Ainsi, le fichier examples.pypeut tre utilis comme un module (nomm commele fichier) et offrir laccs aux deux fonctions tout programme en ayant lutilit.

La chane de documentation doit tre mise avant toute dclaration (cest--dire aussi avant les

clauses import) pour tre considre comme documentation du module. Les deux premireslignes de ce fichier (optionnelles) ont la significations suivante : la premire ligne de ce fichier indique que ce fichier sera reconnu comme un programme

Python par un environnement Unix (sil a les droits en excution) 1 ; la seconde ligne prcise le type dencodage du fichier : ici lencodage utf-8 supportant la

gestion des accents. Ds quun fichier Python contient un accent, cette ligne est obligatoire(dans le cas contraire elle peut tre omise).

#! /usr/bin/env python

# -*- coding: utf-8 -*-

#

# examples.py

1. La construction#!sert prciser, sous Unix, le programme utiliser pour excuter un script.

27


32/108


#

"""

Regroupe les dfinitions des fonctions relatives au chapitre 1 de

Initiation a python par lexemple.

"""

def fib(n):

"""Calcule la suite de Fibonacci jusque n"""

a, b = 0, 1

while b < n:

print b,

a, b = b, a + b

def welcome(name, greeting=Hello, mark=!):

"""Un hello world configurable"""

print greeting, name, mark

Utilisation dun module

La construction importpermet dimporter un module et de fournir accs son contenu 2.Limportation dun module peut se faire de deux manire. La premire solution est de dsignerle module que lon souhaite utiliser, son contenu est alors utilisable de manire scope, cest--dire en prfixant le nom de la fonctionnalit du nom du module (ligne 2). La seconde solutionrepose sur la construction from importo lon identifie la ou les fonctionnalits que lon

souhaite importer dun module (ligne 4). Dans le cas dun import de plusieurs fonctionnalits,les noms sont spars par des virgules. Lutilisation se fait alors sans prfixer par le nom demodule (non scop). Enfin, il est possible dimporter, avec cette seconde approche, tousles lments dun module en utilisant la notation * (ligne 7). Attention, avec cette dernireforme car il y a pollution du namespace global : deux imports conscutifs peuvent chargerdeux dfinition dune mme fonction. La seconde masquera la premire.

>>> import examples

>>> examples.welcome(raphael)

Hello raphael !

>>> from examples import welcome

>>> welcome(raphael)

Hello raphael !

>>> from examples import *>>> fib(100)

1 1 2 3 5 8 1 3 2 1 3 4 5 5 8 9

Utilisation mixte

Un fichier peut la fois dfinir un module et un programme. Cette dfinition mixte est int-

ressante pour, par exemple, utiliser les fonctionnalits dun programme indpendamment de2. Nous considrons ici que linterprte a t lanc dans le rpertoire contenant le fichierexamples.py.

28 Chapitre 4. Quelques modules etbuilt-in


33/108


celui-ci, ou pour associer le code de test un module. Dans ce cas, la fin du fichier contient ladfinition de linitialisation du code comme un programme. Pour cela, un test est ralis afin desavoir si le code est import ou excut. Si le code est import, la variable __name__contientle nom du module, sinon elle contient la chane __main__. Ici, dans le cas dune excutioncertaines des fonctions du module sont testes. (Sinon il ne se passe rien.)

if __name__ == __main__:

welcome(world)

welcome(monde, Bonjour)

welcome(world, mark=...)

fib(100)

Lutilisation du fichier examples comme un programme donne la trace dexcution suivante.Que lon utilise explicitement linterprte ou non (du fait de la premire ligne du fichier) latrace est identique.

$ python examples.py

Hello world !

Bonjour monde !

Hello world ...

1 1 2 3 5 8 1 3 2 1 3 4 5 5 8 9

$ l s - l

total 100

-rwxr-x--- 1 raphael raphael 1046 2005-03-11 11:51 examples.py*$ ./examples.py

Hello world !

Bonjour monde !

Hello world ...

1 1 2 3 5 8 1 3 2 1 3 4 5 5 8 9

Remarques

Lors de lutilisation de la construction import, linterprte recherche la disponibilit des mo-dules demand dans le chemin dcrit par la variable denvironnement PYTHONPATH. La valeurpar dfaut de cette variable contient le rpertoire dinstallation de Python et le rpertoire cou-rant.

Lors de lutilisation de la construction from module import *, tout le contenu du module estimport lexception des dfinition dont le nom commence par un_(qui refltent la notion depriv en Python). Lutilisation de ce type dimportation allge le code saisi, ce qui est intressanten interactif. Toutefois, une fois le prfixe par le nom de module perdu il peut de nouveau yavoir des conflits de noms entre les fonctionnalits importes depuis plusieurs modules.

Enfin, les modules peuvent tre organiss selon une structure hirarchique. Dans ce cas, lesmodules contenant des sous-modules, encore nomms packages, sont dfinis comme des r-pertoires sur le systme de fichier. Le nommage des modules se fait alors par concatnation :mod.submod. Afin de faciliter la portabilit du code, tout rpertoire doit contenir un fichier

nomm __init__.py

. Pour permettre le chargement de tous les sous-modules, ce fichierdoit contenir la liste des modules du package (rpertoire) stocke dans la variable __all__.

4.1. Dfinition et utilisation de modules 29


34/108


$ cat graphical/__init__.py

__all__ = [basic, advanced]

4.2 Quelques modules standards

Python offre un grand nombre de modules. Ne sont prsents ici que les quatre modules consi-drs comme incontournables (Cest--dire ceux que lauteur utilise couramment) : sysfournit les paramtres et fonctions lies lenvironnement dexcution, string fournit des oprations courantes sur les chanes de caractres (quivalentes aux

mthodes de la classe stringplus quelques bonus), refournit le support des expressions rgulires pour faire dupattern matchinget des sub-

stitutions,

osfournit laccs aux services gnriques du systme dexploitation.Pour chacun de ces modules, les fonctionnalits de base sont prsentes et illustres sur desexemples.

4.2.1 Le modulesys

Quelques constantes

argvSquence des paramtres pass sur la ligne de commande (argv[0]reprsente le nomdu script).

stdin stdout stderrObjets de type file(fichier) reprsentant les entres et sortiesstandard. Ces objets peuvent tre remplacs par tout objet offrant une mthode write.

pathSquence contenant les chemins de la variable denvironnement PYTHONPATH. Cettesquence peut tre manipule dynamiquement.

>>> sys.path.append(/tmp/python)

[, /home/raphael, /usr/lib/python2.6, /usr/lib/python2.6/plat-linux2,

/usr/lib/python2.6/lib-tk, /usr/lib/python2.6/lib-old,

/usr/lib/python2.6/lib-dynload, /usr/lib/python2.6/dist-packages,

/var/lib/python-support/python2.6, /usr/local/lib/python2.6/dist-packages,/tmp/python]

platformNom du systme dexploitation.

# sous linux

>>> sys.platform

linux2

# sous OSX

>>> sys.platform

darwin

ps1, ps2Variables contenant les valeurs des prompts, par dfaut >>> et ....



35/108


Quelques fonctions

exit([arg])Mettre fin lexcution dun programme, argtant le statut de sortie pour lesystme dexploitation. Cette fonction respecte le nettoyage des clauses finally (voir sectionref{sec :chap3 :exceptions}).

4.2.2 Le modulestring

Ce module fournit un certain nombre de constantes et de fonctions de manipulation des chanesde caractres. Il est gnralement recommand dutiliser les mthodes disponibles sur les objetsde typestringquivalentes.

>>> import string

Quelques constantes

Des constantes pratiques offertes par le module stringdfinissent des ensembles de carac-tres :

>>> string.lowercase

abcdefghijklmnopqrstuvwxyz

>>> string.uppercase

ABCDEFGHIJKLMNOPQRSTUVWXYZ

>>> string.letters

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz>>> string.digits

0123456789

>>> string.whitespace

\t\n\x0b\x0c\r

>>> string.punctuation

!"#$%&\()*+,-./:;?@[\\]^_{|}~

Les fonctions principales

lower upper cap*permettent de grer la casse dune chane de caractres : mise en mi-nuscules, en majuscules, capitalisation de la phrase ou des mots (avec la rduction des espaces).

>>> string.lower(FOO)

foo

>>> string.upper(foo)

FOO

>>> string.capitalize(foo)

Foo

>>> string.capwords( hello world! )

Hello World!

4.2. Quelques modules standards 31


36/108


strip expandtabspermettent de grer les espaces dans une chane de caractres en sup-primant les blancs non significatifs ou en remplaant les tabulations par un nombre fixe des-paces.

>>> string.strip( hello world! \n ) # [2nd arg]

hello world!>>> string.expandtabs(\thello world!, 4)

hello world!

find permet de rechercher un motif dans une chane ( partir du dbut ou de la fin pourrfind) en retournant lindice o le motif est trouv pour la premire fois ou -1. (La fonctionindexest similaire mais lve une exception pour un motif non trouv.)

>>> string.find(bonjour le monde, on)

1

>>> string.rfind(bonjour le monde, on)

12>>> string.rfind(bonjour le monde, om)

-1

split permet de dcouper une chane en une liste de mots (par dfaut sur les espaces, oualors sur une chane passe en second argument) etjoinpermet lopration inverse qui est deconstruire une chane partir dune liste de mots et une chane de liaison.

>>> string.split(foo bar 123)

[foo, bar, 123]

>>> string.split("hello world", "wo")

[hello , rld]>>> string.join([foo, bar, 123], ;)

foo;bar;123

count replacepermettent respectivement de compter les occurrence dun motif dans unechane et le remplacement de ce motif par un autre.

>>> string.count(bonjour le monde, on)

2

>>> string.replace(bonjour le monde, on, ONON)

bONONjour le mONONde

zfill center rjust ljust permettent de grer laffichage : zfill complte unnombre avec des zros en tte pour une largeur daffichage constant, les trois autres fonctionspermettent de justifier une phrase sur une largeur donne.

>>> string.zfill(str(123), 5)

00123

>>> string.center(hi!, 10)

hi!

>>> string.rjust(hi!, 10)

hi!

>>> string.ljust(hi!, 10)

hi!



37/108


4.2.3 Le modulere

Ce module permet la manipulation des expressions rgulires 3.Ces expressions sont par dfautidentiques Perl et louvrage Mastering Regular Expressions de Jeffrey Friedl(OReilly) est

un bon complment pour qui doit utiliser les expressions rgulires. Afin de ne pas devoir tou-jours utiliser des \ dans les expressions, il est possible dutiliser des Raw regular expressionsen prfixant la chane dfinissant lexpression par un r : r(.*)\n.

>>> import re

Oprations de recherche

search(pattern, chaine) permet de rechercher le pattern dans la chane et retourne unobjet de typeSRE_Matchdcrivant la rponse ou bien None. La classeSRE_Matchfournit

des mthodes pour obtenir lindice de dbut (start()) et de fin (end()) du motif dans lachane. Ici, la mthode matchingutilise span()qui fournit un tuple contenant les deuxindices.

>>> def matching(res):

... if res: print res.span()

... else: print no matching

>>> matching(re.search(ada, abracadabra))

(5, 8)

match(pattern, chaine)test si la chane commence par le pattern et retourne un objet

de typeSRE_Matchdcrivant la rponse ou bien None.

>>> res = re.match(abr, abracadabra)

>>> matching(res)

(0, 3)

Oprations de manipulation

split(pattern, chaine)dcoupe la chane par rapport au pattern. Lexemple suivantfait un dcoupage en mots (tout ce qui nest pas espace ou ponctuation).

>>> re.split(\W+, Hello world !)

[Hello, world, ]

sub(pattern, repl, chaine)retourne une chane ou toutes les occurrences du pat-tern dans la chane fournie sont remplacs par repl. La chane nest pas modifie, une copieest cre 4.

>>> re.sub(hello, bonjour, hello foo hello bar)

bonjour foo bonjour bar

3. Voirhttp ://www.amk.ca/python/howto/regex/4. En Python les chanes sont des objets immuables, toute modification dune chane entrane en fait lacration dune nouvelle chane contenant la version modifie.

http://www.amk.ca/python/howto/regex/http://www.amk.ca/python/howto/regex/


38/108


Utilisation dexpressions compiles

Lorsquune expression rgulire est utilise de manire rptitive dans un programme, il de-vient intressant de compiler le motif rechercher. Les fonctionnalits sont similaires cellesvues prcdemment (mthodes) mais la performance est meilleure.

compilepermet la cration dun objet reprsentant lexpression rgulire sous forme compi-le. Un fois lobjet cr, les fonctions sont appeles sur cet objet et non par rapport au module.La mthodegroup()sur lobjet SRE_Matchdonne accs aui-me motif (dans le cas duneexpression compose de plusieurs motifs 5 comme ici) trouv par la fonction search.

>>> exp = re.compile((.*))

>>> res = exp.search(Cliquer ici!)

>>> matching(res)

(8, 34)

>>> res.group(0)

ici>>> res.group(1)

foo.html

>>> res.group(2)

ici

>>> exp = re.compile(r.*.*.*)

>>> exp.sub(r\1, Cliquer ici!)

foo.html

4.2.4 Le moduleos

Ce module permet daccder aux fonctions des systmes dexploitation et de faire de la pro-grammation ou de ladministration systme. Les fonctions sont disponibles sur (presque) tousles systme. Toutefois, il faut toujours tre conscient des limites pour la portabilit du code : lanotion de droits sur un fichier nest pas similaire sur tous les systmes.

Les principaux sous modules deossont : pathmanipulation de chemins, glob fnmatchpattern matching de fichiers et rpertoires,

timeaccs et manipulation de lheure, getpassmanipulation de mots de passe et identifiants. utilisateur

>>> import os

Quelques constantes

name donne le nom de limplmentation du module os : posix, nt, dos, mac,java,etc.

5. Un motif au sein dune expression rgulire est dfini par des parenthses.



39/108


>>> os.name

posix

environ est un dictionnaire contenant les variables denvironnement (au sens Unix mais aussi

relatives au lancement de linterprte Python).>>> os.environ

{USER: raphael, HOME: /home/raphael,

PATH: /bin:/usr/bin:/opt/bin:/home/raphael/bin,

HOSTNAME: alfri.lifl.fr,

PWD: /home/raphael/enseign/python/scripts}

4.2.5 Le moduleos.path

Ce module fournit quelques primitives (courantes sous les environnements Unix) de manipula-tion des noms de fichiers et des fichiers.

basename dirname permettent respectivement dextraire dun chemin le nom du fichier oule nom du rpertoire (ou de larborescence dans le cas dun chemin compos).

>>> os.path.basename(/tmp/foo.txt)

foo.txt

>>> os.path.dirname(/tmp/foo.txt)

/tmp

split join permettent respectivement de dcouper et de construire un chemin. Lutilisationde la fonction joinest fortement recommande pour construire des chemin car elle respecteimplicitement le bon sparateur de chemin pour le systme courant.

>>> os.path.split(/tmp/foo.txt)

(/tmp, foo.txt)

>>> os.path.join(/tmp, foo.txt)

/tmp/foo.txt

exists isdir isfilepermettent de tester lexistence et le type dun fichier (ou rper-toire).

>>> os.path.exists(/tmp/bar.txt)

False

>>> os.path.isdir(/tmp)

True

>>> os.path.isfile(/tmp)

False

4.2.6 Les modules globet fnmatch

Ces deux modules fournissent principalement une fonction portant le mme nom.



40/108


glob est lquivalent du ls Unix. Cette fonction retourne une liste des fichiers dun rpertoireavec utilisation dejockers.

>>> import glob

>>> glob.glob(*.py)

[hello.py, examples.py]>>> glob.glob(/tmp/*.tmp)

[/tmp/sv3e2.tmp, /tmp/sv001.tmp, /tmp/sv3e4.tmp]

fnmatch et filterpermettent de faire du pattern matching sur des chanes de caractresreprsentant des noms de fichiers : respectivement est ce quun nom suit un pattern de nommageet quels sont les lments dune liste respectant un pattern.

>>> import fnmatch

>>> fnmatch.fnmatch(examples.py, *.py)

True

>>> fnmatch.filter([examples.py, hello.pyc], *.py)[examples.py]

4.2.7 Le modulegetpass

Ce module permet de demander au systme le nom de lutilisateur connect et de demander demanire cache un mot de passe.

>>> import getpass

getuser()demande au systme le nom de login de lusager.

>>> getpass.getuser()

raphael

getpass() demande proprement (en masquant les caractres saisis) un mot de passe lusa-ger. Lappel cette fonction est bloquant jusqu ce que lusager ait tap entre.

>>> p = getpass.getpass() # bloquant jusquau \n

Password:

>>> print p

quelmauvaismotdepasse

4.3 Built-in en Python

Les built-insont les fonctionnalits cbles en dur dans linterprte Python, et dans un cer-tain sens linterprte lui-mme. Ces fonctionnalits ne sont pas crite en Python car elles sontplus que largement utiliseset leur mise en {oe}uvre en C contribue obtenir de meilleuresperformances.



41/108


4.3.1 Les fichiers

Les objets fichiers

Les fichiers sont reprsents comme des objets de type file. Ils peuvent tre textuels oubinaires et tre utiliss en lecture ou en criture.

openouvre un fichier (cre lobjet associ) en lecture par dfaut.

>>> foo = open(/tmp/foo.txt)

>>> foo

closeferme un fichier (mais ne dtruit pas lobjet associ).

>>> foo.close()

>>> foo

Lecture dans un fichier

Il y a plusieurs manires de lire un fichier.

readline() permet de lire une ligne (position courante jusquau prochain \n) la fois dansle fichier.

>>> foo = open(/tmp/foo.txt, r)>>> foo.readline()

hello world!\n

readlines() permet de lire toutes les lignes dun fichier en une seule fois (retourne unesquence de chanes).

>>> foo.readlines()

[bonjour le monde!\n, au revoir le monde!\n]

read([n])permet de lire tout le fichier partir de la position courante, ou au maximum n

octets lorsque un argument est donn. Cette fonction retourne une chane. La fonction seekpermet de se dplacer dans le fichier de faon absolue : ici nous retournons au dbut (indice 0).

>>> foo.seek(0) ; foo.read()

hello world!\nbonjour le monde!\nau revoir le monde!\n

>>> foo.close()

Comparaison des approches de lecture

Il ny a pas de solution idale pour la lecture des fichiers. Il faut choisir en fonction de la

situation et des besoins.

4.3. Built-in en Python 37


42/108


La lecture globale (readlines) dun fichier est plus performante pour laspect rcupra-tion des informations car elle reprsente un gros accs disque puis un parcours de squenceen mmoire. Toutefois, cette approche est coteuse en mmoire vive : imaginez la prsencedun fichier texte de 500Mo en mmoire.

Lecture ligne par ligne (readline) est plus coteuse pour lire un fichier car elle repr-sente de nombreux accs disques pour des petites quantits dinformation. Toutefois, cetteapproche permet de manipuler des gros fichiers : un fichier de 10Go peut tre lu ligne parligne sur une machine ayant 64Mo de mmoire.

Depuis Python 2.3, il est possible ditrer simplement ligne par ligne sur un fichier ouvert (sansavoir utiliser la fonctionreadline). Cette manire de faire repose sur les itrateurs (voir lasection ref{ssub :chap1 :iterateurs}).

>>> fichier = open(/tmp/foo.txt)

>>> for line in fichier:

... print line.strip()

...hello world!

bonjour le monde!

au revoir le monde!

>>> fichier.close()

Ecriture dans un fichier

Il faut quun fichier soit ouvert en criture pour pouvoir crire dedans, on le prcise donc

louverture en donnant un second paramtre w (Python suit les modes douverture du langageC, pour les fichiers binaires il faut prciser ben plus). Tant que le fichier nest pas ferm,son contenu nest pas garanti sur le disque.

writepermet dcrire des donnes (une chane de texte) reprsentant une ou plusieurs lignesde texte (utilisation de \n). Les donns peuvent aussi tre binaires.

>>> foo = open(/tmp/foo.txt, w)

>>> foo.write(hello world!\n)

writelines permet dcrire des donnes contenues dans une squence (de chanes). Si

chaque chane contenue dans la squence reprsente une ligne de texte dans le fichier, il fautalors quelles contiennent toute la squence de fin de ligne \n. Dans le cas contraire, toutsera crit dans le fichier, mais la notion de ligne sera dfinie par les \n contenus (mme silsntaient pas en fin dune des chanes).

>>> lines = [bonjour le monde!\n, au revoir le monde!\n]

>>> foo.writelines(lines)

>>> foo.close()



43/108


4.3.2 Conversions de types

Utilisation du nom des types pour convertir les chanes, en entiers, flottants, etc. (et rciproque-ment.) La fonctionstrpermet de convertir tout objet en chane.

>>> str(123)123

>>> int(123)

123

>>> float(123)

123.0

>>> float(123)

123.0

>>> long(123)

123L

4.3.3 Evaluation dynamique

Python permet dexcuter des commandes la vole 6 : une chane de caractres reprsentantune commande est excute. La chane peut tre compile explicitement ou non avant sonvaluation. Cette possibilit permet de faire de la gnration dynamique de commandes.

compile() retourne une version compile de lexpression (ou du fichier) pass en paramtre.Le second argument prcise o doit se faire la sortie derreur au cas o une exception seraitleve. Le dernier argument prcise quel usage est envisag, ici nous prvoyons de lutiliser

avec la fonctioneval().>>> obj = compile(x + 1, , eval)

>>> obj

eval()value une expression (compile ou non) pass en paramtre.

>>> x = 2

>>> eval( x + 1 )

3

>>> eval(obj)

3

4.3.4 Assertions

Les assertions permettent de traiter les situations sans appel : soit la condition est respecte,soit le programme est arrt. (Dans la pratique, une exception est leve.)

assert value une expression logique et arrte le programme en affichant un message derreur(qui est optionnel et fourni spar par une virgule) si lexpression logique est fausse (cf section

ref{sub :chap1 :tests}). Lexpression peut inclure des appels de fonctions.6. Bien que tout est dynamiquement valu en python, il est possible de faire des choses encore plus dynami-

quement, comme de la production de code excutable la vole.

4.3. Built-in en Python 39


44/108


>>> assert 1

>>> assert 0, oups



AssertionError: oups>>> try: assert 0

... except AssertionError: print sic

...

sic

4.4 Exercices

4.4.1 Utilitaire de sauvegarde

En saidant de la fonction os.stat qui permet de connatre la dates de modification desfichiers, crire un utilitaire de backup dune arborescence. Cet utilitaire doit faire un backupincrmental (sauf la premire fois) des fichiers modifis.

>>> help(os.stat)

Help on built-in function stat in module posix:

stat(...)

stat(path) -> stat result

Perform a stat system call on the given path.

4.4.2 Extraction de donnes

Cet exercice propose dutiliser des fonctions du module regular exressions pour extraire desdonnes dun fichier texte. Ecrire un programme analysant un fichier texte de type mbox et quiproduit la liste de toutes les personnes ayant envoy un e-mail, en triant la liste de leurs adressespar ordre alphabtique avec la date de le-mail reu le plus rcent.



45/108

CHAPITRE 5

Plongeon dans les objets

5.1 Des objets, rien que des objets

5.1.1 Rappels de principes de base en programmation oriente ob-jet

Instanciation

Un objet est cr partir dun moule, sa classe qui dfinit une structure (les attributs) et un

comportement (les mthodes). Une classe dfinit un type dobjets. Un objet est instance duneunique classe.

Encapsulation

Les donnes sont caches au sein des objets, et leur accs est contrl par les mthodes.Ltat dun objet ne devrait pas tre manipul directement si un contrle est ncessaire. Lobjetpeut tre vu comme un fournisseur de services (plus que de donnes).

Encapsulation nimplique pas attributs privs comme dans certains langages de programmation.

Un attribut priv ne protge pas dune utilisation abusive, mai considre le dveloppeur commeun danger. Python prend une approche diffrente : le dveloppeur a un cerveau, et donc, faisonslui confiance.

Polymorphisme

Des objets respectant une mme interface (la signature de mthodes suffit dans le cas de Py-thon) peuvent tre manipuls de manire gnrique, mme si leur type exact est diffrent. Ceprincipe permet aussi la substitution dune instance par une autre (tant que les interfaces sontcompatibles).

41


46/108


Hritage

Mcanisme qui permet la rutilisation de dfinitions de base, comportements par dfaut, et laspcialisation de certains comportements. La relation dhritage entre deux classes ne se limitepas une facilit de capitalisation de code. La classe qui hrite doit tre un de la classe dontelle hrite : un chat est un animal, chat peut donc tre une sous classe de animal. Mais unevoiture ne doit pas hriter dun moteur : une voiture nest pas un moteur elle contient un moteur.

5.1.2 Objets et rfrences

En Python, le monde est uniforme. Tout est objet: les chanes, les entiers, les listes, les fonctions, les classes, les modules, etc.

Tout est rifi et manipulable dynamiquement. Tout objet est manipul par rfrence: une variable contient une rfrence vers un objet et

un objet peut tre rfrenc par plusieurs variables. Une fonction, une classe, un module sont desespaces de nommage organiss de manire

hirarchique: un module contient des classes qui contiennent des fonctions (les mthodes).

5.1.3 Classes

Dfinition et instanciation

La dfinition dune classe suit la rgle des blocs (cf section ref{sub :chap1 :blocs}) en utilisant

le mot cl class. (Voir la section sur lunification des types et des classes pour une explicationsur lhritage explicite deobject).

>>> class Empty(object):

... pass

Toute mthode est dfinie comme une fonction avec un premier argument (self) qui repr-sente lobjet sur lequel elle sera applique lexcution. En Java ou C++, le thisest dfinieimplicitement, en Python il est explicite est cest toujours le premier paramtre dune mthode.Le nom est libre, mais on utilise en gnralself. Une mthode ne prenant pas de paramtresaura donc quand mme un argument.

>>> class Dummy(object):

... def hello(self):

... print hello world!

Linstanciation se fait sans mot cl particulier (il ny a pas de newen Python). Il suffit de fairesuivre un nom de classe de parenthses (contenant ou non des paramtres) pour dclencher uneinstanciation. Linvocation se fait laide de la notation pointe, un appel de mthode sur unevariable rfrenant un objet.

>>> d = Dummy()

>>> d

42 Chapitre 5. Plongeon dans les objets


47/108


>>> d.hello()

hello world!

Dfinition dattributs et du constructeurLes attributs sont dfinis leur premire affectation. Une variable est considre comme unattribut si elle est rattache lobjet : elle est accde par self. Tout accs un attribut ou une mthode de lobjet depuis sa mise en oeuvre se fait obligatoirement par la variableself.Le constructeur est une mthode nomme__init__. Comme toute mthode, certain de sesparamtres peuvent avoir des valeurs par dfaut. Cette possibilit est important car une classea un seul constructeur en Python (contrairement dautre langages).

>>> class Compteur(object):

... def __init__(self, v=0):

... self.val = v

... def value(self):

... return self.val

En termes de gnie logiciel (et de bon sens), il est recommand de toujours initialiser ltat desobjets (ses attributs) lors de son instanciation, donc dans le constructeur.

Visibilit des attributs et mthodes

Les attributs, comme les mthodes, ont par dfaut une visibilit publique en Python. Dans lecas des instances de la classe Compteur, il est possible de manipuler directement la valeur delattribut (ou mthodes) val.

Une convention pour certains dveloppeurs Python est de prfixer les attributs par un souglin_ pour annoncer quils ne sont pas destins tre utiliss par les clients. Il est noter quecest une convention et que rien nempche un utilisateur de lire un attribut dont le nom estprfix par un soulign 1.

Enfin, lutilisation de deux souligns comme prfixe (et pas de soulign comme postfixe) dunnom dattribut (ou de mthode) permet de dfinir un attribut priv et donc non visible par lesclients de la classe.

>>> class Foo(object):

... def __init__(self):... self._a = 0

... self.__b = 1

...

>>> f = Foo()

>>> f._a

0

>>> f.__b



AttributeError: Compteur instance has no attribute __b

1. Il est vrai que dans le cas de Python la notion de protg repose sur la confiance, mais si vous roulez 180 km/h en ville qui est responsable, la voiture ou vous?

5.1. Des objets, rien que des objets 43


48/108


Note

La philosophie de Python est de faire confiance au programmeur plutt que devouloir tout blinder comme dans dautres langages (qui ne blindent pas grandchose au final).

5.1.4 Hritage

Python supporte lhritage simple et lhritage multiple. Dans une relation dhritage, il estfaut prciser le nom de la classe mre (entre parenthses aprs le nom de la classe en cours dedfinition)etappeler explicitement le constructeur de la super classe.

>>> class A(object):

... def __init__(self, n=none):

... self._name = n

... def name(self):

... return self._name

>>> class B(A):

... def __init__(self, val=0, n=none):

... A.__init__(self, n)

... self._wheels = val

... def wheels(self):

... return self._wheels

Dans le cas de lhritage multiple, il suffit de prciser les diffrentes classes mres et dappeler

leurs constructeurs respectifs.

>>> class C(object):

... def __init__(self, t=):

... self._title = t

... def title(self):

... return self._title

>>> class D(A, C):

... def __init__(self, n=none, t=):

... A.__init__(self, n)

... C.__init__(self, t)

... def fullname(self):

... return self._title + + self._name

Lexemple suivant donne une utilisation des trois classes prcdentes. Il ny a rien de particulier lutilisation que la classe ait t dfinie entirement ou par hritage ne change rien.

>>> a = A(raphael)

>>> print a.name()

raphael

>>> b = B(4, car)

>>> print b.name()car

>>> print b.wheels()

44 Chapitre 5. Plongeon dans les objets


49/108

Initiation Python par lexemple Documentation, Vers

Initiation Python

Documents

Transcript of Initiation Python