Département Informatique & Mathématiques Appliquées Prise en main de Python

(1)

Département Informatique & Mathématiques Appliquées

Prise en main de Python

J. Gergaud

¹

, E. Navarro

²

et D. Rupprecht

³

2 mai 2013

1. INP-ENSEEIHT,[email protected] 2. INP-ENSEEIHT,[email protected] 3. Lycée Pierre de Fermat,[email protected]

(2)

Table des matières

1 Introduction 1

I Quelques dates . . . 1

II Qu’est-ce que l’informatique ? . . . 1

III Les avantages et inconvénients dePython . . . 1

III.1 Pythonun langage utilisé dans l’industrie . . . 1

III.2 Les avantages dePython. . . 1

III.3 Et les inconvénients ! . . . 2

IV Lancer python en mode interactif . . . 2

V Quelques généralités . . . 2

2 Les types de référence 7 I Type, id et références . . . 7

II Flottants, booléens et complexes . . . 7

II.1 Float . . . 7

II.2 Complex . . . 7

II.3 Opérations . . . 8

II.4 Booléens . . . 8

III Les séquences : tuple, listes et chaînes . . . 8

III.1 Tuple . . . 8

III.2 Listes . . . 9

III.3 Chaînes de caractères . . . 9

IV Objets modifiables ou non . . . 10

V Opérations communes . . . 11

VI Conversions . . . 12

3 Contrôle du flux 13 I Introduction . . . 13

II Instructionsif then else . . . 13

III Instructionfor . . . 14

III.1 Modification de la variable . . . 15

IV Instructionwhile. . . 15

V Quelques compléments . . . 15

V.1 Introduction . . . 15

V.2 break et continue . . . 16

V.3 What else ? . . . 16

4 Fonctions 17 I Introduction . . . 17

II Définition d’une fonction . . . 18

III Les arguments . . . 19

III.1 Plusieurs arguments . . . 19

III.2 Valeurs par défaut . . . 19

III.3 Arguments nommés . . . 19

III.4 Liste quelconque d’arguments . . . 20

III.5 Liste quelconque d’arguments nommés . . . 20

IV Portée des variables et espace de noms . . . 20

IV.1 Construction d’un argument par défaut . . . 22

V Synthèse . . . 23 i

(3)

ii TABLE DES MATIÈRES

VI Récursivité . . . 23

VI.1 La tortue . . . 24

5 Modules 25 I Chargement d’un module externe . . . 25

II Quelques modules importants . . . 26

II.1 Au sujet de la complétion . . . 26

II.2 math . . . 26

II.3 random . . . 26

II.4 copy . . . 27

II.5 time . . . 27

II.6 this . . . 28

III Écrire son module . . . 28

IV Quelques exercices . . . 29

6 Quelques remarques 31 I Sur le codage des caractères . . . 31

II Pour une bonne pratique de la programmation . . . 31

7 Listes 33 I Construction . . . 33

II Modification . . . 33

III Méthodes associées aux listes . . . 34

IV Fonctions appliquées à une liste . . . 35

IV.1 Un peu de lambda-fonction . . . 35

IV.2 map, filter et zip . . . 35

8 Les dictionnaires 39 I Principe . . . 39

I.1 Définir un dictionnaire . . . 39

I.2 Les méthodes . . . 40

I.3 Parcourir le dictionnaire . . . 40

9 Chaînes de caractères 41 I Méthodes sur les chaînes de caractères . . . 41

I.1 Transformations . . . 41

I.2 Recherche . . . 42

I.3 Méthodes de tests . . . 42

II Formatage d’une chaîne . . . 42

III Quelques exercices . . . 43

10 Fichiers 45 I Utiliser des fichiers . . . 45

II Le module os . . . 46

III Fichiers csv . . . 46

III.1 Commandes de base . . . 47

III.2 Paramètres de format . . . 47

III.3 Reader . . . 47

III.4 Writer . . . 48

IV Exercices . . . 48

11 Les tris 49 I Version simple . . . 49

II Modification de la fonction de tri . . . 49

III Avec le module operator . . . 50

III.1 Sélection d’un élément . . . 50

III.2 Sélection d’un attribut . . . 51

12 Quelques références 53

(4)

Chapitre 1

Introduction

On trouvera à la fin de ce document quelques références, dont le polycopié du Professeur D. Rupprecht dont on s’est fortement inspiré.

I Quelques dates

– une première version 0.9.0 publié par Guido Van Rossum en février 1991 (les débuts remontent à fin 1989) – janvier 1994 : version 1.0

– octobre 2000 : version 2.0

– décembre 2008 : version 3.0 - changement majeur car pas de compatibilité avec la version 2

– juillet 2010 : version 2.7 - dernière version majeure pour la branche 2, pour prendre en compte certaines améliorations de Python 3.1

– septembre 2012 : version 3.3

II Qu’est-ce que l’informatique ?

– Leçon inaugurale de Gérard Berry au collège de France

http://www.college-de-france.fr/default/EN/all/inn_tec2007/lecon_inaugurale_.htm

– Slides

Slides

– Interview sur France culture

http://www.franceculture.fr/emission-l-eloge-du-savoir-algorithmes-machines-et-langages-2013-04-02

III Les avantages et inconvénients de Python

III.1 Python un langage utilisé dans l’industrie

– You tube est codé enPython http://python.about.com/b/2006/12/13/holy-web-apps-youtube-is-written-in-python.

htm

– Python est utilisé à EDF pour leur code de mécanique de structures Code_Aster :

http://innovation.edf.com/recherche-et-communaute-scientifique/logiciels/code-aster-41195.html – Logiciel de simulation numérique en calcul des structures développé depuis 20 ans par EDF R&D pour les

besoins de recherche et les études d’expertise des installations de production et de transport d’électricité – Constamment développé, maintenu et enrichi de nouveaux modèles, Code_Aster comporte désormais près

de 1.200.000 lignes de code source, pour la plupart en langages Fortran et Python

– Pour satisfaire les exigences de qualité requises par l’industrie nucléaire, les fonctionnalités du code sont qualifiées par des campagnes de validations indépendantes, par comparaisons avec des solution analytiques ou expérimentales, des benchmarks avec d’autres codes. De plus, 2.000 tests sont gérés en configuration : exécutés chaque semaine, ils sont dévolus à la validation élémentaire et sont utiles comme base pédagogique – La documentation de Code_Aster, entièrement accessible sur un site internet, comporte plus de 12.000

pages

III.2 Les avantages de Python

– c’est un langage interprété

1

(5)

2 CHAPITRE 1. INTRODUCTION – c’est un langage typé

– c’est un langage orienté objet – c’est un langage polivalent :

– piloter un robot ;

– créer une interface graphique ; – créer un site web très complet.

– il est multi-plateforme et gratuit

– Il existe plusieurs environnements (IDLE, IEP, Spyder, IPython, . . . ) et beaucoup de documentation . . .

III.3 Et les inconvénients !

– 2 versions majeures non compatibles : Python2 etPython3.Python3 est mieux, mais tous les modules ne sont pas compatibles

– c’est un langage interprété :

– il est lent (mais les calculs sont optimisés avec les bibliothèquesNumPyet SciPy) ; – beaucoup d’erreurs ne peuvent être détectées qu’à l’exécution

– le typage est dynamique

– langage très riche avec de nombreuses façons de faire

– langage peu contraignant : c’est au programmeur de savoir ce qu’il fait – syntaxe simple mais beaucoup d’implicite (convention de nommage...)

– certains choix sont critiquables pour une bonne pratique de la programmation : – variable globale ;

– traitement du type boolean ; – . . .

– ⇒Il est très important d’apprendre à bien programmer

IV Lancer python en mode interactif

– Vous connecter : login et mot de passe dans vos valisettes, – Pour vous déconnecter, il suffit de cliquer en haut à droite¬

Se déconnecter ...puis de valider.

– ouvrir un terminal :

Application¬Accessoires¬terminal

– lancerPython3. Pour cela taper dans la fenêtre terminal :python ( p y t h o n _ s t a g e _ 3 .3) p y t h o n 3 6 @ k e n o b i :~$ p y t h o n

P y t h o n 3 . 3 . 1 ( default , Apr 8 2013 , 16 :15 :57) [ GCC 4 . 4 . 3 ] on l i n u x

T y p e " h e l p " , " c o p y r i g h t " , " c r e d i t s " or " l i c e n s e " for m o r e i n f o r m a t i o n .

> > > e x i t () # ou q u i t () ( p y t h o n _ s t a g e _ 3 .3) p y t h o n 3 6 @ k e n o b i :~$

V Quelques généralités

– Tout ce qui est après le caractère#est un commentaire.

– Une instruction par ligne.

– Il est conseillé de ne pas avoir plus de 79 caractères par ligne.

– Importance de l’indentation dansPython.

– Un identificateur (nom de variable , d’une fonction, . . . ) commence par une lettre ou le caractère _ et est suivi par une lettre ou le caractère _ ou un chiffre.

– Pythonfait la distinction entre les minuscules et les majuscules.

– Certains noms sont interdits car il s’agit de mots clés (cf.. ci-après).

> > > a = 1 # a f f e c t a t i o n de la v a r i a b l e a

> > > A = 2

> > > p r i n t( " A = " , A , " a = " , a )

A = 2 a = 1

> > > b = 2.0

> > > t y p e ( a ) # a est de t y p e e n t i e r

(6)

V. QUELQUES GÉNÉRALITÉS 3

> > > t y p e ( b ) # b est de t y p e f l o a t

> > > b = " h e l l o "

> > > p r i n t( b ) h e l l o

> > > t y p e ( b ) # b est m a i n t e n a n t de t y p e str ( string , cha î ne de c a r a c t è re )

> > > A + a 3

> > > b

’ h e l l o ’

> > > b + b

’ h e l l o h e l l o ’

> > > b + b

’ h e l l o h e l l o ’

> > > a , b = 3 , " c o u c o u " # a f f e c t a t i o n m u l t i p l e

> > > a 3

> > > b

’ c o u c o u ’

> > > for = 1 # for est un mot cl é

F i l e " < stdin > " , l i n e 1

for = 1

^

S y n t a x E r r o r : i n v a l i d s y n t a x

> > > 3/2 # s o u s P y t h o n 2 c e l a d o n n e l ’ e n t i e r 1

1.5

> > > 3 . 0 / 2 # s o u s P y t h o n 2 c e l a d o n n e a u s s i 1.5

1.5

> > > 2 * * 3 8

Et la commande help

> > > h e l p ()

W e l c o m e to P y t h o n 3.2 ! T h i s is the o n l i n e h e l p u t i l i t y .

If t h i s is y o u r f i r s t t i m e u s i n g Python , you s h o u l d d e f i n i t e l y c h e c k out the t u t o r i a l on the I n t e r n e t at h t t p ://d o c s . p y t h o n . org / t u t o r i a l /.

E n t e r the n a m e of any module , keyword , or t o p i c to get h e l p on w r i t i n g P y t h o n p r o g r a m s and u s i n g P y t h o n m o d u l e s . To q u i t t h i s h e l p u t i l i t y and r e t u r n to the i n t e r p r e t e r , j u s t t y p e " q u i t " .

To get a l i s t of a v a i l a b l e modules , k e y w o r d s , or topics , t y p e " m o d u l e s " ,

" k e y w o r d s " , or " t o p i c s " . E a c h m o d u l e a l s o c o m e s w i t h a one - l i n e s u m m a r y of w h a t it d o e s ; to l i s t the m o d u l e s w h o s e s u m m a r i e s c o n t a i n a g i v e n w o r d s u c h as " s p a m " , t y p e " m o d u l e s s p a m " .

help > k e y w o r d s

H e r e is a l i s t of the P y t h o n k e y w o r d s . E n t e r any k e y w o r d to get m o r e h e l p .

and e l i f i m p o r t r a i s e

as e l s e in r e t u r n

a s s e r t e x c e p t is try

b r e a k f i n a l l y l a m b d a w h i l e

c l a s s for n o n l o c a l w i t h

c o n t i n u e f r o m not y i e l d

(7)

4 CHAPITRE 1. INTRODUCTION

def g l o b a l or

del if p a s s

help > m o d u l e s

P l e a s e w a i t a m o m e n t w h i l e I g a t h e r a l i s t of all a v a i l a b l e m o d u l e s ...

IN b i n h e x i t e r t o o l s s h e l v e

I P y t h o n b i s e c t j s o n s h l e x

_ _ f u t u r e _ _ b u i l t i n s k e y w o r d s h u t i l

_ a b c o l l bz2 l i b 2 t o 3 s i g n a l

_ a s t c P r o f i l e l i n e c a c h e s i t e

_ b i s e c t c a l e n d a r l o c a l e s m t p d

_ c o d e c s cgi l o g g i n g s m t p l i b

_ c o d e c s _ c n c g i t b m a c p a t h s n d h d r

_ c o d e c s _ h k c h e r r y p y m a c u r l 2 p a t h s o c k e t

_ c o d e c s _ i s o 2 0 2 2 c h u n k m a i l b o x s o c k e t s e r v e r

_ c o d e c s _ j p c m a t h m a i l c a p s q l i t e 3

_ c o d e c s _ k r cmd m a r s h a l s r e _ c o m p i l e

_ c o d e c s _ t w c o d e m a t h s r e _ c o n s t a n t s

_ c o l l e c t i o n s c o d e c s m i m e t y p e s s r e _ p a r s e

_ c o m p a t _ p i c k l e c o d e o p m m a p ssl

...

E n t e r any m o d u l e n a m e to get m o r e h e l p . Or , t y p e " m o d u l e s s p a m " to s e a r c h for m o d u l e s w h o s e d e s c r i p t i o n s c o n t a i n the w o r d " s p a m " .

help > q u i t

You are now l e a v i n g h e l p and r e t u r n i n g to the P y t h o n i n t e r p r e t e r . If you w a n t to ask for h e l p on a p a r t i c u l a r o b j e c t d i r e c t l y f r o m the i n t e r p r e t e r , you can t y p e " h e l p ( o b j e c t ) " . E x e c u t i n g " h e l p ( ’ s t r i n g ’) "

has the s a m e e f f e c t as t y p i n g a p a r t i c u l a r s t r i n g at the help > p r o m p t .

> > >

On voit qu’il y a un modulemath, on peut essayer de l’utiliser :

> > > m a t h . pi

T r a c e b a c k ( m o s t r e c e n t c a l l l a s t ) : F i l e " < stdin > " , l i n e 1 , in < module >

N a m e E r r o r : n a m e ’ m a t h ’ is not d e f i n e d

> > > i m p o r t m a t h

> > > m a t h . pi

3 . 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3

> > > m a t h . sin (2 * m a t h . pi /3) 0 . 8 6 6 0 2 5 4 0 3 7 8 4 4 3 8 8

> > > h e l p ( ’ m a t h . sin ’ )

Dans la fenêtre apparaît alors l’aide suivant sur la fonction sin. Pour quitter cet aide et revenir àPython3 il faut taper sur le caractèreq.

H e l p on built -in f u n c t i o n sin in m a t h : m a t h . sin = sin ( . . . )

sin ( x )

R e t u r n the s i n e of x ( m e a s u r e d in r a d i a n s ) . ( END )

On affiche des résultats avec print, en séparant les arguments par des virgules :

(8)

V. QUELQUES GÉNÉRALITÉS 5

> > > a = 3

> > > p r i n t(2* a , a * a , a * * 1 0 ) # la s y n t a x e P y t h o n 2 est d i f f é r e n t e 6 9 5 9 0 4 9

Les arguments peuvent être à peu près de tout type (en fait, il suffit que dans la classe, il existe une méthode particulière__str__qui renvoie une chaîne de caractère qui va représenter l’objet - le résultat est alors utilisé par print).

On peut préciser deux arguments particuliersend=etsep=pour donner ce qui va être la fin de la chaîne ou la partie qui sépare chaque argument à l’affichage :

> > > a = 3

> > > p r i n t(2* a , a * a , a **10 , sep = ’ - - - ’ ) 6 - - -9 - - -59049

> > > p r i n t( a ) ; p r i n t( a ) 3

3

> > > p r i n t( a , end = ’ :’ ) ; p r i n t( a ) 3 :3

Remarques : le caractère de retour à la ligne estn. Le;permet de donner plusieurs instructions sur une même ligne, non recommandé.

Cette fois on utiliseinput

> > > x = i n p u t ( " d o n n e r un e n t i e r : " ) d o n n e r un e n t i e r : 43

> > > x

’ 43 ’

> > > t y p e ( x )

bon il va falloir apprendre à convertir...

(9)

6 CHAPITRE 1. INTRODUCTION

(10)

Chapitre 2

Les types de référence

On peut consulter http://fr.wikibooks.org/wiki/Programmation_Python/Typepour une liste des types, ainsi que les différences entre Python2 et Python3 à ce sujet. Dans cette partie on ne rentrera pas en détails sur tous les types. Certains auront un chapitre dédié. On peut aussi consulter le site de référence Python pour tous les types :http://docs.python.org/3.3/library/stdtypes.html

I Type, id et références

Comme déjà dit, la fonction typepermet d’obtenir le type d’un objet ou d’une variable. Un seconde fonction importante pour comprendre comment sont stockés les objets estid. Cette fonction donne l’identifiant de l’objet (en gros sa place en mémoire).

> > > a = 3

> > > id ( a ) 9 1 5 7 0 5 6

II Flottants, booléens et complexes

II.1 Float

On a déjà vu le typeint¹. Il existe un type flottant (float) standard (environ 16 chiffres significatifs, codés sur 64 bits). Un nombre est détecté commefloatdès qu’il contient un point décimal ou un exposant de 10 défini avece.

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

> > > t y p e ( 1 0 . )

> > > 3 e10 3 0 0 0 0 0 0 0 0 0 0 . 0

Il existe des librairies pour le calcul multi-précision, comme mpmath²qui est entre autre utilisé par Sage, ou encore gmpy³.

II.2 Complex

Il existe un typecomplexqui s’obtient en collant j à la partie imaginaire :

> > > 3+2 j ( 3 + 2 j )

> > > 3 + 2 * j

N a m e E r r o r : n a m e ’ j ’ is not d e f i n e d

1. pour Python2 il existe deux types distinctsintetlong(avec conversion automatique lorsque l’entier était trop grand) 2. http://code.google.com/p/mpmath/

3. http://code.google.com/p/gmpy/

7

(11)

8 CHAPITRE 2. LES TYPES DE RÉFÉRENCE

> > > 3 + 2 * 4 . 1 j ( 3 + 8 . 2 j )

II.3 Opérations

Pas grand chose de spécial, on a les opérations classiques.

+,-,* opérations classiques

// division entière

/ division flottante (resp. entière) sousPython3 (resp.Python2)

convertit si besoin

% modulo

divmod(x,y) quotient et reste de la division

abs(x) valeur absolue int, float, complex

int(x) convertit en entier en retirant la partie déci- male

différent de partie entière

float(x) convertit en float

pow(x,y)oux**y puissance avec int, float et complex

II.4 Booléens

Enfin on dispose d’un type booléens (bool) avec deux valeurs True et False (attention aux majuscules !). Les opérations sontand,or,not.

> > > a = T r u e

> > > t y p e ( a )

> > > b = 5.4 < 2.2

> > > t y p e ( b )

> > > a or b T r u e

III Les séquences : tuple, listes et chaînes

Ces trois types d’objets à priori différents font partie d’une même catégorie appelée « séquence ». Ils ont de nombreux points communs notamment lorsqu’on cherche à en extraire une partie. Ils ont également un comportement semblable en tant qu’itérateursdans les boucles for. Commençons par un rapide tour de ces objets.

III.1 Tuple

Un tuple est une suite (ordonnée) d’éléments (pas forcément de même type), séparée par une virgule (entourés par des parenthèses, même si ce n’est pas obligatoire dans la définition).

> > > l = (2 , 3 , 6 , " a " , 1 . 3 )

> > > t y p e ( l )

Comme les autres séquences, on peut accéder à un élément quelconque par sa position : attention le premier élément est en position 0 !

> > > l [0]

2

> > > l [3]

’ a ’

> > len ( l )

(12)

III. LES SÉQUENCES : TUPLE, LISTES ET CHAÎNES 9 On verra dans une prochaine section, toutes les manières d’extraire une sous-séquence.

Attention de ne pas confondre un objet et un tuple à un seul élément :

> > > a = (2)

> > > t y p e ( a )

> > > b = (2 , )

> > > t y p e ( b )

> > > c = 2 , # les p a r e n t h è ses ne s o n t pas o b l i g a t o i r e s

> > > t y p e ( c )

III.2 Listes

Il y a beaucoup de façons différentes de définir une liste (il y aura tout un chapitre sur les listes). La plus simple ressemble à la définition d’un tuple, mais encadré par des crochets

> > > u n e _ l i s t e = [2 , 4.3 , " b o n j o u r " , 3]

> > > u n e _ l i s t e [2]

’ b o n j o u r ’

> > > p r i n t( u n e _ l i s t e ) [2 , 4.3 , ’ b o n j o u r ’ , 3]

Attention : comme d’habitude, une variable est un alias sur un objet en mémoire. Cela peut sembler étrange car le comportement suivant n’est pas forcément celui auquel on s’attend :

> > > l = [2 ,3 ,4]

> > > l2 = l

> > > l2 [1] = 0

> > > l2 [2 , 0 , 4]

> > > l [2 , 0 , 4]

ainsil2n’est pas une copie de la liste lmais un nouvel alias vers le même objet. Une modification de l’une modifie l’autre. Pour comprendre regardons l’id:

> > > id ( l ) 4 3 0 0 8 5 3 4 7 2

> > > id ( l2 ) 4 3 0 0 8 5 3 4 7 2

Si on veut une vraie copie, il faut utiliser le modulecopy (cf.le chapitre sur les listes).

III.3 Chaînes de caractères

Plusieurs façons de définir des chaînes de caractères (string - classestr) : avec des guillemets ou des apostrophes.

Suivant ce qu’on utilise pour délimiter, l’autre caractère est accessible dans la chaîne :

> > > ex1 = " Une p r e m i e r e c h a i n e "

> > > ex2 = " a v e c des ’ ’ , ca m a r c h e !"

> > > p r i n t( ex2 )

a v e c des ’ ’ , ca m a r c h e !

> > > ex2 = " m a i s pas a v e c " p u i s q u e la c h a i n e est t e r m i n e e "

F i l e " < stdin > " , l i n e 1

ex2 = " m a i s pas a v e c " p u i s q u e la c h a i n e est t e r m i n e e "

^ S y n t a x E r r o r : i n v a l i d s y n t a x

> > > " ou a l o r s c o m m e ca \" , ca m a r c h e "

’ ou a l o r s c o m m e ca " , ca m a r c h e ’

> > > ’ ou e n c o r e \ ’ si on p r e f e r e ’

" ou e n c o r e ’ si on p r e f e r e "

(13)

10 CHAPITRE 2. LES TYPES DE RÉFÉRENCE Le caractère d’échappement\a plusieurs utilisations. Il permet décrire sur plusieurs lignes une lignePython trop grande. Il permet aussi d’accéder à certains caractères dans les chaînes : pour utiliser les " ou ’, pour certains caractères spéciaux (les plus courants sont\npour le retour à la ligne,\tpour une tabulation) :

> > > ex3 = " B o n j o u r !\nLa c h a i n e est sur p l u s i e u r s l i g n e s \ n e n f i n p r e s q u e "

> > > ex3

’ B o n j o u r !\nLa c h a i n e est sur p l u s i e u r s l i g n e s \ n e n f i n p r e s q u e ’

> > > p r i n t( ex3 ) B o n j o u r !

La c h a i n e est sur p l u s i e u r s l i g n e s e n f i n p r e s q u e

Une dernière méthode pour saisir des chaînes avec des caractères spéciaux : les triples guillemets ou triples apostrophes.

> > > ex4 = """ C ’ est p r o m i s

... c ’ est la d e r n i e r e c h a i n e p o u r c e t t e f o i s ... On t e r m i n e c o m m e on a c o m m e n c e !"""

> > > ex4

" C ’ est p r o m i s \ nc ’ est la d e r n i e r e c h a i n e p o u r c e t t e f o i s \ n \ tOn t e r m i n e c o m m e on a c o m m e n c e !"

> > > p r i n t( ex4 ) C ’ est p r o m i s

c ’ est la d e r n i e r e c h a i n e p o u r c e t t e f o i s On t e r m i n e c o m m e on a c o m m e n c e !

Comme avant on a une distinction entre l’objet chaîne et ce qui est affiché avecprint.

IV Objets modifiables ou non

Bien entendu, tout le monde s’est demandé pourquoi on a deux types qui ont l’air les mêmes : les tuples et les listes. DansPython, il y a deux types d’objets : les modifiables (mutable) et les non-modifiables (immutable). On verra notamment l’intérêt dans le passage des arguments d’une fonction.

> > > e x _ t u p l e = (2 ,3 ,4) ; e x _ l i s t e = [2 ,3 ,4]

> > > e x _ t u p l e [ 1 ] = 1

T y p e E r r o r : ’ t u p l e ’ o b j e c t d o e s not s u p p o r t i t e m a s s i g n m e n t

> > > e x _ l i s t e [ 1 ] = 1

> > > e x _ l i s t e [2 , 1 , 4]

Les objets non-modifiables sont principalement les types numériques, les tuples, les strings.

Nous l’avons vu, il n’est pas possible de modifier « en place » un objet non-modifiable. Par contre certaines opérations de modification « en place », deviennent des modifications par copie sur des objets non-modifiables :

> > > a = [1 , 2]

> > > id ( a ) # r a p p e l : id ( obj ) d o n n e l ’ a d r e s s e m é m o i r e de l ’ o b j e t 1 8 1 5 5 1 3 6

> > > a += [42 , 43]

> > > a

[1 , 2 , 42 , 43]

> > > id ( a ) 1 8 1 5 5 1 3 6

> > > b = (1 , 2)

> > > id ( b ) 1 8 1 4 7 8 8 0

> > > b += (42 , 43)

> > > b

(1 , 2 , 42 , 43)

(14)

V. OPÉRATIONS COMMUNES 11

> > > id ( b )

1 3 9 7 1 8 1 4 0 8 4 7 8 3 2

V Opérations communes

Pour toutes les séquences, on dispose de certaines opérations communes :

s + t concaténation des deux séquences

s * n création d’une séquence ou s est copiée n fois

s[i] éléments en position i

s[i:j] tranche entre l’élément i (inclus) et j (exclu) s[i:j:k] tranche entre l’élément i (inclus) et j (exclu)

avec un pas de k

len(s) nombre d’éléments de s

max(s), min(s) maximum et minimum de s

Dans cette partie on ne parlera que de la lecture des éléments (par slicing). On verra comment cela s’utilise (pour les listes puisque chaîne et tuple ne sont pas modifiables) en affectation dans le chapitre sur les listes.

> > > l = [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8] # ou en p l u s c o u r t : l = r a n g e (9)

> > > l [3] # le 3 eme e l e m e n t de l 3

> > > l = [3 , 2 , 4 , 8 , 9 , 1 , 8 , 0]

> > > l [3] # le 3 eme e l e m e n t de l 8

> > > l [ 2 : 4 ] # du 2 eme au 3 eme [4 , 8]

> > > len ( l ) 8

> > > l [ 1 : 7 : 2 ] # du 1 au 7 ( e x c l u ) de 2 en 2 [2 , 8 , 1]

Pour la concaténation :

> > > l = [1 , 2 , 3] + [4 , 5 , 6]

> > > l

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

> > > l2 = l *2

> > > l2

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

Cela fonctionne sur les chaînes de caractères :

> > > c h a i n e = " Une c h a i n e de c a r a c t e r e s "

> > > c h a i n e [5]

’ h ’

> > > c h a i n e [ 5 : 1 5 : 3 ]

’ h n d c ’

On peut compter les éléments à l’envers avec des nombres négatifs, ou laisser certains indices vides pour aller au début ou à la fin : à vous de comprendre comment sont indexés les termes

> > > c h a i n e

’ Une c h a i n e de c a r a c t e r e s ’

> > > c h a i n e [ 1 0 : ]

’ de c a r a c t e r e s ’

> > > c h a i n e [10: -3]

’ de c a r a c t e ’

> > > c h a i n e [ 2 : : 4 ]

’ ea cce ’

(15)

12 CHAPITRE 2. LES TYPES DE RÉFÉRENCE Il reste quelques fonctions supplémentaires :

s in t test d’appartenance

s not in t le contraire

s.index(x, i, j) position dexdanssentreietj(iet/oujne sont pas obligatoires)

s.count(x) nombre d’occurences de xdanss

> > > c h a i n e = " c ’ est pas t o u j o u r s f a c i l e de t r o u v e r de b o n s e x e m p l e s "

> > > ’ il ’ in c h a i n e T r u e

> > > ’ bac ’ not in c h a i n e T r u e

> > > c h a i n e . i n d e x ( ’ a ’ , 9) 20

> > > c h a i n e . c o u n t ( ’ ou ’ ) 3

Bon d’accord, ce n’est peut-être pas ce qu’il faut montrer aux étudiants en priorité si on veut faire faire un peu d’algorithmique et de parcours de chaînes. . .

VI Conversions

C’est assez simple, il suffit en général d’une syntaxe sous la formetype(donnees):

> > > c h a i n e = ’ 123 ’

> > > int ( c h a i n e ) + 3 126

> > > f l o a t ( c h a i n e ) + 3 1 2 6 . 0

> > > str (23 + 12)

’ 35 ’

> > > t u p l e = (2 , 4 , 5 , 3)

> > > l i s t ( t u p l e ) [2 , 4 , 5 , 3]

> > > # la p l u p a r t des o b j e t s ont une m é t h o d e ’ _ _ s t r _ _ ’ p o u r se t r a n s f o r m e r en cha î ne de c a r a c t è res

> > > str ( t u p l e )

’ (2 , 4 , 5 , 3) ’

On peut aller plus loin et évaluer une chaîne :

> > > c h a i n e = " 1 2 * 4 5 "

> > > int ( c h a i n e )

V a l u e E r r o r : i n v a l i d l i t e r a l for int () w i t h b a s e 10 : ’ 1 2 * 4 5 ’

> > > e v a l ( c h a i n e ) 540

> > > f r o m m a t h i m p o r t sin , pi

> > > e v a l ( " sin (2* pi ) + 3 " )

2 . 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 6 # et oui , c ’ est du c a l c u l num é r i q u e

(16)

Chapitre 3

Contrôle du flux

I Introduction

Une des particularité de Pythonest que la structuration du code est lié à l’indentation des instructions. Pour délimiter une série d’instructions dans un test, une boucle, il n’y a pas de délimiteurs particuliers (de type begin/end ou { }), l’indentation suit les blocs d’instructions (ou le contraire, à vous de voir).

Qu’est ce que l’indentation : au moins un espace ou une tabulation. Il est très très fortement recommandé d’utiliser systématiquement une suite de 4 espaces (ou moins, mais dans ce cas, il faut rester cohérent et garder toujours le même nombre). La plupart des éditeurs dédié àPythonconvertissent automatiquement les tabulations en une suite de 4 espaces.

La première ligne de ces instructions, comme la définition d’une fonction, se termine toujours par deux points (le caractère:).

II Instructions if then else

x =2 if x >0:

p r i n t( " le n o m b r e est p o s i t i f " )

x +=1 # on i n c r e m e n t e - a u c u n interet , c ’ est p o u r m o n t r e r e l s e:

p r i n t( " x est n e g a t i f " ) x =3

p r i n t( x )

On peut compliquer avec deselif(else if) : if t e s t 1 :

b l o c 1 e l i f t e s t 2 :

b l o c 2 e l i f t e s t 3 :

b l o c 3 e l s e:

b l o c 4

et bien entendu, on peut imbriquer plusieurs blocs de cette façon : if t e s t 1 :

d e b u t _ b l o c _ 1 if s o u s _ t e s t 1 :

s o u s _ b l o c _ i n t e r n e e l s e:

s o u s _ b l o c _ s i n o n f i n _ b l o c _ 1

On peut également condenser lorsque les blocs sont très simples (une instruction) : 13

(17)

14 CHAPITRE 3. CONTRÔLE DU FLUX

if x > = 0 : y = x

e l s e: y = - x # au passage , il est e n c o r e p l u s s i m p l e de f a i r e y = abs ( x ) le code doit rester lisible, et c’est déjà assez limite. . .

Quelques remarques :

– le test d’égalité se fait avec==(ne pas mélanger avec l’affectation)

– On a bien entendu les règles de comparaison standard :<,>,<=et>=, ainsi que !=(pour différent), avec tous les objets qui ont les fonctions de tests correspondantes (c’est fait pour les entiers, flottant, les chaînes, les listes... à vous de tester pour comprendre quel critère est utilisé).

– il y a le test d’appartenancein

– on dispose des opérateursandetorpour combiner plusieurs tests, ainsi que des parenthèses pour regrouper convenablement les tests. Il existe également la négationnot.

– évaluation paresseuses : les expressions booléennes ne sont pas forcément évaluées complétement : sitest1est False, alorstest1 and test2renverraFalsesans même évaluer le second test (et c’est similaire avecor).

> > > (2 >3) or (3 <4) T r u e

> > > 2 >3 and 4 <3 # les p a r e n t h e s e s ne s o n t pas o b l i g a t o i r e s F a l s e

> > > 2 <3 <4 # on p e u t e n c h a i n e r T r u e

> > > 2 <3 >=1 # a ne pas f a i r e ! T r u e

> > > T r u e or f o n c t i o n _ d e _ t e s t () # la f o n c t i o n _ d e _ t e s t ne s e r r a pas é v a l u é e T r u e

En fait les tests utilisés dansifouwhilene demande pas forcément un vrai test (au sens où on l’entend en général). Les valeurs considérées commeFalsesont :

– évidemment la valeurFalse,

– la constante None(constante du langage), – tout valeur numérique égale à 0 (0, 0.0, 0.0j), – les chaînes, listes, tuples, dictionnaires vides.

> > > a = " "

> > > if a :

... p r i n t( " q u e l q u e c h o s e " ) ... e l s e:

... p r i n t( " r i e n " ) . . . .

r i e n

On peut tester le fait que la chaîneaest non vide avecif a!= "":, mais il est plus efficace d’utiliserif a:.

Il existe beaucoup d’autres méthodes et fonctions qui permettent de tester différents critères :

> > > a = 3

> > > i s i n s t a n c e ( a , f l o a t ) # on r e g a r d e si a est une i n s t a n c e de la c l a s s e f l o a t F a l s e

> > > i s i n s t a n c e ( a , int ) # c l a s s e int T r u e

et énormément de critères sur les chaînes (voir chapitre correspondant)

> > > c = " c o u c o u "

> > > c . i s l o w e r () T r u e

> > > c . i s d i g i t () F a l s e

III Instruction for

Commençons par le plus simple (le principe est le même pour l’indentation) :

(18)

IV. INSTRUCTIONWHILE 15

for i in r a n g e ( 1 0 ) : p r i n t( i )

On peut manipulerrangesous les formesrange(n)pour les entiers de 0 àn−1,range(a,b)pour ceux entrea etb (strictement) etrange(a,b,p)lorsqu’on veut ajouter un pas dep.

La boucleforne s’utilise pas forcément avec la fonctionrange. Il est en fait possible d’utiliser des boucles for sur tout objet « itérable » (c’est un type particulier d’objets, dont la classe possède des instructions qui permettent de parcourir les données de l’objet).

Les objets itérables que l’on a déjà vu sont : – range : évidemment

– les listes et les tuples

– les chaînes de caractères (on parcourt l’ensemble des caractères de la chaîne) Quelques exemples simples :

> > > l = [ ’ a ’ , 3 , 4 , ’ p l u s g r a n d ’ ]

> > > for e in l : ... p r i n t( e ) ...

a 3 4

p l u s g r a n d ou

> > > for e in " les c a r a c t è res " : ... p r i n t( e , end = " - " ) ...

l - e - s - -c - a - r - a - c - t - è -r - e - s -

III.1 Modification de la variable

La variable utilisée dans une boucle forva décrire un à un les éléments de l’itérateur donné, même si elle est modifiée dans la boucle :

> > > for i in r a n g e (8) : # e q u i v a l e n t à " for i in [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7] :"

... i +=2

... p r i n t( i , end = " " ) ...

2 3 4 5 6 7 8 9

Dans cet exemple,iprend les différentes valeurs imposées par l’itérateurrange, même si elle est modifiée dans le corps de la boucle, elle prend la valeur suivante de l’itérateur au passage suivant.

Le comportement de for i in range(10): est donc différent des boucles de typefor(i = 0; i<10; i++)en C par exemple.

IV Instruction while

Il existe également une instructionwhile : w h i l e t e s t :

b l o c 1

V Quelques compléments

V.1 Introduction

les instructions suivantes ne sont à utiliser que dans des cas très particulier et sont en général à proscrire dans le cadre d’une bonne pratique de la programmation.

(19)

16 CHAPITRE 3. CONTRÔLE DU FLUX

V.2 break et continue

Aussi bien dans les bouclesforque les boucleswhile, on peut utiliser ces deux instructions : – break : sort (violemment) de la boucle et passe à la suite

– continue : termine l’itération en cours et passe à la suivante (retour en début de boucle avec l’itération suivante dans une boucleforou retour au test danswhile).

Quelques exemples sans intérêt : a =0

w h i l e ( a > = 0 ) : a +=1

if ( a = = 5 ) : c o n t i n u e e l i f ( a = = 1 0 ) : b r e a k e l s e: p r i n t( a )

devinez ce qu’il va se passer... et essayez !

Dans le même genre d’idée, qu’affiche ces instructions ?

> > > for i in r a n g e ( 1 1 ) : if i %2: c o n t i n u e e l s e: p r i n t( i )

De façon général, il est peu recommandé d’utiliser ces instructions. Vous le voyez cela rend, en général, la compréhension de la boucle difficile !

Mini-exercice : rendre ces deux boucles plus lisibles.

Corrigé :

for a in r a n g e (1 ,10) :

if a != 5:

p r i n t( a )

# et

for i in r a n g e (0 , 11 , 2) : p r i n t( i )

V.3 What else ?

Pour terminer, on peut ajouter un bloc d’instructions en fin de boucle, qui sera réalisé si la sortie de la boucle s’est faite proprement (c’est-à-dire sansbreak) avec l’instructionelse

w h i l e t e s t : b l o c e l s e:

si s o r t i e p r o p r e

Un cas d’utilisation typique (et souhaitable) debreaket elsedans uns boucle de recherche : p h r a s e = [ " une " , " l i s t e " , " de " , " c h a i n e s " ]

for mot in p h r a s e :

if mot . s t a r t s w i t h ( " li " ) : p r i n t( " mot t r o u v é ! " ) b r e a k

e l s e:

p r i n t( " mot non pr é s e n t ... " )

(20)

Chapitre 4

Fonctions

I Introduction

Avant de voir les fonctions, nous allons parler de script et voir comment exécuter un programme écrit enPython.

Pour cela on va écrire dans un fichier texte un petit programmePythonque nous exécuterons ensuite. l’éditeur de texte que l’on va utiliser ici s’appellegeany. pour cela :

– ouvrir un nouveau terminal (Application¬Accessoires¬terminal) ; – taper geany &

Cela vous ouvre l’éditeur de texte tout en gardant la fenêtre du terminal active.

– Ensuite taper (on reviendra sur la première ligne plus tard)

# -* - c o d i n g : utf -8 -* -

""" P r e m i e r e s s a i de s c r i p t P y t h o n

P e t i t p r o g r a m m e s i m p l e a f f i c h a n t une s u i t e de F i b o n a c c i , c . à . d . une s u i t e de n o m b r e d o n t c h a q u e t e r m e est é g a l e à la s o m m e des d e u x pr é c é d e n t s Cr é é le 20 a v r i l 0 8 : 0 3 : 5 0 2 0 1 3

a u t e u r : g e r g a u d

"""

p r i n t( " S u i t e de F i b o n a c c i : " )

a , b = 1 , 1 # a & b s e r v e n t au c a l c u l des t e r m e s s u c c e s s i f s p r i n t( b ) # a f f i c h a g e du p r e m i e r c o m p t e u r

for i in r a n g e ( 1 4 ) : # on a f f i c h e r a 15 t e r m e s en t o u t : a , b = b , a + b

p r i n t( b )

– enregistrer ce fichier sous le nom fibo.pydans le répertoire d’où vous avez lancégeany

– Aller dans la fenêtre du terminal et taperpython fibo.py. Vous obtenez alors l’exécution du programme Python.

( p y t h o n _ s t a g e _ 3 .3) p y t h o n 3 6 @ k e n o b i :~$ p y t h o n f i b o . py S u i t e de F i b o n a c c i :

1 2 3 5 8 13 21 34 55 89 144 233 377

17

(21)

18 CHAPITRE 4. FONCTIONS

610 987

Tout ceci est un peu lourd, c’est pourquoi, il a été créé des environnements. Nous allons ici utiliser l’environnement IEP. Pour le lancer, il suffit de taper dans la fenêtre du terminaliepou de cliquer sur le lien présent sur le bureau.

Pour retrouver et exécuter votre fichier il suffit alors :

– de cliquer surFile¬Openet de sélectionner le fichierfibo.py

– d’exécuter le fichier en cliquant ensuite surRun¬Run file as script(ou le raccourciCTRL+SHIFT+E).

II Définition d’une fonction

– Fichierpremiere_fonction.py

# -* - c o d i n g : utf -8 -* -

"""

Cr é é le 20 a v r i l 0 8 : 0 3 : 5 0 2 0 1 3 a u t e u r : g e r g a u d

F i c h i e r qui ne c o m p r e n d que la d é f i n i t i o n d ’ une f o n c t i o n tr è s s i m p l e

"""

def f ( x ) :

""" c e t t e f o n c t i o n c a l c u l e q u e l q u e c h o s e d ’ a s s e z c o m p l i q u e ...

p a r a m e t e r s ( i n p u t ) - - - - x : f l o a t

r e t u r n - - - - y : f l o a t

= ‘x ‘+ 1

"""

y = x + 1 r e t u r n y – Fichierscript2.py

# -* - c o d i n g : utf -8 -* -

"""

Cr é é le 20 a v r i l 0 8 : 0 3 : 5 0 2 0 1 3 a u t e u r : g e r g a u d

D e u x i è me s c r i p t : e x e m p l e d ’ a p p e l d ’ une f o n c t i o n d ’ un a u t r e m o d u l e

"""

i m p o r t p r e m i e r e _ f o n c t i o n a = p r e m i e r e _ f o n c t i o n . f (3) p r i n t( ’ a = ’ , a )

– Exécuter le programme principalscript2.py

– Taperhelp(’premiere_fonction.f’)dans la fenêtre de commandePython – On obtient alors

> > > h e l p ( ’ p r e m i e r e _ f o n c t i o n . f ’ )

H e l p on f u n c t i o n f in p r e m i e r e _ f o n c t i o n : p r e m i e r e _ f o n c t i o n . f = f ( x )

(22)

III. LES ARGUMENTS 19

c e t t e f o n c t i o n c a l c u l e q u e l q u e c h o s e d ’ a s s e z c o m p l i q u e ...

p a r a m e t e r s ( i n p u t ) - - - - x : f l o a t

r e t u r n - - - - y : f l o a t

= ‘x ‘+ 1

III Les arguments

Bien entendu, on ne va pas se limiter à des fonctions avec un seul argument. . . enfin ! ! !

III.1 Plusieurs arguments

rien de surprenant :

> > > def f ( x , y ) : r e t u r n x * y

> > > f (3 , 4) # en p l u s c e l a d o n n e le bon r é s u l t a t 12

III.2 Valeurs par défaut

On peut, à la fin de la suite des arguments préciser que certains arguments ont une valeur par défaut lorsque cette valeur n’est pas transmise. Bien entendu, on ne peut pas mélanger les arguments puisque l’interpréteur ne peut pas savoir dans quel ordre les prendre :

> > > def f ( x , y =1) : r e t u r n x * y

> > > f (2 , 4) 8

> > > f (6) 6

Exercice III.1

Jusqu’où peut-on aller dans les arguments par défaut ? doit-on tous les mettre ou aucun ? à vous de tester.

III.3 Arguments nommés

Il est parfois commode de donner un nom aux différents arguments, cela permet d’appeler la fonction de façon assez naturelle et en transmettant les arguments dans un ordre quelconque.

> > > def d i v i s e ( d i v i d e n d e , d i v i s e u r =1) : r e t u r n d i v i d e n d e / d i v i s e u r

> > > d i v i s e (18 ,4) 4.5

> > > d i v i s e ( d i v i d e n d e =56 , d i v i s e u r =3) 1 8 . 6 6 6 6 6 6 6 6 6 6 6 6 6 6 8

> > > d i v i s e ( d i v i s e u r =7 , d i v i d e n d e = 8 7 ) 1 2 . 4 2 8 5 7 1 4 2 8 5 7 1 4 2 9

On n’est alors pas obliger de respecter l’ordre lorsqu’on appelle la fonction du moment que tous les arguments sans valeurs par défaut sont nommés dans l’appel.

(23)

III.4 Liste quelconque d’arguments

Il est possible de récupérer dans un tuple un nombre quelconque d’arguments. La syntaxe est sous la forme def f(*args). On peut également combiner tous ce qui est dit avant avec l’ordre arguments, arguments avec valeurs par défaut, et tuple d’arguments.

> > > def f ( x , y =0 , * l i s t e ) :

p r i n t( ’ les d e u x p r e m i e r s : ’ , x , y ) for i in l i s t e : p r i n t( i , end = ’ ’ )

> > > f (3 , 4 , 5 , 3 , 4) les d e u x p r e m i e r s : 3 4 5 3 4

Exercice III.2

les incontournables : écrire une fonction qui détermine le maximum d’une suite d’éléments. Même chose avec la moyenne.

III.5 Liste quelconque d’arguments nommés

Pour finir, on peut en plus transmettre un nombre quelconque d’arguments nommés : c’est par exemple utile si une fonction peut avoir plusieurs options et qu’on doit filtrer suivant ces options. Imaginons qu’on ait à tracer un objet, on peut alors spécifier dans la fonction de tracé différentes options (couleur, pointillé. . .) sans savoir au final combien de telles options il peut y avoir (il n’y a pas besoin de reprendre l’entête de la fonction si on ajoute un type mais seulement modifier le corps en conséquence).

Pour cela, on a besoin de parler de dictionnaire... hélas ce sera fait plus tard.

La syntaxe est sous la forme :def f(arguments, *args, **kargs)

Remarque :Il est préférable, en général, d’éviter d’utiliser*argset**kwargs.

IV Portée des variables et espace de noms

La portée d’une variable provient directement de l’endroit où elle est créée. Une variable créée dans une fonction n’aura plus de visibilité lorsqu’on va quitter cette fonction.

L’ordre standard lorsque l’interpréteur doit évaluer le contenu d’une variable, d’un nom : – espace local

– espace global : lorsque la variable n’a pas été définie localement, – espace interne : les variables et fonctions dePython(None,len, . . .)

> > > def f ( x ) : ... p r i n t( a , x )

> > > f (3)

F i l e " < stdin > " , l i n e 2 , in f

N a m e E r r o r : g l o b a l n a m e ’ a ’ is not d e f i n e d

> > > a = 3

> > > f (2) 3 2

> > > x = 6

> > > f (2) 3 2

Comment sont modifiées les variables à l’intérieur d’une fonction ?

> > > def f () :

... a = 3

... p r i n t( a )

> > > a = 1

> > > f () 3

> > > a

(24)

IV. PORTÉE DES VARIABLES ET ESPACE DE NOMS 21

1

Cela semble complètement cohérent. Dans la fonction f, la variable a est créée (dans l’espace de nom de la fonction f) mais ne modifie pas la variable globale.

On peut accéder à une variable globale dans une fonction en le spécifiant par la directiveglobal

> > > def f () : ... g l o b a l a

... a += 1

... p r i n t( a )

> > > a = 2

> > > f () 3

> > > a 3

et si on ne précise pas

> > > def f () :

... a += 1

... p r i n t( a )

> > > a =2

> > > f () # a l o r s ???

Si l’on ne précise pas global, les variables globales ne peuvent être modifiées.

continuons :

> > > l i s t e = [2 , 3 , 4]

> > > def f ( l ) : ... p r i n t( l )

... l = []

... p r i n t( l ) ...

> > > f ( l i s t e ) [2 , 3 , 4]

[]

> > > l i s t e [2 , 3 , 4]

mais...

> > > def g ( l ) : ... p r i n t( l )

... l [0] = ’ m o d i f i e ’ ... p r i n t( l )

...

> > > l i s t e [2 , 3 , 4]

> > > g ( l i s t e ) [2 , 3 , 4]

[ ’ m o d i f i e ’ , 3 , 4]

> > > l i s t e

[ ’ m o d i f i e ’ , 3 , 4]

Quelle différence entre ces deux fonctions ? le mieux est de regarder les identifiants def f ( l ) :

p r i n t( " l i s t e d a n s f : " , id ( l ) ) l =[]

p r i n t( " n o u v e l l e l i s t e : " , id ( l ) ) def g ( l ) :

p r i n t( " l i s t e d a n s g : " , id ( l ) )

(25)

p r i n t( " é l é m e n t 0 d a n s g : " , id ( l [ 0 ] ) ) l [0] = ’ m o d i f i e ’

p r i n t( " é l é m e n t 0 m o d i f i é d a n s g : " , id ( l [ 0 ] ) ) p r i n t( " l i s t e apr è s m o d i f d a n s g : " , id ( l ) ) l i s t e = [2 , 3 , 4]

f ( l i s t e )

p r i n t( " id g l o b a l : " , id ( l i s t e ) ) p r i n t()

g ( l i s t e )

p r i n t( " id g l o b a l f i n a l : " , id ( l i s t e ) ) p r i n t( " e l e m e n t 0 g l o b a l : " , id ( l i s t e [ 0 ] ) )

avec, lorsqu’on exécute :

l i s t e d a n s f : 1 3 9 8 8 9 3 6 7 2 9 6 2 6 4 n o u v e l l e l i s t e : 3 8 8 5 6 3 2 0 id g l o b a l : 1 3 9 8 8 9 3 6 7 2 9 6 2 6 4 l i s t e d a n s g : 1 3 9 8 8 9 3 6 7 2 9 6 2 6 4 e l e m e n t 0 d a n s g : 9 1 5 7 0 2 4

e l e m e n t 0 m o d i f i e d a n s g : 1 3 9 8 8 9 3 6 7 7 1 3 5 8 4 l i s t e a p r e s m o d i f d a n s g : 1 3 9 8 8 9 3 6 7 2 9 6 2 6 4 id g l o b a l f i n a l : 1 3 9 8 8 9 3 6 7 2 9 6 2 6 4

e l e m e n t 0 g l o b a l : 1 3 9 8 8 9 3 6 7 7 1 3 5 8 4

L’identifiant lgarde bien une portée globale dans la seconde fonction (c’est un alias vers la liste identifiée également parliste) puisqu’il n’est pas défini localement. Le comportement est donc totalement logique.

Pour terminer :

– globals()renvoie un dictionnaire avec les éléments globaux sous la forme nom :valeur – locals()renvoie le dictionnaire des éléments locaux.

Exercice IV.1

Écrire une fonction remplace qui prend en argument

– une chaîne, un premier caractèrec₁, une second caractèrec₂ – deux arguments optionnels debut et fin

et qui renvoie une chaîne dans laquelle chaque caractèrec1entre les positions début et fin est remplacé parc2.

IV.1 Construction d’un argument par défaut

Lorsqu’une fonction est définie avec certains arguments par défaut, cette valeur par défaut est construite à la création de la fonction. Cela n’a aucune conséquence sur un objet non mutable (il ne bougera jamais), mais beaucoup plus sur un mutable : si on évalue le code suivant

> > > def f ( l = [ ] ) : ... l . a p p e n d (1) ... p r i n t( l )

> > > l i s t e = [2 , 2 , 2]

> > > p r i n t( " a v a n t : " , l i s t e ) a v a n t : [2 , 2 , 2]

> > > f ( l i s t e ) [2 , 2 , 2 , 1]

> > > p r i n t( " a p r e s : " , l i s t e )

a p r e s : [2 , 2 , 2 , 1] # t o u t est s t a n d a r d

> > > f () [1]

> > > f () [1 , 1]

> > > f ( l i s t e ) [2 , 2 , 2 , 1 , 1]

> > > f ()

(26)

V. SYNTHÈSE 23

[1 , 1 , 1]

Lors de la création de la fonctionf, une liste vide est construite et est ensuite utilisée lors d’un appel où l’objet l n’est pas spécifié. Dit autrement la valeur de l’argument par défaut est construit une fois pour toute

Si vous avez bien compris que fait cette suite d’instructions ?

> > > def f ( l = [ ] ) : ... l . a p p e n d (1) ... p r i n t( l )

... l =[1 ,2 ,3]

... p r i n t( l )

> > > f () # p r e m i e r a p p e l [1]

[1 , 2 , 3] # pas de s u r p r i s e

> > > f () # s e c o n d e a p p e l ...

Ce comportement étrange est une source d’erreur classique en python. Pour avoir des arguments par défaut mutables, mais bien initialisés à chaque appel, on est obligé de faire :

def f ( l = N o n e ) :

""" F o n c t i o n a v e c a r g u m e n t a y a n t une v a l e u r par d é f a u t m u t a b l e p a r a m e t e r s ( i n p u t )

- - - - l : l i s t

si N o n e a l o r s ‘l ‘ p r e n d la v a l e u r par d é f a u t ‘[] ‘

"""

if l is N o n e : l = []

l . a p p e n d (1) p r i n t( l ) On peut tester :

> > > f () # p r e m i e r a p p e l [1]

> > > f () # s e c o n d a p p e l ...

[1]

V Synthèse

(i) Portée des variables :

– chaque appel à une fonction définit un nouvel espace de noms,

– toutes les variables affectées dans une fonction sont automatiquement locales, – l’ordre de résolution est : local>global>interne

(ii) Passage de paramètres :

– tous les passages se font par paramètre,

– tous les paramètres passés sont locaux (modifier le contenu d’un mutable ne modifie pas l’identifiant du mutable).

(iii) Les valeurs par défauts sont construites une seule fois, lors de la création de la fonction.

VI Récursivité

Pas de soucis, on peut faire de la programmation récursive, avec ses avantages et ses inconvénients si on s’y prend mal. . .

def f a c t ( n ) : # il n ’ y a pas p l u s o r i g i n a l

if n >1:

r e t u r n n * f a c t ( n -1) e l s e:

(27)

r e t u r n 1

p r i n t( " 6! = " , f a c t (6) )

VI.1 La tortue

Une bonne méthode pour expérimenter la récursivité est d’utiliser cette bonne vieille tortue tout droit héritée du logo. Pour cela, on importera le module correspondant (dans le shell ou dans le module) avec

f r o m t u r t l e i m p o r t *

On dispose alors de quelques fonctions intéressantes :

reset() efface la fenêtre

goto(x,y) se déplace sans écrire

forward(d) etbackward avance ou recule de d

up() etdown() monte et descend le crayon

left(a)etright(a) tourne de a (degrés)

penup()etpendown() monte ou baisse le crayon

begin_fill()et end_fill() début/fin d’une zone à remplir

f r o m t u r t l e i m p o r t * r e s e t ()

for i in r a n g e ( 2 0 ) : f o r w a r d ( 1 0 0 ) l e f t ( 1 5 0 )

Exercice VI.1

utiliser le module turtle pour écrire une procédure qui trace un triangle (ou un flocon) de Von Koch avec une profondeur donnée

Exercice VI.2

un petit arbre pythagoricien :

On pourra charger le module math avecfrom math import *afin d’ajouter quelques fonctions intéressantes comme le sinus (ou le nombreπ).

(28)

Chapitre 5

Modules

I Chargement d’un module externe

Afin d’avoir un interpréteur très léger, très peu de fonctions sont intégrées. Il faut donc charger ces fonctions qui se trouvent dans des modules. Python dispose d’un nombre impressionnant de modules. Certains font partie de la distribution standard (module math, random, copy par exemple), d’autres sont à télécharger et installer indépendamment (NumPy, SciPy, Matplotlib par exemple - même si certaines distributions non officielles dePython les intègrent). Il y a différentes possibilités pour charger un module - cela se place en début du module que l’on programme.

– la totale :

f r o m m o d u l e i m p o r t *

cela charge le module, l’éxécute et place toutes les fonctions du module (et variables) dans l’espace de noms courant - cela peut être dangereux car on peut alors écraser une version précédente de la fonction. Les fonctions et variables s’appellent alors directemet par leur nom :

> > > f r o m m o d u l e i m p o r t *

> > > sin ( pi + e )

- 0 . 4 1 0 7 8 1 2 9 0 5 0 2 9 0 9 3 5

On peut ne charger que certaines fonctions du module avec la syntaxe f r o m m o d u l e i m p o r t f o n c t i o n s _ a _ i m p o r t e r

Par exemple

> > > f r o m m a t h i m p o r t sin , cos

> > > sin (1)

0 . 8 4 1 4 7 0 9 8 4 8 0 7 8 9 6 5

> > > pi

N a m e E r r o r : n a m e ’ pi ’ is not d e f i n e d – on ne mélange pas :

i m p o r t m o d u l e

Comme précédemment on importe le module. En revanche les fonctions ne sont plus placées dans l’espace de noms courants mais dans un espace propre. Pour y accéder, il faut préciser qu’on utilise la fonction dans cet espace de noms :

> > > m a t h . sin ( m a t h . pi +2) - 0 . 9 0 9 2 9 7 4 2 6 8 2 5 6 8 1 7

Évidemment c’est plus lourd, surtout si le nom du module est long. . . On peut simplifier en précisant un nom pour cet espace de noms :

25

(29)

26 CHAPITRE 5. MODULES

> > > i m p o r t m a t h as m

> > > m . sin ( m . pi +1) - 0 . 8 4 1 4 7 0 9 8 4 8 0 7 8 9 6 4

Les deux utilisations sont possibles suivant les situations. Pour les petits programmes, on peut directement importer dans l’espace de noms. Pour les programmes plus conséquents, il vaut mieux importer le module avec import module afin d’éviter les conflits (sauf lorsqu’on utilise très intensivement les fonctions du module, par exemple tkinter qui permet de faire des interfaces graphiques).

Un module est encore un objet comme un autre :

> > > t y p e ( m a t h )

<c l a s s ’ m o d u l e ’ > # c ’ est un o b j e t de t y p e m o d u l e

> > > del m a t h # on e f f a c e l ’ o b j e t de la m e m o i r e

> > > t y p e ( m a t h ) # il n ’ e x i s t e p l u s ...

N a m e E r r o r : n a m e ’ m a t h ’ is not d e f i n e d

II Quelques modules importants

II.1 Au sujet de la complétion

Petite remarque générale sur la complétion automatique sous IEP (ou sur un autre éditeur mais avec éventuelle- ment un autre raccourci). L’éditeur propose en effet les commandes qui commencent par ce qu’on a tapé, ou ce qui s’en rapproche le plus. Par exemple si on a importer le modulemathet que l’on tape

math.sdans la fenêtre ”traitement de texte” alors IEP proposesin, sinhetsqrt. Il faut appuyer surTABpour valider un choix de complétion.

II.2 math

Pour la documentation complète : http://docs.python.org/3.3/library/math.html. On y retrouve la plupart des fonctions et constantes usuelles, par exemple :

– les constantes :pi, e

– quelques fonctions classiques : sqrt, exp, log, log10, ainsi queceil, floor, fabs, factorial(pour un entier)

– les fonctions trigonométriques diverses :sin, cos, tan, asin, acos, atan – les fonctions hyperboliques :sinh, cosh, tanh, asinh, acosh, atanh – quelques fonctions spéciales :gamma, lgamma(ln◦Γ),erf(avec erf(x) = 2

√π Z x

0

e^−t²dt) ainsi que sa fonction complémentaireerfc

– quelques autres plus ou moins utilisées. . .

Il existe un module assez proche pour traiter le cas des fonctions d’une variable complexe (modulecmath).

II.3 random

Pour toutes les fonctions : http://docs.python.org/3.3/library/random.html. On n’en présente que quelques-unes ici, les plus habituelles

(30)

II. QUELQUES MODULES IMPORTANTS 27

random réel dans [0,1[ (loi uniforme)

randrange([debut, ]fin) entier entre debut et fin (non compris) randrange(debut, fin, pas) entier dans range(debut,fin,pas)

randint(a, b) entier entre a et b compris (=randrange(a,b+1))

uniform(a, b) réel dans [a, b[ - loi uniforme

gauss(mu,sigma) loi gaussienne de paramètremuetsigma

seed(a=None, version=2) initilialisation du générateur : l’élément a est un entier/chaîne ou rien - dans ce cas l’heure actuelle est utilisée

choice(seq) retourne un élément de la séquence

shuffle(liste) mélange la liste l (modifie la liste, ne renvoie pas une nouvelle liste)

II.4 copy

Un petit module qui permet de copier des listes (essentiellement - en fait tout type d’objet qui contient des objets mutables).

> > > i m p o r t c o p y

> > > l = l i s t ( r a n g e (6) )

> > > g = c o p y . c o p y ( l )

> > > g

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

> > > id ( l ) ; id ( g )

1 4 0 0 2 7 4 6 2 5 1 5 0 2 4 # on o b t i e n t b i e n une c o p i e de la l i s t e ( i d e n t i f i a n t d i f f é r e n t s )

1 4 0 0 2 7 4 6 2 5 1 5 0 9 6

La fonctioncopyne fait une copie qu’au premier niveau

> > > l = [[0] , [ 1 ] ]

> > > m = c o p y . c o p y ( l )

> > > id ( l ) ; id ( m ) 4 6 9 4 8 1 5 2

4 7 0 0 1 8 9 6

> > > id ( l [ 1 ] ) ; id ( m [ 1 ] ) 4 6 9 4 7 7 2 0

4 6 9 4 7 7 2 0

> > > l [ 1 ] [ 0 ] = 2

> > > m [[0] , [ 2 ] ]

Pour créer complètement un nouvel élément en descendant dans les listes :

> > > l = [ [ 0 ] , [ 1 ] ]

> > > m = c o p y . d e e p c o p y ( l )

> > > id ( l ) ; id ( m ) 4 6 9 4 8 2 9 6

4 6 9 4 8 1 5 2

> > > id ( l [ 1 ] ) ; id ( m [ 1 ] ) 4 6 9 4 8 2 2 4

4 7 0 0 1 8 2 4

> > > l [ 1 ] [ 0 ] = 2

> > > m [[0] , [ 1 ] ]

II.5 time

Le module time(http://docs.python.org/3.3/library/time.html) permet de faire des manipulations sur le temps

(31)

> > > i m p o r t t i m e

> > > t i m e . g m t i m e ()

t i m e . s t r u c t _ t i m e ( t m _ y e a r =2013 , t m _ m o n =3 , t m _ m d a y =24 , t m _ h o u r =17 , t m _ m i n =24 , t m _ s e c =1 , t m _ w d a y =6 , t m _ y d a y =83 , t m _ i s d s t =0)

# OK ce n ’ est pas t r e s e x p l i c i t e , m a i s on p e u t f o r m a t e r c e l a

> > > t i m e . s t r f t i m e ( " % A % d % B % Y % H :%M :%S " , t i m e . g m t i m e () )

’ S u n d a y 24 M a r c h 2 0 1 3 17 :26 :14’

# et si on e s s a i e en f r a n c a i s

> > > i m p o r t l o c a l e

> > > l o c a l e . s e t l o c a l e ( l o c a l e . LC_ALL , ’ f r _ F R . UTF -8 ’ )

’ f r _ F R . UTF -8 ’

> > > t i m e . s t r f t i m e ( " % A % d % B % Y % H :%M :%S " , t i m e . g m t i m e () )

’ d i m a n c h e 24 m a r s 2 0 1 3 17 :28 :55’

# et oui f a u t t r a v a i l l e r a u s s i le d i m a n c h e

On peut notamment utiliser la fonctionclock()(ou, à partir de Python3.3,process_time()) afin de déterminer le temps passé dans une fonction

> > > t1 = t i m e . c l o c k ()

> > > max ([ x * y for x in r a n g e ( 1 0 0 0 0 ) for y in r a n g e ( 1 0 0 0 0 ) ]) 9 9 9 8 0 0 0 1

> > > t2 = t i m e . c l o c k ()

> > > t2 - t1

7 . 0 7 9 9 9 9 9 9 9 9 9 9 9 9 9

La fonction ne mesure pas un vraiment temps écoulé, mais un temps « processeur ».

II.6 this

> > > i m p o r t t h i s

III Écrire son module

Lorsqu’on développe un projet conséquent, on a fortement envie de scinder son code en module indépendant : des modules qui contiennent un ensemble de fonctions qui peuvent être réutilisées dans différentes situations. On incorpore alors son module de la même façon qu’un module fourni (il faut simplement qu’il soit accessible - en général en le mettant dans le dossier du module principal, ça tourne).

Quelques commentaires sur__name__ :

> > > _ _ n a m e _ _

’ _ _ m a i n _ _ ’

on dispose donc d’une variable donnant le nom de l’espace de nom actuel (cette variable__name__). Par exemple, on dispose d’un module enregistré sous le nommod.pyqui contient cela :

def f ( x ) :

p r i n t( _ _ n a m e _ _ ) r e t u r n( x +2) on l’importe dans le shell :

> > > f r o m mod i m p o r t *

> > > _ _ n a m e _ _

’ _ _ m a i n _ _ ’

> > > f (2) mod 4

On sait donc à un moment dans quel espace de nom on se situe. Quel est l’intérêt simple de la chose... écrire dans un module, une portion de code qui ne sera exécutée que lorsque ce sera le module principal : on fait régulièrement cela pour inclure plusieurs éléments de tests du module, ces tests n’étant réalisés que lorsqu’on exécute directement le module. Un exemple : on crée un module calcul.py qui contient cela :

(32)

IV. QUELQUES EXERCICES 29

p r i n t( " e x e m p l e de p r i n t à ne pas f a i r e ! " ) def f ( x , y ) :

r e t u r n( x * y )

if _ _ n a m e _ _ == ’ _ _ m a i n _ _ ’ : p r i n t( f (3 , 4) )

p r i n t( f ( " abc " , 2) ) p r i n t( f ([1 ,2 ,3] , 3) )

Lorsqu’on exécute ce module, on obtient :

( p y t h o n _ s t a g e _ 3 .3) p y t h o n 3 6 @ k e n o b i :~$ p y t h o n c a l c u l . py E x e m p l e de p r i n t à ne pas f a i r e !

12 a b c a b c

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

En revanche, si on importe ce module, la partie de tests n’est pas évaluée.

> > > f r o m c a l c u l i m p o r t *

E x e m p l e de p r i n t à ne pas f a i r e !

> > > f (3 , 4) 12

IV Quelques exercices

Exercice IV.1

Utiliser Python et le modulerandompour obtenir une réponse approchée aux questions suivantes : Une urne contientnboules blanches et2boules noires.

– On tire successivement les boules de l’urne. Quelle est la position moyenne de la première boule noire tirée ? de la seconde ?

– On tire avec remise une boule de l’urne. On s’arrête lorsqu’on a tirépfois une boule noire (pétant fixé). Quel est le nombre moyen de tirages ?

(33)

(34)

Chapitre 6

Quelques remarques

I Sur le codage des caractères

À l’origine de l’informatique, les seuls caractères utilisés étaient les caractères latins sans accents. On pouvait donc coder ces caractères sur 7 bits (128 combinaisons possibles). Le code utilisé est le code ASCII¹. Ensuite, il y a eu différents codes pour les autres caractères que ceux de la langue anglaise : les caractères accentués pour le français, les caractères grecques, . . . Ainsi, pour le français, il y a eu la normelatin-1, mais aussi par exemple la norme windows ! Aujourd’hui, c’est la normeUnicodequi est la référence.

C’est cette norme qu’utilisePython3 par défaut, mais pasPython2. C’est pourquoi, il est préférable de dire à Pythonque l’on travaille avec un encodageutf8(encodage standard de la normeUnicode). Ceci se fait simplement en ajoutant, à tous vos fichiers, la première ligne :

# -* - c o d i n g : utf -8 -* -

Pour illustrer ceci, considérons les fichierscar.pyet car_utf8.pysuivant a = " c a r a c t è res a c c e n t u é s "

p r i n t( a )

# -* - c o d i n g : utf -8 -* - a = " c a r a c t è res a c c e n t u é s "

p r i n t( a )

Alors si on exécute ces modules sont Python 3 (commande python3 ou commande python) et Python 2(

commandepython2) on obtient

( p y t h o n _ s t a g e _ 3 .3) p y t h o n 3 6 @ k e n o b i :~$ p y t h o n 3 car . py c a r a c t è res a c c e n t u é s

( p y t h o n _ s t a g e _ 3 .3) p y t h o n 3 6 @ k e n o b i :~$ p y t h o n 3 c a r _ u t f 8 . py c a r a c t è res a c c e n t u é s

( p y t h o n _ s t a g e _ 3 .3) p y t h o n 3 6 @ k e n o b i :~$ p y t h o n 2 car . py F i l e " car . py " , l i n e 1

S y n t a x E r r o r : Non - A S C I I c h a r a c t e r ’ \ xc3 ’ in f i l e car . py on l i n e 1 , but no

e n c o d i n g d e c l a r e d ; see h t t p ://www . p y t h o n . org / p e p s / pep - 0 2 6 3 . h t m l for d e t a i l s ( p y t h o n _ s t a g e _ 3 .3) p y t h o n 3 6 @ k e n o b i :~$ p y t h o n 2 c a r _ u t f 8 . py

c a r a c t è res a c c e n t u é s

Remarque I.1

Bien sûr si vous le souhaitez vous pouvez travailler avec les codeslatin1ouwindows. Pour cela il faut respectivement mettre à la première ligne # -*- coding: latin-1 -*-ou# -*- coding: CP1252 -*-

II Pour une bonne pratique de la programmation

Il est préférable quand on programme en Pythonde respecter quelques usages :

1. American Standard Code for Information Interchange

31