ENSAE

Ecole Nationale de la Statistique et de l’Administration Economique

Initiation à la programmation

avec les langages Python

et Visual Basic for Application (VBA)

Xavier Dupré

http ://www.xavierdupre.fr/
Table des matières

1. Avant-propos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

partie I Le langage Python 11

2. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1 Ordinateur et langages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2 Présentation du langage Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3 Installation du langage Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4 Installation d’un éditeur de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5 Premier programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.6 Installation d’extensions (ou modules externes) . . . . . . . . . . . . . . . . . . . . . . . . 23
2.7 Outils connexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3. Types et variables du langage Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.1 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.2 Types immuables (ou immutable) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3 Types modifiables (ou mutable) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.4 Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

4. Syntaxe du langage Python (boucles, tests, fonctions) . . . . . . . . . . . . . . . . . . . . . . . . 51

4.1 Les trois concepts des algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.2 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.4 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.5 Indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.6 Fonctions usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.7 Constructions classiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

5. Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.1 Présentation des classes : méthodes et attributs . . . . . . . . . . . . . . . . . . . . . . . . 81
5.2 Constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5.3 Apport du langage Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
5.4 Opérateurs, itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
5.5 Méthodes, attributs statiques et ajout de méthodes . . . . . . . . . . . . . . . . . . . . . . 93
5.6 Copie d’instances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
 TABLE DES MATIÈRES 3

5.7 Attributs figés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

5.8 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
5.9 Compilation de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
5.10 Constructions classiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

6. Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
6.1 Principe des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
6.2 Définir ses propres exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
6.3 Exemples d’utilisation des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

7. Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
7.1 Modules et fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
7.2 Modules internes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
7.3 Modules externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
7.4 Python et les autres langages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
7.5 Ecrire un module en langage C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
7.6 Boost Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

8. Fichiers, expressions régulières, dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

8.1 Format texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
8.2 Fichiers zip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
8.3 Manipulation de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
8.4 Format binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
8.5 Paramètres en ligne de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
8.6 Expressions régulières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
8.7 Dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
8.8 Problème de jeux de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

9. Interface graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

9.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
9.2 Les objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
9.3 Disposition des objets dans une fenêtre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
9.4 Evénements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
9.5 D’autres fenêtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
9.6 Constructions classiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

10. Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

10.1 Premier thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
10.2 Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
10.3 Interface graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
10.4 Files de messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
 TABLE DES MATIÈRES 4

partie II Enoncés pratiques, exercices 207

11. Exercices pratiques pour s’entraîner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

11.1 Montant numérique, montant littéral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
11.2 Représentation des données, partie de dames . . . . . . . . . . . . . . . . . . . . . . . . . . 211
11.3 Reconnaître la langue d’un texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
11.4 Carrés magiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
11.5 Tri rapide ou quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
11.6 Calcul matriciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

12. Exercices pratiques pour s’évaluer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244

12.1 Recherche dichotomique (2005-2006) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
12.2 Ajouter un jour férié (2006-2007) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
12.3 Fréquentation d’un site Internet (2007-2008) . . . . . . . . . . . . . . . . . . . . . . . . . 249
12.4 Ajout d’une pièce de monnaie (2008-2009) . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
12.5 Fusion de fichiers (2008-2009) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
12.6 Nuées dynamiques (2009-2010) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
12.7 Voyageur de commerce (2009-2010) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
12.8 Densité des restaurants à Paris (2010-2011) . . . . . . . . . . . . . . . . . . . . . . . . . . 275
12.9 Calcul matriciel et problème simple d’optimisation (2011-2012) . . . . . . . . . . . . . . . 278
12.10Court examen, deux questions simples (2012-2013) . . . . . . . . . . . . . . . . . . . . . . 284
12.11Exercice de préparation au TD noté (2012-2013) . . . . . . . . . . . . . . . . . . . . . . . 290
12.12Calcul matriciel et fonction de remplissage (2012-2013) . . . . . . . . . . . . . . . . . . . 299
12.13Manipulation de données, expressions régulières (2012-2013) . . . . . . . . . . . . . . . . 307
12.14Interrogation écrite 30 minutes (2012-2013) . . . . . . . . . . . . . . . . . . . . . . . . . . 308
12.15Interrogation écrite 45 minutes (2012-2013) . . . . . . . . . . . . . . . . . . . . . . . . . . 314
12.16Ajout d’espace dans une phrase (2012-2013) . . . . . . . . . . . . . . . . . . . . . . . . . 318

13. Exercices écrits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

13.1 Premier énoncé (2005-2006) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
13.2 Second énoncé (2006-2007) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
13.3 Troisème énoncé (2007-2008) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
13.4 Quatrième énoncé (2007-2008) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
13.5 Cinquième énoncé (2008-2009) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
13.6 Sixième énoncé (2009-2010) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
13.7 Septième énoncé (2010-2011) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
13.8 Exercices supplémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381

partie III Résumé pratique, outils d’aide, algorithmes à connaître 385

14. Ecrire un programme à plusieurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387

14.1 Trois conseils pour écrire un programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
14.2 Trucs et astuces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
 TABLE DES MATIÈRES 5

15. Instructions fréquentes en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389

15.1 Le langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
15.2 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
15.3 Tests et boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394
15.4 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
15.5 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
15.6 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
15.7 Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
15.8 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
15.9 Erreurs, confusions fréquentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

16. Outils d’aide au développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405

16.1 Modules d’aide au développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
16.2 Tortoise SVN : suivi de version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
16.3 HTML Help Workshop : construction d’un fichier d’aide . . . . . . . . . . . . . . . . . . . 419
16.4 InnoSetup : installateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
16.5 MoinMoin : wiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
16.6 SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
16.7 Modules divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
16.8 Graphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
16.9 Apache : serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459

17. Algorithmes usuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464

17.1 Calcul d’une intégrale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
17.2 Tri simple et tri fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465

partie IV Visual Basic For Applications (VBA) 475

18. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476

18.1 Visual Basic et macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476
18.2 Première procédure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476
18.3 Macro liée à une feuille Excel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
18.4 Erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
18.5 Autres possibillités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479

19. Le langage VBA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481

19.1 Préliminaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
19.2 Variables et opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
19.3 Affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485
19.4 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485
19.5 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
19.6 Fonctions et procédures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
19.7 Erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
 TABLE DES MATIÈRES 6

19.8 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489

20. Exercices autour de l’automatisation de tâches quotidiennes . . . . . . . . . . . . . . . . . . . . 491

20.1 Création de PDF puis envoi automatique de mails . . . . . . . . . . . . . . . . . . . . . . 491
20.2 Création d’une présentation à partir de photos de vacances . . . . . . . . . . . . . . . . . . 499
20.3 Résolution d’un sudoku . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507

21. VBA et Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517

21.1 Excel et Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
21.2 Python, valeurs propres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
21.3 Des graphes complexes avec R sous Excel . . . . . . . . . . . . . . . . . . . . . . . . . . . 522

partie V Sujets informatiques 529

22. Périphériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531

22.1 Copie de fichiers vers une clé USB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
22.2 Recherche sur Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
22.3 Python, Excel, Latex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
22.4 Fond d’écran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
22.5 Popularité selon différents moteurs de recherce . . . . . . . . . . . . . . . . . . . . . . . . 547

23. Tri, dictionnaires, tracé d’une ligne... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550

23.1 Dictionnaires (1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
23.2 Dictionnaires (2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
23.3 Tri simple et tri fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
23.4 Tracer une ligne sans multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556

24. Sujets autour des interfaces graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566

24.1 Interface graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
24.2 Jeu avec PyGame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572

25. Manipulation de tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579

partie VI Sujets mathématiques 604

26. Logique, résolution de jeux, cryptographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605

26.1 Résolution d’un sudoku . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
26.2 Résolution d’un puzzle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
26.3 Autour de la conjecture de Syracuse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
26.4 Résolution d’une énigme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628
26.5 Casser le code de Vigenère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
26.6 Simulation informatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642
26.7 Décomposition d’une fraction rationnelle en éléments simples . . . . . . . . . . . . . . . . 653
 TABLE DES MATIÈRES 7

26.8 Conjecture de Syracuse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675

27. Graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679

27.1 Plus court chemin dans un graphe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679
27.2 Problème du voyageur de commerce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693
27.3 Distance d’édition, distance entre graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . 722

28. Optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745

28.1 Optimisation numérique du second ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745
28.2 Optimiser de coûts en environnement aléatoire . . . . . . . . . . . . . . . . . . . . . . . . 767
28.3 Stratégie automatique de trading en finance . . . . . . . . . . . . . . . . . . . . . . . . . . 775
28.4 Equation différentielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 798

29. Modélisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802

29.1 Simulation génétique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802
29.2 Simulation d’une corde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 803
29.3 Filtrage du signal sonore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813
29.4 Images de synthèse, modèle d’illumination . . . . . . . . . . . . . . . . . . . . . . . . . . . 818

30. Sujets statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843

30.1 File d’attente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843
30.2 Disparition des gens aux yeux bleus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 850
30.3 Calculer des espérances de vie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 854
30.4 Trouver une personne ayant les mêmes goûts que vous . . . . . . . . . . . . . . . . . . . . 863
30.5 Calcul d’un histogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 868
30.6 Classification à l’aide de plus proches voisins . . . . . . . . . . . . . . . . . . . . . . . . . . 874
30.7 Intervalle de confiance et p-Value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 895

partie VII Exercices autour de sujets déjà abordés 900

31. Exercices plutôt mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 901

31.1 Tracé d’une ligne sans multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 901
31.2 Un portrait lointain à l’aide du TSP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 908
31.3 Image de synthèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 926

32. Exercices plutôt informatiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 943

32.1 Conserver ses fichiers sur une clé USB avec une interface graphique . . . . . . . . . . . . . 943
32.2 Conserver ses fichiers sur une clé USB avec une interface graphique (2) . . . . . . . . . . . 951

partie VIII Tutoriels et nouvelles versions des TD 954

33. Tutoriels niveau confirmé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955

33.1 Clustering dans un graphe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955
 TABLE DES MATIÈRES 8

33.2 Distance d’édition et Viterbi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 965

34. Exercices minutés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 971

34.1 Recherche dichotomique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 971
34.2 Tri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 976
34.3 Cryptage de Vigenère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 980
34.4 Deviner la langue d’un texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 983
34.5 Carré Magique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 985
34.6 Graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 990
34.7 Régression linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 993
34.8 Décorrélation de variables normales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 998
34.9 Expression réguligères et discours des présidents . . . . . . . . . . . . . . . . . . . . . . . . 1001
34.10Plus court chemin dans un graphe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1003

partie IX Bibliographie, index, remerciements 1008

Index 1012
Chapitre 1
Avant-propos

Quelques années passées à initier les élèves à l’informatique avec différents langages me poussent à dire
que le langage Python est sans doute un langage qui s’apprend plus vite sans pour autant être limité. Les
ordinateurs ont progressé et il n’est plus souvent nécessaire d’utiliser des langages tels que le C certes plus
rapide et plus connu mais aussi plus difficile à maîtriser. A partir de 2004, le langage Python a été utilisé
à l’ENSAE 1 pour initier les élèves à la programmation et, depuis cette date, j’ai pu observer un regain
d’intérêt des élèves pour cette matière qui s’appuyait auparavant sur le langage C. Certains étudiants
avouent même s’être amusés ; leur projet de programmation n’est plus centré sur un langage mais sur les
résultats qu’il permet d’obtenir.
Le langage Python suffit pour la plupart des besoins d’un ingénieur et permet de réaliser beaucoup plus
rapidement des programmes informatiques qui fonctionnent sur les principaux systèmes d’exploitation.
Internet fournit également un panel très large de librairies pour faire du calcul scientifique, des jeux ou
encore des sites Internet. Il suffit parfois de quelques minutes pour télécharger une extension et s’en servir.
Malgré ces avantages, il existe peu de livres de langue française sur ce langage, beaucoup moins que ceux
écrits en langue anglaise dont quelques uns seulement sont traduits.
Quelques d’ouvrages décrivent minutieusement le langage et ses extensions ([Swinnen2004], [Martelli2004],
[Pilgrim2004], [Ziadé2006]). L’ouvrage [Swinnen2004] part d’exemples pour expliquer le langage. Les trois
autres sont plus classiques dans leur présentation : les exemples sont moins présents et leur plan suit
plus les différentes fonctionnalités du langage. Un autre ouvrage ([Dayley2007]) prend une direction diffé-
rente : des explications courtes, beaucoup de courts exemples qui répondent à des besoins précis. Un livre
([Brucher2008]) s’intéresse à l’utilisation du langage que pourrait en faire un ingénieur : les fonctionnalités
liées au calcul numérique sont mieux représentées. Un dernier livre ([Bailly2008]) propose des exemples de
programmes équivalents rédigés en Python et C++ sans présenter de cas associant ces deux langages. J’ai
apprécié [Dayley2007] pour ses exemples concis, [Martelli2004] pour son exhaustivité. [Ziadé2006] est une
bonne référence pour ceux qui souhaitent prendre de bonnes habitudes de programmation.
Ce livre n’aborde pas des sujets comme la programmation web ou l’utilisation conjointe des langages
Python et SQL. La description du langage couvre les besoins qui sont ceux d’un ingénieur, c’est-à-dire une
personne dont la programmation ne constitue pas l’essentiel de son travail. Chaque notion est illustrée
par des exemples 2 . Ceux-ci sont particulièrement présents lors de l’introduction de notions pas toujours
évidentes à comprendre comme les threads, les interfaces graphiques et l’utilisation de C++. Le livre se
ferme sur plusieurs chapitres ne contenant que des exercices et leurs corrections. Ces exercices sont de
deux types : des travaux dirigés et des problèmes courts. Ces derniers ont été posés lors des examens à
l’ENSAE et ont été conçus pour préparer les élèves à répondre aux questions techniques lors des entretiens
d’embauche.
Le langage Python évolue assez vite, il est de plus en plus utilisé ce qui explique la multitude d’informations
qu’on peut trouver sur Internet. Le site officiel 3 recense la plupart des extensions (plus d’une centaine)
accessibles gratuitement. Il existe également de nombreux sites d’aide comme WikiPython 4 qui recense
des exemples de programmes sur des sujets variés. L’anglais est la langue d’échange par excellence dans le
monde informatique et le langage Python n’y échappe pas même si les moteurs de recherches retournent
1. Ecole Nationale de la Statistique et de l’Administration Economique, http://www.ensae.fr/
2. L’ensemble de ces exemples est accessible depuis le site http://www.xavierdupre.fr.
3. http://www.python.org/
4. http://wikipython.flibuste.net/
presque toujours des résultats en français pour des requêtes concernant Python, à condition toutefois d’y
insérer un mot de syntaxe exclusivement française.
Il n’est pas utile de lire tous les chapitres pour savoir programmer. Le chapitre 2 décrit l’installation du
langage Python et son utilisation via des éditeurs de texte. Les chapitres 3 et 4 introduisent les premiers
concepts, à partir de là, il est déjà possible d’écrire des programmes conséquents et notamment de lire les
chapitres 12 à 13 pour s’exercer.
Les chapitres 5 et 6 s’intéressent à la programmation objet, qui n’est pas indispensable dans un premier
temps. La programmation est utilisée en tant qu’outil pour atteindre un objectif, réaliser une étude ou
tester un modèle. Nombreux sont les élèves qui choisissent de contourner les classes et les objets sans pour
autant nuire à la qualité de leur travail ; les programmes qu’ils conçoivent sont sans doute moins lisibles
mais ils parviennent à l’objectif fixé.
Le chapitre 7 présente comment créer ses propres extensions. Les derniers paragraphes ne concernent que
des utilisateurs experts puisqu’ils parlent de l’utilisation conjointe des langages Python et C++ à partir
d’un exemple conçu à cet effet et utilisable en peu de temps 5 . Cette technique est intéressante dans des
domaines où les calculs doivent être impérativement très rapides comme en finance, matière à laquelle sont
formés les étudiants de l’ENSAE.
Le chapitre 8 introduit les fichiers où comment conservées des résultats sur disque dur. Le chapitre 9
présente les interfaces graphiques et le chapitre 10 les threads. Les chapitres 11 à 13 ne contiennent que
des exercices et problèmes sur lesquels plusieurs promotions de l’ENSAE ont été évaluées.
Visual Basic for Application (VBA)
Lorsqu’une application comme Excel est aussi couramment utilisée, il est parfois utile de savoir programmer
dans le langage associé à ce logiciel. Même s’il n’est pas toujours aussi convivial que Python, on y retrouve
les mêmes éléments (boucles, tests, fonctions). Néanmoins, comme Python, VBA est un langage assez lent et
il est aussi difficile de trouver des extensions de calcul numérique. C’est pourquoi, il est parfois utile de lier
les deux langages afin de pouvoir utiliser les nombreux modules disponibles pour le langage Python tels que
scipy ou encore BioPython. Le premier regroupe aborde le traitement du signal, l’estimation de densité, la
classification, l’optimisation... Le second module aborde des techniques spécifiques au domaine biologique
et plus spécifique les séquences ADN.

5. Concernant ce point, cet exemple téléchargeable permet de construire entièrement un module Python écrit en C++,
l’ajout d’une fonctionnalité ne prenant que quelques minutes. Cet exemple fonctionne sous Microsoft Windows avec Microsoft
Visual C++, il utilise la librairie Boost Python. Microsoft Windows est le système d’exploitation le plus courant dans les
sociétés.
 Première partie

LE LANGAGE PYTHON

Les programmes informatiques sont souvent l’aboutissement d’un raisonnement, d’une construction, d’une
idée, parfois imprécise mais dont le principe général est compris. Et pour valider cette idée, on utilise un
langage de programmation qui ne tolère jamais l’imprécision, qui refuse de comprendre au moindre signe
de ponctuation oublié, qui est d’une syntaxe si rigide.
On reste parfois indécis devant une erreur qui se produit avec un exemple qu’on a pourtant recopié sans
ajout. On compare les deux versions sans faire attention aux petits détails qui ne changent rien pour le
concepteur et beaucoup pour le langage. C’est un espace en plus ou en moins, un symbole : oublié... Il
est fréquent de ne pas vérifier ces petits détails lorsqu’on commence à programmer. Et ils découragent
souvent. On s’habitue peu à peu au fait qu’il ne faut pas confondre parenthèses et crochets, qu’il manque
des guillemets, qu’il y a une lettre en plus, ou en moins.
Lorsque sa syntaxe n’est pas respectée, le langage de programmation ne cherche jamais à comprendre
l’intention du programmeur. Il faut penser à la vérifier en premier lorsqu’une erreur se produit. Les messages
d’erreur, obscurs au premier abord, donnent néanmoins un bon indice pour corriger un programme. Et si
cela ne suffisait pas, il ne faut pas hésiter à recopier ce message dans un moteur de recherche sur Internet
pour y trouver une indication dès les premiers résultats, et le plus souvent en français.
Cette première partie est consacrée à la description du langage Python. Il est parfois utile de reproduire
un des exemples, de le faire fonctionner, de le modifier, d’y introduire des erreurs puis de les corriger.
Plus tard, dans de plus longs programmes, les mêmes erreurs seront plus difficiles à déceler et l’expérience
montre qu’on fait presque toujours les mêmes erreurs.
Chapitre 2
Introduction

Ce chapitre s’intéresse tout d’abord à l’installation du langage Python et à la réalisation d’un premier pro-
gramme avec des instructions dont le sens est intuitif. Les derniers paragraphes présentent de nombreuses
extensions disponibles sur Internet. Elles rendent le langage Python très attractif dans des domaines variés.
Ces extensions témoignent que ce langage emporte l’adhésion de nombreux informaticiens qui en retour
assurent sa pérennité. Il permet de relier facilement différents éléments, différentes applications. C’est une
des raisons de son succès.

2.1 Ordinateur et langages

Il est rare aujourd’hui de ne pas avoir déjà entendu ou lu les termes informatiques définis ci-dessous. C’est
un rapide rappel.

2.1.1 L’ordinateur
On peut considérer simplement qu’un ordinateur est composé de trois ensembles : le microprocesseur, la
mémoire, les périphériques. Cette description n’a pas varié en cinquante ans depuis qu’un scientifique du
nom de von Neumann l’a imaginée.
Le microprocesseur est le cœur de l’ordinateur, il suit les instructions qu’on lui donne et ne peut travailler
qu’avec un très petit nombre d’informations. Sa vitesse se mesure en GigaHertz (GHz) qui correspondent
au nombre d’opérations qu’il est capable d’effectuer en une seconde et en nombre de cœurs qui détermine
le nombre d’opérations en parallèle qu’il est capable d’exécuter. On lui adjoint une mémoire avec laquelle
il échange sans arrêt des données. Sa capacité se mesure en octets (kilo-octets, mégaoctets, gigaoctets ou
leurs abréviations Ko, Mo, Go 1 ). Ces échanges entre processeur et mémoire sont rapides.
Les périphériques regroupent tout le reste (écran, clavier, souris, disque dur, imprimante...). Ils sont princi-
palement de deux types : les périphériques de stockages (disque dur, DVD) et ceux qui nous permettent de
dialoguer avec l’ordinateur, que ce soit pour afficher, sonoriser (écran, enceintes) ou pour recevoir (souris,
clavier, webcam, micro...).

2.1.2 Termes informatiques

Certains termes reviendront fréquemment dans le livre. Ils sont souvent utilisés comme si tout le monde
les connaissait comme la notion d’algorithme qui paraît plutôt abstraite si on se réfère à sa définition dans
le dictionnaire. Dans la pratique, on confond souvent algorithme avec programme informatique.

Définition 2.1 : algorithme

Un algorithme est une suite finie de règles à appliquer dans un ordre déterminé à un nombre fini
de données pour arriver avec certitude, en un nombre fini d’étapes, à un certain résultat et cela,
indépendamment des données.

1. Un kilo-octets équivaut à 1024 = 210 octets, un Mo à 1024 Ko et un Go à 1024 Mo.

 2. Introduction 13

Leur écriture est indépendante du langage choisi, qu’il soit écrit en Basic, en Pascal, en C, en Perl, en PHP,
en Python, en français, un algorithme reste le même. Pour les algorithmes simples (un tri par exemple), le
passage d’un langage à l’autre consiste souvent à traduire mot-à-mot, ce qui favorise l’apprentissage d’un
nouveau langage informatique lorsqu’on en connaît déjà un. Les différences entre ces langages résident
dans leur spécialisation, le Visual Basic permet de piloter les applications Microsoft Office, le PHP, le
JavaScript sont dédiés à la programmation Internet. Le langage Python n’est pas spécialisé. Il est souvent
moins efficace que chaque langage appliqué à son domaine de prédilection mais il peut éviter l’apprentissage
d’une syntaxe différente.

Définition 2.2 : programme

Un programme informatique est une suite d’instructions ou séquence d’instructions. C’est la réali-
sation informatique d’un ou plusieurs algorithmes. Il dépend du langage.

Définition 2.3 : compilateur et compilation

Le compilateur est un programme qui traduit un code écrit dans un langage de programmation en
langage dit "machine", compréhensible par l’ordinateur. La compilation est le fait de traduire un
programme afin que l’ordinateur le comprenne.

Définition 2.4 : langage interprété

Un langage interprété est converti en instructions propres à la machine au fur et à mesure de son
exécution.

Le langage Python n’est pas un langage compilé car un programme Python n’est pas traduit en langage
machine, il est un langage interprété. Entre son écriture et son exécution, il n’y a pas d’étape intermédiaire
telle que la compilation et on peut ainsi tester un programme plus rapidement même si son exécution est
alors plus lente.

Définition 2.5 : mot-clé

Un mot-clé est une composante du langage et fait partie de sa grammaire qui comprend également
les opérateurs numériques.

La table 4.1 (page 52) regroupe les mots-clés du langage Python. Elle contient peu de mots-clés : son
concepteur s’est attaché à créer un langage objet avec la grammaire la plus simple possible.

Définition 2.6 : instruction

Ce terme est assez vague et dépend en général du langage. On peut considérer qu’une instruction
est une expression syntaxiquement correcte pour un langage donné.

Les instructions sont très courtes et tiennent sur une ligne mais si on n’en prend qu’une partie, elle perd
son sens. Ce serait comme considérer une phrase avec un verbe transitif mais sans son complément d’objet
direct.

2.2 Présentation du langage Python

2.2.1 Histoire résumée
Python est un langage objet interprété de haut niveau, il a été créé au début des années quatre-vingt-dix
par Guido van Rossum. Entre 1995 et 2001, Rossum a changé plusieurs fois de travail tout en continuant
l’élaboration du langage Python. En 2001, la PSF (Python Software Foundation) est créée. Il s’agit d’une
organisation à but non lucratif détenant les droits de propriété intellectuelle de Python. Il est depuis
 2. Introduction 14

distribué sous forme de logiciel libre. Python est couvert par sa propre licence 2 . Toutes les versions depuis
la 2.0.1 sont compatibles avec la licence GPL 3 . Selon Wikipedia 4 , Rossum travaillerait maintenant pour
l’entreprise Google qui propose une plate-forme de développement de sites web en Python 5 et qui héberge
de nombreux projets en langage Python via son projet Google Code 6 .

2.2.2 Le langage en quelques points

On distingue plusieurs classes parmi les langages informatiques selon la syntaxe qu’ils proposent ou les
possibilités qu’ils offrent. Python est un langage : interprété, orienté objet, de haut niveau, modulaire, à
syntaxe positionnelle, au typage dynamique.
Le langage Python est dit interprété car il est directement exécuté sans passer par une phase de compilation
qui traduit le programme en langage machine, comme c’est le cas pour le langage C. En quelque sorte,
il fonctionne autant comme une calculatrice que comme un langage de programmation. Afin d’accélérer
l’exécution d’un programme Python, il est traduit dans un langage intermédiaire 7 qui est ensuite interprété
par une machine virtuelle Python. Ce mécanisme est semblable à celui propre au langage Java.
Le langage est orienté objet car il intègre le concept de classe ou d’objet. Un objet regroupe un ensemble
de données et un ensemble de fonctionnalités attachées à ces données. Ce concept relie la description des
données et les algorithmes qui leur sont appliqués comme un tout indissociable. Un objet est en quelque
sorte une entité autonome avec laquelle on peut communiquer via une interface.
On considère que le langage Python est de haut niveau car il propose des fonctionnalités avancées et
automatiques comme le garbage collecting. Cette tâche correspond à la destruction automatique des objets
lorsqu’ils ne sont plus utilisés. Cette fonctionnalité est proposée par la plupart des langages interprétés ou
encore Java mais pas C++. Il propose également des structures de données complexes éloignées des types
numériques standards telles que des dictionnaires.
Le langage Python est modulaire. La définition du langage est très succincte et autour de ce noyau concis,
de nombreuses librairies ou modules ont été développées. Python est assez intuitif. Etre à l’aise avec ce
langage revient à connaître tout autant sa syntaxe que les nombreux modules disponibles. Comme il est
assez simple de construire un pont entre Python et C++, de nombreux projets open source antérieurs à
Python sont maintenant accessibles dans ce langage et sous toutes les plateformes.
Le langage Python est à syntaxe positionnelle en ce sens que l’indentation fait partie du langage. Le
point virgule permet de séparer les instructions en langage C, l’accolade permet de commencer un bloc
d’instructions. En Python, seule l’indentation permet de marquer le début et la fin d’un tel bloc, ce procédé
consiste à décaler les lignes vers la droite pour signifier qu’elles appartiennent au même bloc d’instructions
et qu’elles doivent être exécutées ensemble. Cette contrainte rend les programmes Python souvent plus
faciles à lire.
Le langage Python est à typage dynamique. Le type d’une variable, d’une donnée est définie lors de
l’exécution du programme. Chaque information est désignée par un identificateur qui est manipulé tout
au long du programme. Le fait que telle ou telle opération soit valide est vérifiée au moment où elle doit
être réalisée et non au moment où le programme est traduit en langage machine, c’est-à-dire compilé.

2.2.3 Avantages et inconvénients du langage Python

Alors qu’il y a quelques années, le langage C puis C++ s’imposaient souvent comme langage de pro-
grammation, il existe dorénavant une profusion de langages (Java, JavaScript, PHP, Visual Basic, C#,
2. Voir le site http://www.python.org/psf/license/, cette licence autorise les usages commerciaux.
3. Ou GNU Public Licence (voir le site http://www.gnu.org/copyleft/gpl.html).
4. http://fr.wikipedia.org/wiki/Python_(langage)
5. http://code.google.com/appengine/
6. http://code.google.com/
7. Celui-ci est appelé bytecode. Ce mot ne signifie pas grand chose excepté que ce bytecode est seulement compréhensible
par la machine virtuelle Python.
 2. Introduction 15

Perl, PHP, ...). Il est souvent possible de transposer les mêmes algorithmes d’un langage à un autre. Le
choix approprié est bien souvent celui qui offre la plus grande simplicité lors de la mise en œuvre d’un
programme même si cette simplicité s’acquiert au détriment de la vitesse d’exécution. Le langage PHP
est par exemple très utilisé pour la conception de sites Internet car il propose beaucoup de fonctions très
utiles dans ce contexte. Dans ce domaine, le langage Python est une solution alternative intéressante.
Comme la plupart des langages, le langage Python est tout d’abord portable puisqu’un même programme
peut être exécuté sur un grand nombre de systèmes d’exploitation comme Linux, Microsoft Windows,
Mac OS X... Python possède également l’avantage d’être entièrement gratuit tout en proposant la possi-
bilité de pouvoir réaliser des applications commerciales à l’aide de ce langage.
Si le langage C reste le langage de prédilection pour l’implémentation d’algorithmes complexes et gour-
mands en temps de calcul ou en capacités de stockage, un langage tel que Python suffit dans la plupart des
cas. De plus, lorsque ce dernier ne convient pas, il offre toujours la possibilité, pour une grande exigence de
rapidité, d’intégrer un code écrit dans un autre langage tel que le C/C++ 8 ou Java, et ce, d’une manière
assez simple. La question du choix du langage pour l’ensemble d’un projet est souvent superflue, il est cou-
rant aujourd’hui d’utiliser plusieurs langages et de les assembler. Le langage C reste incontournable pour
concevoir des applications rapides, en revanche, il est de plus en plus fréquent d’"habiller" un programme
avec une interface graphique programmée dans un langage tel que Python.
En résumé, l’utilisation du langage Python n’est pas restreinte à un domaine : elle comprend le calcul
scientifique, les interfaces graphiques, la programmation Internet. Sa gratuité, la richesse des extensions
disponibles sur Internet le rendent séduisant dans des environnements universitaire et professionnel. Le
langage est vivant et l’intérêt qu’on lui porte ne décroît pas. C’est un critère important lorsqu’on choisit
un outil parmi la myriade de projets open source. De plus, il existe différentes solutions pour améliorer
son principal point faible qui est la vitesse d’exécution.

2.3 Installation du langage Python

2.3.1 Installation du langage Python
Python a l’avantage d’être disponible sur de nombreuses plates-formes comme Microsoft Windows, Linux
ou Mac OS X. L’installation sous Windows est simple. Le langage Python est déjà intégré aux systèmes
d’exploitation Linux et Mac OS X.
Sous Microsoft Windows, il suffit d’exécuter le fichier python-2.6.5.msi 9 ou tout autre version plus récente.
En règle générale, il est conseillé de télécharger la dernière version stable du langage, celle avec laquelle le
plus grande nombre d’extensions seront compatibles, en particulier toutes celles dont vous avez besoin. Les
options d’installation choisies sont celles par défaut, le répertoire d’installation est par défaut C:/Python26.
A la fin de cette installation apparaît un menu supplémentaire dans le menu Démarrer (ou Start) de
Microsoft Windows comme le montre la figure 2.1. Ce menu contient les intitulés suivant :

IDLE (Python GUI) éditeur de texte, pour programmer

Module Docs pour rechercher des informations dans la docu-
mentation
Python (command line) ligne de commande Python
Python Manuals documentation à propos du langage Python
Uninstall Python pour désinstaller Python

La documentation (de langue anglaise 10 ) décrit en détail le langage Python, elle inclut également un
tutoriel 11 qui permet de le découvrir. La ligne de commande (voir figure 2.2) permet d’exécuter des
8. Ce point est d’ailleurs abordé au paragraphe 7.6, page 140.
9. Cette version est disponible à l’adresse http://www.python.org/download/. C’est la version utilisée pour développer les
exemples présents dans ce livre.
10. http://www.python.org/doc/
11. La requête python français de nombreux sites de documentation sur Python en français.
 2. Introduction 16

Figure 2.1 : Menu ajouté à Microsoft Windows.

instructions en langage Python. Elle est pratique pour effectuer des calculs mais il est nécessaire d’utiliser
un éditeur de texte pour écrire un programme, de le sauvegarder, et de ne l’exécuter qu’une fois terminé
au lieu que chaque ligne de celui-ci ne soit interprétée immédiatement après qu’elle a été écrite comme
c’est le cas pour une ligne de commande.

Figure 2.2 : Ligne de commande, la première ligne affecte la valeur 3 à la variable x, la seconde ligne l’affiche.

2.3.2 Particularité de Mac OS X et Linux

Le langage Python est déjà présent sur les ordinateurs d’Apple si ceux-ci sont équipés du système d’ex-
ploitation Mac OS X. Il est également présent dans les distributions Linux. L’installation de Python est
parfois rendue nécessaire si on désire utiliser la dernière version du langage. L’installation des extensions
du langage est similaire à celle d’autres extensions Linux.
Il ne faut pas oublier de vérifier la version du langage Python installée sur l’ordinateur Linux et Mac OS X.
Il suffit pour cela de taper la ligne help() pour en prendre connaissance. Cela signifie que toutes les
extensions qui doivent être installées doivent l’être pour cette version qu’il est néanmoins possible de
mettre à jour 12 .

2.3.3 Utilisation de l’éditeur de texte

La figure 2.1 montre le menu installé par Python dans le menu "Démarrer" de Microsoft Windows. En
choisissant l’intitulé "IDLE (Python GUI)", on active la fenêtre de commande de Python(voir figure 2.3).
Les instructions sont interprétées au fur et à mesure qu’elles sont tapées au clavier. Après chaque ligne,
cette fenêtre de commande conserve la mémoire de tout ce qui a été exécuté. Par exemple :

>>> x = 3
>>> y = 6
>>> z = x * y
>>> print z
18
>>>

Après l’exécution de ces quelques lignes, les variables 13 x, y, z existent toujours. La ligne de commande
ressemble à une calculatrice améliorée. Pour effacer toutes les variables créées, il suffit de redémarrer
12. voir la page http://www.python.org/download/mac/ ou http://www.python.org/download/linux/
13. Les variables sont définies au chapitre 3. En résumé, on peut considérer une variable comme une lettre, un mot qui
désigne une information. Dans cet exemple, les trois variables désignent des informations numériques qu’on peut manipuler
 2. Introduction 17

Figure 2.3 : Fenêtre de commande fournie avec le langage Python.

l’interpréteur par l’intermédiaire du menu Shell–>Restart Shell. Les trois variables précédentes auront
disparu.
Il n’est pas possible de conserver le texte qui a été saisi au clavier, il est seulement possible de rappeler une
instruction déjà exécutée par l’intermédiaire de la combinaison de touches ALT + p, pressée une ou plusieurs
fois. La combinaison ALT + n permet de revenir à l’instruction suivante. Pour écrire un programme et ainsi
conserver toutes les instructions, il faut d’actionner le menu File–>New Window qui ouvre une seconde
fenêtre qui fonctionne comme un éditeur de texte (voir figure 2.4).

Figure 2.4 : Fenêtre de programme, le menu

Run→Run Module permet de lancer l’exécution du pro-
gramme. L’interpréteur Python est réinitialisé au début
de l’exécution et ne conserve aucune trace des travaux
précédents.

Après que le programme a été saisi, le menu Run→Run Module exécute le programme. Il demande au préalable
s’il faut enregistrer le programme et réinitialise l’interpréteur Python pour effacer les traces des exécutions
précédentes. Le résultat apparaît dans la première fenêtre (celle de la figure 2.3). La pression des touches
"Ctrl + C" permet d’arrêter le programme avant qu’il n’arrive à sa fin.
Remarque 2.7 : fenêtre intempestive
Si on veut se débarrasser de cette fenêtre intempestive qui demande confirmation pour enregistrer les
dernières modifications, il suffit d’aller dans le menu Options–>Configure IDLE et de choisir No prompt sur
la quatrième ligne dans la rubrique General (voir figure 2.5). Ce désagrément apparaît sur la plupart des
éditeurs de texte et se résout de la même manière.
Cette description succincte permet néanmoins de réaliser puis d’exécuter des programmes. Les autres
fonctionnalités sont celles d’un éditeur de texte classique, notamment la touche F1 qui débouche sur l’aide
associée au langage Python. Il est possible d’ouvrir autant de fenêtres qu’il y a de fichiers à modifier
simultanément.
comme si elles étaient effectivement des nombres. Les variables supprimées, les informations qu’elles désignaient ne plus
accessibles et sont perdues également.
 2. Introduction 18

Néanmoins, il est préférable d’utiliser d’autres éditeurs plus riches comme celui proposé au paragraphe 2.4.1.
Ils proposent des fonctions d’édition plus évoluées que l’éditeur installé avec Python.

Figure 2.5 : Cliquer sur General puis sur Noprompt

pour se débarrasser de la fenêtre intempestive qui de-
mande à l’utilisateur de confirmer la sauvegarde des
dernières modifications. D’autres éditeurs de texte se
comportent de la même manière et disposent d’une
option similaire.

2.4 Installation d’un éditeur de texte

2.4.1 Editeur SciTe
Il existe de nombreux éditeurs de texte, payants ou gratuits. Le premier proposé dans ce livre est SciTe, il
est gratuit et fonctionne avec de nombreux compilateurs de langages différents (voir figure 2.6). L’éditeur
SciTe 14 est léger et son utilisation ne nécessite pas de droits spécifiques 15 . La gestion des erreurs est égale-
ment plus pratique puisqu’il suffit de cliquer sur une erreur pour que l’éditeur positionne automatiquement
le curseur sur la ligne ayant généré cette erreur.
Une fois installé, il faut configurer l’éditeur de manière à ce qu’il puisse utiliser le compilateur Python. Il
faut cliquer sur le menu Option et choisir la rubrique Open python.properties (voir figure 2.6).
Après avoir sélectionné ce menu, un fichier texte s’ouvre. Vers la fin, on trouve les lignes suivantes qui
contiennent la ligne de commande qui permet d’exécuter un programme Python :

if PLAT_WIN
command.go.*.py=python -u "$(FileNameExt)"
command.go.subsystem.*.py=0
command.go.*.pyw=pythonw -u "$(FileNameExt)"
command.go.subsystem.*.pyw=1

Il suffit de préciser le répertoire où se trouve l’interpréteur qui devrait être c : /python26 sur Microsoft
Windows si le répertoire d’installation par défaut du langage Python n’a pas été modifié.
14. Cet éditeur est accessible depuis l’adresse http://www.scintilla.org/SciTE.html et téléchargeable depuis l’adresse http:
//scintilla.sourceforge.net/SciTEDownload.html.
15. Il arrive fréquemment que des universités, des sociétés interdisent à leurs utilisateurs l’installation de nouveaux logiciels
sur leurs machines pour des raisons de sécurité. Il faut des droits spécifiques pour contourner cette interdiction.
 2. Introduction 19

Figure 2.6 : Configuration de l’éditeur de texte SciTe. Il faut

cliquer sur le menu Option, puis sur Open python.properties
pour ouvrir les paramètres de configuration associées au langage
Python.

if PLAT_WIN
command.go.*.py=c:\Python26\python -u "$(FileNameExt)"
command.go.subsystem.*.py=0
command.go.*.pyw=c:\Python26\pythonw -u "$(FileNameExt)"
command.go.subsystem.*.pyw=1

Une fois ce fichier enregistré, il ne reste plus qu’à écrire un programme Python. Une fois terminé, la touche
F5 lance son exécution. L’exemple de la figure 2.7 montre un cas où l’exécution a été interrompue par une
erreur.

Figure 2.7 : Exécution d’un programme interrompue

par une erreur. Pour cet éditeur, il suffit de cliquer sur
le message d’erreur pour placer le curseur sur la ligne
erronée.

Le site Internet de SciTe propose quelques trucs et astuces pour configurer l’éditeur à votre convenance.
Comme à peu près tous les logiciels, il dispose d’une rubrique FAQ 16 (Frequently Asked Questions) qui
recense les questions et les réponses les plus couramment posées. Cette rubrique existe pour la plupart des
éditeurs et plus généralement pour la plupart des applications disponibles sur Internet.

2.4.2 Python Scripter

Le second éditeur proposé dans ce livre est Python Scripter 17 (voir figure 2.8). Il est plus lourd mais
offre plus de fonctionnalités notamment un débugger qui permet d’exécuter pas à pas un programme
16. http://scintilla.sourceforge.net/SciTEFAQ.html
17. http://mmm-experts.com/
 2. Introduction 20

afin de vérifier chaque ligne de son exécution. Lorsqu’un programme produit de mauvais résultats, la
première solution consiste à afficher de nombreux résultats intermédiaires mais cela nécessite d’ajouter
des instructions un peu partout dans le programme. La seconde méthode est l’utilisation du débugger.
Sans modifier le code informatique, il est possible d’arrêter temporairement l’exécution à une ligne donnée
pour inspecter le contenu des variables à cet instant de l’exécution. Ce logiciel fonctionne sans autre
manipulation supplémentaire autre que son installation.

Figure 2.8 : Copie d’écran de l’éditeur Python Scripter.

Cet éditeur, contrairement à SciTe, ne fonctionne qu’avec Python et ne peut être utilisé avec d’autres
langages. Son apparence est adaptée au développement. Il permet également de voir la liste des variables,
fonctions, classes, présentes dans un programme.

2.4.3 Eclipse et PyDev

Eclipse 18 est un environnement complet de développement adapté à une multitude de langages dont Py-
thon via une extension appelé PyDev 19 . Cette solution s’adresse plus à des gens ayant déjà une expérience
en informatique ou souhaitant construire un projet conséquent. En constante évolution, Eclipse est un édi-
teur très complet mais son utilisation nécessite un apprentissage non négligeable qui n’est pas indispensable
pour des projets de petite taille.

2.4.4 Côté Mac OS X : TextWrangler

Un éditeur possible est TextWrangler 20 qui est gratuit. Lorsqu’on programme à la fois sous Microsoft
Windows et Linux ou Mac OS X, les fichiers contiennent des codes de fins de lignes différents et l’éditeur
vous le fait remarquer à chaque exécution. Pour éviter ce désagrément, il convient d’écraser le fichier
contenant le programme en le sauvegardant à nouveau en prenant soin de choisir des fins de lignes identiques
à celles du monde Linux. Linux fait également la différence entre les minuscules et les majuscules en ce qui
18. http://www.eclipse.org/
19. http://pydev.sourceforge.net/
20. http://www.barebones.com/products/textwrangler/
 2. Introduction 21

concerne les noms de fichiers contrairement à Microsoft Windows 21 . L’environnement de développement

XCode est aussi une solution.

2.4.5 Autres éditeurs

Certains éditeurs de texte sont eux-mêmes écrits en Python, ce qui leur permet de fonctionner sur toutes
les plates-formes. Trois sont assez connues, DrPython 22 , Boa Constructor 23 , The Eric Python IDE 24 . Ce
dernier s’appuie sur une interface graphique de type pyQt 25 , son interface est riche, presque trop lorsqu’on
commence à programmer. Boa Constructor s’appuie sur wxPython et offre des outils permettant de dessiner
des interfaces graphiques. DrPython est le plus simple des trois.
Certains éditeurs connus du monde Linux ont été déclinés pour le monde Windows, c’est le cas de Emacs 26 .
SciTe est souvent utilisé car c’est le plus simple. Les autres offrent des fonctionnalités variées dont l’utilité
n’apparaît que pour des programmes conséquents. Le site officiel 27 répertorie d’autres éditeurs de texte
dont certains sont de véritables environnements de développements. Il n’est pas aberrant d’en utiliser plus
d’un car chacun d’eux est plus approprié dans telle situation ou pour tel type de programme.

2.4.6 Tabulations
De nombreux éditeurs utilisent les tabulations pour mettre en forme un programme et tenir compte des
décalages (indentation) d’un bloc par rapport à un autre. Il est conseillé de remplacer ces tabulations par
des espaces, cela évite les confusions et les mauvaises interprétations lorsque tabulations et espaces sont
mélangés. La taille d’une tabulation peut varier d’un éditeur à l’autre contrairement aux espaces.

2.5 Premier programme

Après avoir installé le langage Python ainsi qu’un éditeur, il suffit d’écrire quelques lignes pour vérifier
que cette première étape s’est achevée correctement. Tous les programmes Python porte l’extension .py.

2.5.1 Afficher le résultat d’un calcul

Le programme suivant, qu’on peut appeler premier.py, affiche le message premier message une fois qu’il
est exécuté. Le mot-clé print précédant le message - toujours entre guillemets ou entre apostrophes sauf
si ce sont des nombres - stipule qu’il faut afficher quelque chose.

print "premier message"

Un programme ne barbouille pas l’écran de texte indésirable, il n’affiche que ce que le programmeur lui
demande d’afficher et cette intention se matérialise grâce à l’instruction print. On peut ensuite écrire
quelques lignes qu’on pourrait également taper sur une calculatrice :

print 3.141592 * 5*5

print 3.141592 * 5**2

21. L’usage de la commande dos2unix peut se révéler utile.

22. http://drpython.sourceforge.net/
23. http://boa-constructor.sourceforge.net/
24. http://www.die-offenbachs.de/eric/index.html
25. Voir le paragraphe 2.6.5 sur les interfaces graphiques.
26. http://www.gnu.org/software/emacs/windows/
27. plus précisément à l’adresse http://wiki.python.org/moin/PythonEditors ou encore à l’adresse http://wiki.python.org/
moin/IntegratedDevelopmentEnvironments
 2. Introduction 22

Ces deux lignes affichent 78.5398 qui est la surface d’un cercle de 5 mètres de côté. Le symbole ∗∗ correspond
à l’opération puissance. Il existe une constante PI ou π mais qui ne fait pas partie du langage lui-même : elle
est définie dans une extension interne 28 du langage qui contient bon nombre de fonctions mathématiques
telles que les cosinus, sinus...

from math import * # permet d’utiliser les extensions mathématiques de Python

print pi * 5**2

Remarque 2.8 : print Python 3.0

A partir de la version 3.0 du langage Python, la syntaxe de print change et il faudra dorénavant utiliser
des parenthèses. Il est suggéré d’utiliser cette syntaxe qui est valide quelque soit la version du lanage.

print (3.141592 * 5*5)

2.5.2 Les accents

Le langage Python est conçu pour le monde anglophone et l’utilisation des accents ne va pas de soi. Le
programme suivant qui demande d’afficher un message contenant un accent provoque l’apparition d’une
erreur :
print "accentué"

L’erreur est la suivante :

File "essai.py", line 1
SyntaxError: Non-ASCII character ’\xe9’ in file i.py on line 1,
but no encoding declared;
see http://www.python.org/peps/pep-0263.html for details

Dans ce cas, il faut ajouter une ligne placée en première position qui précise que des accents pourront être
utilisés. L’exécution du programme qui suit ne soulève aucune erreur.
# coding: latin-1
print "accentué"

Cette ligne précise en fait que l’interpréteur Python doit utiliser un jeu de caractères spécial. Ces jeux de
caractères ont parfois leur importance, les navigateurs n’aiment pas trop les accents au sein des adresses
Internet : il est parfois préférable de ne pas utiliser d’accents sur les sites de réservations d’hôtels, de trains
ou d’avions.
Par défaut, l’interpréteur Python utilise le jeu de caractères le plus réduit, il faut lui préciser qu’il doit
en utiliser un plus étendu incluant les accents. On trouve également sous Microsoft Windows la syntaxe
équivalente suivante :
# coding: cp1252
print "accentué"

Enfin, s’il fallait utiliser des caractères autres que latins, il faudrait alors choisir le jeu de caractères utf − 8
qui s’appliquent aussi aux langues orientales.
# coding: utf-8
print "accentué"

A cause des accents, la plupart des exemples cités dans ce livre ne fonctionnent pas sans cette première
ligne qui a parfois été enlevée lors de l’impression pour des questions de lisibilité. Il faut penser à l’ajouter
pour reproduire les exemples. Le paragraphe 8.8 page 168 est plus complet à ce sujet.
Remarque 2.9 : #!/usr/local/bin/python
Sur Internet, on trouve de nombreux exemples commençant par la ligne suivante :
28. Cette extension est installée automatiquement avec Python contrairement à une extension externe.
 2. Introduction 23

#!/usr/local/bin/python

On rencontre souvent cette ligne pour un programme écrit sur une machine Linux, elle indique l’emplace-
ment de l’interpréteur Python à utiliser. Cette ligne s’appelle un shebang.

2.6 Installation d’extensions (ou modules externes)

Les extensions ou modules ou packages sont des bibliothèques de fonctions non standard. Ce sont souvent
des programmes existant conçus dans un autre langage tel que C++ et qui ont été "coiffés" d’une in-
terface permettant de les utiliser sous Python. Les paragraphes qui suivent décrivent quelques extensions
couramment utilisées. Certains besoins reviennent fréquemment comme dessiner un graphe, charger une
image, faire du calcul matriciel et Python seul ne permet pas de répondre à ce problème.
La première information à connaître avant d’installer un package est la version du langage Python installée
sur votre ordinateur. Il faut impérativement utiliser la version du module élaborée pour la même version 29 .
Il est nécessaire de connaître également le système d’exploitation de votre ordinateur.
Par conséquent, il ne faut pas installer le module scipy (calcul scientifique) élaboré pour Python 2.5 alors
que sur votre ordinateur est installée la version 2.4, il y a de fortes chances que cela ne fonctionne pas.
Certains modules dépendent d’autres, lors de leur installation, il faut vérifier que les modules dont ils
dépendent ont été préalablement installés.
Le site officiel 30 recense une longue liste de modules existants (plusieurs centaines). Il recense également
les dernières mises à jour. Avant de commencer à programmer, il est conseillé d’aller chercher sur ce site
ou d’utiliser un moteur de recherche pour savoir si un module ne ferait pas déjà une partie du travail.
Il est parfois intéressant de consulter des forums d’échanges entre programmeurs autour de Python. Il est
parfois plus intéressant de jeter un œil sur de tels sites 31 avant de se lancer dans la recherche d’un module
spécifique. Internet fournit également de nombreux exemples de programmes dont on peut s’inspirer.
Les modules cités dans ce paragraphe ne sont pas installés automatiquement avec le langage Python mais
sont parfois très utiles dans le cadre d’un travail d’ingénieur. Ils existent depuis plusieurs années et sont
pour la plupart régulièrement maintenus à jour. Ils sont tous facilement accessibles depuis un moteur de
recherche.

2.6.1 Graphes
matplotlib 32 : ce module reprend la même logique que le logiciel MatLab ou Octave. Pour ceux
que la finance intéresse, il comporte également des fonctions qui permettent de récupérer des historiques
quotidiens de cours d’actions depuis le site Yahoo ! Finance 33 .
biggles 34 : ce module permet de dessiner des courbes (2D, 3D) et de convertir des graphiques sous
forme d’images de tout format. Ce module nécessite l’installation de fichiers supplémentaires (libpng, zlib,
plotutils) 35 .
chartdirector 36 : beaucoup plus rapide que MatPlotLib, ce module est gratuit à condition d’accepter un
bandeau jaune en bas de chaque graphique.
29. L’instruction help() saisie sur la ligne de commande Python retourne entre autres le numéro de version.
30. http://pypi.python.org/pypi
31. On peut citer http://wikipython.flibuste.net/ ou http://www.afpy.org/, deux sites français qui regroupent des informations
intéressantes sur de nouveaux modules ou des exemples d’utilisation de modules courants.
32. http://matplotlib.sourceforge.net/
33. Avec la fonction fetch_historical_yahoo.
34. http://biggles.sourceforge.net/
35. Accessibles depuis l’adresse http://www.gnu.org/software/plotutils/, ces informations sont disponibles depuis la page de
téléchargement de biggles.
36. http://www.advsofteng.com/
 2. Introduction 24

pydot 37 : ce module propose le dessin de graphes dans une image (arbre généalogique, réseau de distribu-
tion, ...). Le module pydot permet de dessiner tout type de graphe. Ce module nécessite un autre module
pyparsing 38 et une application Graphviz 39 . Avec cet outil, on peut réaliser des graphes comme celui de
la figure 2.9. Ce module est utilisé lors de l’exercice 11.5.1 page 227.

Figure 2.9 : Image d’un graphe, extraite du site

http ://www.graphviz.org/ où est disponible l’outil
Graphviz. Il permet de représenter des graphes sur
une page en minimisant les croisements d’arcs ce qui
est un problème complexe.

pyx 40 : ce module est aussi une librairie qui permet de tracer des graphes avec la possibilité de convertir
directement ceux-ci en fichiers PDF ou EPS.
Sans utiliser nécessairement une extension, il existe des outils comme GNUPlot 41 venu du monde Linux
qui s’exécutent facilement en ligne de commande. Cet outil propose son propre langage de programmation
dédié à la création de graphiques. Une fois ce langage maîtrisé, il est facile de construire un programme
qui permet de l’exécuter en ligne de commande pour récupérer l’image du graphique.
Remarque 2.10 : sortie texte et graphique
Un des moyens simples de construire un rapport mélangeant résultats numériques et graphiques est de
construire un fichier au format HTML 42 puis de l’afficher grâce à un navigateur Internet. Il est même
possible de construire un fichier au format PDF en utilisant l’outil Latex 43 .

2.6.2 Calculs scientifiques

numpy 44 : ce module manipule efficacement les tableaux de grandes dimensions, intègre le calcul matriciel,
la transformée de Fourier.
scipy 45 : ce module propose de nombreux algorithmes, algorithmes de classification, intégration, opti-
misation, génération de nombres aléatoires, traitement du signal, interpolation, algorithmes génétiques,
algèbre linéaire, transformée de Fourier, dessin de courbes 2D, 3D. Son installation requiert d’abord celle
du module numpy.
orange 46 : c’est un module qui permet de faire ce qu’on appelle du datamining ou fouille de données.
Il propose de nombreux algorithmes de classifications, d’analyse des données qui ont trait au machine
learning.
Rpy 47 : le langage R 48 est un langage dédié aux calculs statistiques. Il est optimisé pour la manipulation
de grandes matrices et des calculs statistiques et matriciels rapides. Il dispose également de nombreux
37. http://code.google.com/p/pydot/
38. http://pyparsing.wikispaces.com/
39. http://www.graphviz.org/
40. http://pyx.sourceforge.net/
41. http://www.gnuplot.info/
42. Il est facile de trouver des pages Internet décrivant cette syntaxe via un moteur de recherche. L’exercice 7, page 232
en dira plus à ce sujet.
43. voir l’exercice 7, page 233
44. http://numpy.scipy.org/
45. http://www.scipy.org/
46. http://www.ailab.si/orange/
47. http://rpy.sourceforge.net/
48. http://www.r-project.org/
 2. Introduction 25

graphiques. Il faut au préalable installer Python et R puis le module Rpy fera la liaison entre les deux.
On pourrait également citer le module mdp 49 qui offre quelques fonctionnalités relatives à l’analyse des
données tels que l’analyse en composante principale (ACP) ou encore le module cvxopt 50 qui propose
des algorithmes d’optimisation quadratique sous contraintes.

2.6.3 Images
PythonImageLibrary(PIL) 51 : ce module permet d’utiliser les images, quelque soit leur format. Elle propose
également quelques traitements d’images simples, rotation, zoom, histogrammes.

2.6.4 Base de données

SQLObject 52 : ce module offre la possibilité de se connecter à la plupart des serveurs de bases de données
et d’y accéder via une syntaxe objet plutôt qu’au travers de requêtes SQL.
SQLAlchemy 53 : ce module propose les mêmes fonctionnalités que le précédent. C’est le plus riche des
deux. Il est souvent utilisé en association avec le module elixir 54 .

2.6.5 Interfaces graphiques

Le langage Python propose un module interne permettant de réaliser des interfaces graphiques : Tkinter.
Il suffit pour des applications simples qui ne nécessitent que quelques fenêtres. Pour des applications
plus ambitieuses qui doivent afficher des données sous forme de matrices par exemple ou pour obtenir un
aspect plus professionnel, il est impératif d’utiliser un module externe. Il est néanmoins conseillé de savoir
utiliser Tkinter et de comprendre la programmation événementielle avant de se lancer dans l’apprentissage
de wxPython, pyQt ou pyGTK. Ces trois modules proposent des fonctionnalités équivalentes, le choix porte
surtout sur des besoins précis qu’un module couvre et sur des questions d’esthétisme.
wxPython 55 : il propose des interfaces graphiques plus complètes que le module standard Tkinter comme une
fenêtre tableur. Utilisé par de nombreuses applications, il est régulièrement mis à jour. Il est entièrement
gratuit et peut servir à des applications commerciales. Il s’inspire des MFC ou Microsoft Fundation Class
issues de Microsoft mais a l’avantage d’être portable. Aujourd’hui, c’est avant tout un projet open source
en constante évolution.
pyQt 56 : il est moins répandu que wxPython sans doute car il est produit par une société et n’est pas open
source. Il est réputé pour être mieux structuré. Il existe des restrictions pour la conception d’applications
commerciales.
pyGTK 57 : il est plus proche de Tkinter que les deux autres modules. Venu du monde Linux, l’aspect de
l’interface lui est plus ressemblant qu’à celui du monde Windows.
Lorsqu’on souhaite réaliser un jeu, il est nécessaire d’avoir une interface graphique plus conciliante avec la
gestion des images, des dessins, des sons voire des vidéos. C’est le cas du module qui suit.
pygame 58 : ce module est prévu pour concevoir des jeux en Python. Il permet entre autres d’écouter les
morceaux enregistrés sur un CD, d’afficher un film et également d’afficher des images, de récupérer les
touches pressées au clavier, les mouvements de la souris, ceux de la manette de jeux. Il suffit d’une heure
49. http://mdp-toolkit.sourceforge.net/
50. http://abel.ee.ucla.edu/cvxopt/
51. http://www.pythonware.com/products/pil/
52. http://www.sqlobject.org/
53. http://www.sqlalchemy.org/
54. http://elixir.ematia.de/trac/
55. http://www.wxpython.org/
56. http://www.riverbankcomputing.co.uk/software/pyqt/intro
57. http://www.pygtk.org/
58. http://www.pygame.org/
 2. Introduction 26

ou deux pour écrire ses premiers programmes avec pygame. Il n’est pas prévu pour réaliser des jeux en 3D
mais suffit pour bon nombre de jeux de plateau, jeux de réflexion.
Pour la réalisation d’images et d’animations 3D, on peut utiliser le module pyOpenGL 59 qui s’interface avec
pygame, wxPython ou pyQt. C’est un module dont la maîtrise ne se compte plus en heures mais en dizaine
d’heures tout comme le module directpython 60 qui est l’équivalent de pyOpenGL mais uniquement sous
Microsoft Windows.

2.6.6 Microsoft Windows, Microsoft Excel, PDF

win32com 61 : ce module permet de communiquer avec les applications Microsoft Windows tels que Microsoft
Excel. Il est ainsi possible de créer une feuille Excel depuis un programme Python, de l’imprimer, de la
sauvegarder sans avoir à ouvrir Excel. Un moteur de recherche permettra de trouver de nombreux petits
exemples utilisant ce module 62 .
reportlab 63 : ce module permet de manipuler les fichiers PDF, autant pour lire les informations qu’il
contient que pour les modifier.

2.6.7 Accélération de Python

Python est un langage interprété et pour cette raison, il est lent ce qui ne veut pas dire qu’il n’existe pas
des solutions pour contourner ce problème.
psyco : ce module permet de multiplier la vitesse d’exécution d’un programme par trois ou quatre. Il suffit
d’ajouter au programme les instructions suivantes :

import psyco
psyco.full ()

Dans les faits, le programme s’exécute plus vite mais pas uniformément plus vite : les calculs sont le plus
favorisés. Toutefois, même avec ce module, le langage Python reste très lent par rapport à un langage
compilé comme le C++. L’outil Pyrex 64 propose une solution en permettant l’insertion de code C++ au
sein d’un programme Python. Pyrex n’est pas un module, c’est un interpréteur Python modifié pour
prendre en compte ces insertions C++. Il est essentiel de connaître la syntaxe du langage C++. Pyrex
propose des temps d’exécution tout à fait acceptable par rapport à ceux du C++ et il accroît fortement
la vitesse d’écriture des programmes. Son installation n’est pas toujours évidente car il faut le relier au
compilateur C++ GCC 65 . Une approche semblable est développée par l’extension Weave 66 du module
scipy 67 . Pyrex et Weave offre des performances bien supérieures à Python seul, proches de celle du
langage C. Weave conviendra sans doute mieux à ceux qui ont déjà programmé en C.
L’accélération de l’exécution d’un programme Python suscite l’intérêt de nombreux informaticiens, c’est
aussi l’objectif de l’outil PyPy 68 qui réécrit automatiquement certaines partie du code en langage C et
l’intègre au programme existant.
59. http://pyopengl.sourceforge.net/
60. http://sourceforge.net/projects/directpython/
61. http://python.net/crew/mhammond/win32/Downloads.html
62. comme http://wikipython.flibuste.net/CodeWindows#ExempleavecExcel
63. http://www.reportlab.com/software/opensource/rl-toolkit/
64. http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/
65. http://gcc.gnu.org/, ce compilateur présent sur toute machine Linux est porté également sur Microsoft Windows (voir
le site http://www.mingw.org/).
66. http://www.scipy.org/Weave
67. http://www.scipy.org/
68. http://codespeak.net/pypy/dist/pypy/doc/home.html
 2. Introduction 27

2.7 Outils connexes

Ce paragraphe sort du cadre de ce livre. Néanmoins, on ne conçoit pas un programme d’envergure sans
outil autre que Python. Lorsqu’on travaille à plusieurs, il faut pouvoir conserver les différentes versions
d’un programme, être capable de fusionner des modifications effectuées par deux personnes, échanger de
l’information. Ce sont ces tâches auxquelles les applications qui suivent tentent d’apporter des réponses.
La liste des outils présentés dans ce livre est loin d’être exhaustive. Il existe de nombreuses applications
open source qui améliorent l’usage qu’on peut avoir des ordinateurs. De nombreux internautes échangent
autour de problèmes rencontrées, comparent différents logiciels. On fait parfoirs quelques trouvailles en y
jetant un coup d’œil régulièrement.

2.7.1 Outils quotidiens

SVN 69 : c’est un logiciel de suivi de source, il permet de conserver différentes versions d’une arborescence
de fichiers, de fusionner des modifications faites par plusieurs personnes. C’est très pratique pour travailler à
plusieurs. Une interface graphique est également disponible : TortoiseSVN 70 . Pour travailler à plusieurs
en réseau, il faudra également installer un serveur tel que Apache 71 .
MoinMoin 72 : les wikis sont devenus des outils presque incontournables qui permettent de conserver
tout type d’information. Wikipedia est le wiki le plus célèbre. Ces outils sont très utiles pour partager
l’information au sein d’une entreprise, pour archiver les rapports de réunions par exemple. Ils intègrent
souvent un moteur de recherche.

2.7.2 Outils occasionnels

BeyondCompare 73 : ce logiciel permet de comparer des fichiers textes entre eux pour voir les différences,
il compare également les arborescences de fichiers. Il n’est pas gratuit. L’outil SVN permet déjà de voir
les différences entre deux versions d’un même fichier mais celui-ci est plus complet en ce qui concernent
les fonctionnalités de comparaison.
doxygen 74 : associé au module doxypy 75 , cet outil offre une alternative plus riche que epydoc, il peut
utiliser également Graphviz 76 pour produire des graphes.
Sphinx 77 : c’est l’outil qui génère l’aide associée au langage Python telle qu’elle apparaît à l’adresse
http://docs.python.org/. Il crée des pages HTML et des documents au format PDF pour tout projet
Python.
HTML Help Workshop 78 : cet outil permet de convertir une documentation au format HTML en un
format CHM propre à Microsoft Windows. L’outil doxygen propose une option qui facilite cette conversion
via ce logiciel.
InnoSetup 79 : cette application permet de construire un installateur qui s’exécute automatiquement.
Lorsque vous souhaitez transmettre votre travail sous Python à quelqu’un d’autre, celui-ci doit récupérer
le langage, un éditeur, les fichiers Python, d’éventuelles données. L’installation permettra de regrouper l’en-
semble de ces opérations sans que l’utilisateur final n’ait à se soucier de quoi que ce soit. Cette application
ne fonctionne que sous Microsoft Windows.
69. http://subversion.tigris.org/
70. http://tortoisesvn.tigris.org/
71. http://httpd.apache.org/
72. http://moinmo.in/
73. http://www.scootersoftware.com/
74. http://www.stack.nl/~dimitri/doxygen/
75. http://code.foosel.org/doxypy
76. http://www.graphviz.org/
77. http://sphinx.pocoo.org/
78. http://www.microsoft.com/downloads/ puis saisir HTML Help Workshop dans la barre de recherche
79. http://www.innosetup.com/
 2. Introduction 28

2.7.3 Outils pour des besoins spécifiques

Le langage Python s’interface avec de nombreuses applications, les outils qui suivent peuvent aider des
programmeurs confirmés à automatiser certaines tâches fastidieuses.
BuildBot 80 : cet utilitaire est écrit en Python, lorsqu’il est couplé avec SVN, il facilite la conception
d’applications informatiques à plusieurs. A chaque mise à jour du code source, BuildBot recompile les
sources, passe les tests de non-régression 81 , avertit le ou les programmeurs concernés par des erreurs
éventuellement introduites lors d’une mise à jour. Il permet de suivre en temps réel la stabilité d’une
application. Le projet PyBots 82 regroupe plusieurs outils d’automatisation intéressants.
MySQL 83 : c’est un serveur de base de données. Les bases de données sont devenus incontournables, elles
permettent de stocker et de consulter un grand nombre d’informations de façon beaucoup plus efficace
que des fichiers quels qu’ils soient. Le langage Python permet facilement de dialoguer directement avec les
logiciels de bases de données les plus connus dont MySQL. Le module MySQLdb 84 permet de s’y connecter
depuis Python.
SQLite 85 : cette application traite également les bases de données mais sans le côté serveur. Les bases
de données sont stockées sous forme de fichiers. Cet outil est intégré à la version 2.5 du langage Python.
L’application SQLiteSpy 86 permet sous Microsoft Windows de visualiser le contenu de ces fichiers et de
lancer des requêtes SQL.
Remote Python Call (RPyC) 87 : ce module facilite l’écriture de programmes Python qui doivent
s’exécuter sur plusieurs machines avec tous les problèmes que cela comporte : synchronisation, partage
d’informations, ...
Mercurial 88 : c’est un autre logiciel de suivi de source écrit en Python, son mode de fonctionnement
- décentralisé - est différent de celui de SVN. Avec Mercurial, il n’y a plus une référence des fichiers sources
d’un programme, Mercurial est capable d’assembler des versions d’où qu’elles viennent.
Bazaar 89 : encore un logiciel de suivi de source créé plus récemment qui paraît plus convivial.

2.7.4 Outils Internet

django 90 : cet outil facilite la conception de sites Internet qui ne sont pas réduits à de simples pages
HTML mais incluent des parties écrites en Python. Il propose des exemples de pages, des accès à des bases
de données. Il est souvent utilisé en combinaison avec l’outil suivant.
CherryPy 91 : il permet de réaliser des applications Internet. Il est suffisamment robuste pour être utilisé
par de nombreux sites Internet. Il peut paraître fastidieux de s’y plonger mais ce genre d’outil offre un
réel gain de temps lors de la conception de sites qui incluent de nombreux échanges avec les utilisateurs.
TurboGears 92 : cet outil en regroupe plusieurs dont CherryPy, c’est un environement complet pour créer
des sites Internet.
80. http://buildbot.net/trac
81. Les tests de non-régression ont pour objectif de limiter le nombre d’erreurs dans un programme. Pour une fonction
retournant le résultat d’un calcul scientifique, un test de non-régression consiste à vérifier que ce calcul, pour des données
bien précises, aboutit toujours au même résultat malgré les modifications apportées au programme. La détection d’une erreur
débouche souvent sur un test de non-régression afin de s’assurer qu’elle ne se reproduira pas.
82. http://www.pybots.org/
83. http://www.mysql.fr/
84. http://sourceforge.net/projects/mysql-python
85. http://www.sqlite.org/
86. http://www.yunqa.de/delphi/doku.php/products/sqlitespy/index
87. http://rpyc.wikispaces.com/
88. http://www.selenic.com/mercurial/wiki/
89. http://bazaar.canonical.com/
90. http://www.django-fr.org/
91. http://www.cherrypy.org/
92. http://turbogears.org/
 2. Introduction 29

Zope 93 : c’est encore un outil pour concevoir des sites Internet, il est plus vieux et beaucoup plus riche. Il
est également plus complexe à appréhender. Il est plutôt destiné au développement de sites conséquents.

93. http://www.zope.org/
Chapitre 3
Types et variables du langage Python

3.1 Variables
Il est impossible d’écrire un programme sans utiliser de variable. Ce terme désigne le fait d’attribuer un
nom ou identificateur à des informations : en les nommant, on peut manipuler ces informations beaucoup
plus facilement. L’autre avantage est de pouvoir écrire des programmes valables pour des valeurs qui
varient : on peut changer la valeur des variables, le programme s’exécutera toujours de la même manière
et fera les mêmes types de calculs quelles que soient les valeurs manipulées. Les variables jouent un rôle
semblable aux inconnues dans une équation mathématique.
L’ordinateur ne sait pas faire l’addition de plus de deux nombres mais cela suffit à calculer la somme de
n premiers nombres entiers. Pour cela, il est nécessaire de créer une variable intermédiaire qu’on appellera
par exemple somme de manière à conserver le résultat des sommes intermédiaires.
somme = 0 # initialisation : la somme est nulle
for i in range(1,n) : # pour tous les indices de 1 à n exclu
somme = somme + i # on ajoute le i ème élément à somme

Définition 3.1 : variable

Une variable est caractérisée par :
un identificateur : il peut contenir des lettres, des chiffres, des blancs soulignés mais il ne peut
commencer par un chiffre. Minuscules et majuscules sont différenciées. Il est aussi unique.
un type : c’est une information sur le contenu de la variable qui indique à l’interpréteur Python la
manière de manipuler cette information.

Comme le typage est dynamique en Python, le type n’est pas précisé explicitement, il est implicitement
liée à l’information manipulée. Par exemple, en écrivant, x = 3.4, on ne précise pas le type de la variable
x mais il est implicite car x reçoit une valeur réelle : x est de type réel ou float en Python. Pour leur
première initialisation, une variable reçoit dans la plupart des cas une constante :

Définition 3.2 : constante

Les constantes sont le contraire des variables, ce sont toutes les valeurs numériques, chaînes de
caractères, ..., tout ce qui n’est pas désigné par un nom. Les constantes possèdent un type mais pas
d’identificateur.

Le langage Python possède un certain nombre de types de variables déjà définis ou types fondamentaux à
partir desquels il sera possible de définir ses propres types (voir chapitre 5). Au contraire de langages tels
que le C, il n’est pas besoin de déclarer une variable pour signifier qu’elle existe, il suffit de lui affecter
une valeur. Le type de la variable sera défini par le type de la constante qui lui est affectée. Le type d’une
variable peut changer, il correspond toujours au type de la dernière affectation.
x = 3.5 # création d’une variable nombre réel appelée x initialisée à 3.5
# 3.5 est un réel, la variable est de type "float"
sc = "chaîne" # création d’une variable chaîne de caractères appelée str
# initialisée à "chaîne", sc est de type "str"
 3. Types et variables du langage Python 31

Remarque 3.3 : commentaires

Pour tous les exemples qui suivront, le symbole # apparaîtra à maintes reprises. Il marque le début d’un
commentaire que la fin de la ligne termine. Autrement dit, un commentaire est une information aidant à
la compréhension du programme mais n’en faisant pas partie comme dans l’exemple qui suit.
x = 3 # affectation de la valeur entière 3 à la variable x
y = 3.0 # affectation de la valeur réelle 3.0 à la variable y

Remarque 3.4 : instruction sur plusieurs lignes

Le Python impose une instruction par ligne. Il n’est pas possible d’utiliser deux lignes pour écrire une
affectation à moins de conclure chaque ligne qui n’est pas la dernière par le symbole \. L’exemple suivant
est impossible.
x = Il devrait être rédigé x = \
5.5 comme suit : 5.5

Avec ce symbole, les longues instructions peuvent être écrites sur plusieurs lignes de manière plus lisibles,
de sorte qu’elles apparaissent en entier à l’écran. Si le dernier caractère est une virgule, il est implicite.
Les paragraphes suivant énumèrent les types incontournables en Python. Ils sont classés le plus souvent en
deux catégories : types immuables ou modifiables. Tous les types du langage Python sont également des
objets, c’est pourquoi on retrouve dans ce chapitre certaines formes d’écriture similaires à celles présentées
plus tard dans le chapitre concernant les classes (chapitre 5).

3.2 Types immuables (ou immutable)

Définition 3.5 : type immuable (ou immutable)

Une variable de type immuable ne peut être modifiée. Une opération sur une variable de ce type
entraîne nécessairement la création d’une autre variable du même type, même si cette dernière est
temporaire.

Autrement dit, la simple instruction x+=3 qui consiste à ajouter à la variable x la valeur 3 crée une seconde
variable dont la valeur est celle de x augmentée de 3 puis à en recopier le contenu dans celui de la variable
x. Les nombres sont des types immuables tout comme les chaînes de caractères et les tuple qui sont des
tableaux d’objets. Il n’est pas possible de modifier une variable de ce type, il faut en recréer une autre du
même type qui intègrera la modification.

3.2.1 Type "rien"

Python propose un type None pour signifier qu’une variable ne contient rien. La variable est de type None
et est égale à None.
s = None
print s # affiche None

Certaines fonctions 1 utilisent cette convention lorsqu’il leur est impossible de retourner un résultat. Ce
n’est pas la seule option pour gérer cette impossibilité : il est possible de générer une exception 2 , de
retourner une valeur par défaut ou encore de retourner None. Il n’y a pas de choix meilleur, il suffit juste
de préciser la convention choisie.
1. Les fonctions sont définies au paragraphe 4.4, plus simplement, ce sont des mini-programmes : elles permettent de
découper un programme long en tâches plus petites. On les distingue des variables car leur nom est suivi d’une liste de
constantes ou variables comprises entre parenthèses et séparées par une virgule.
2. voir chapitre 6
 3. Types et variables du langage Python 32

3.2.2 Nombres réels et entiers

Il existe deux types de nombres en Python, les nombres réels (float) et les nombres entiers (int). L’ins-
truction x=3 crée une variable de type int initialisée à 3 tandis que y=3.0 crée une variable de type float
initialisée à 3.0. Le programme suivant permet de vérifier cela en affichant pour les variables x et y, leurs
valeurs et leurs types respectifs grâce à la fonction type.

x = 3
y = 3.0
print "x =", x, type(x) x = 3 <type ’int’>
print "y =", y, type(y) y = 3.0 <type ’float’>

La liste des opérateurs qui s’appliquent aux nombres réels et entiers suit ce paragraphe. Les trois premiers
résultats s’expliquent en utilisant la représentation en base deux. 8 « 1 s’écrit en base deux 100 « 1 =
1000, ce qui vaut 16 en base décimale : les bits sont décalés vers la droite ce qui équivaut à multiplier par
deux. De même, 7&2 s’écrit 1011&10 = 10, qui vaut 2 en base décimale. Les opérateurs <<, >>, |, & sont
des opérateurs bit à bit, ils se comprennent à partir de la représentation binaire des nombres entiers.

opérateur signification exemple

<< >> décalage à gauche, à droite x = 8 « 1 (résultat = 16)
| opérateur logique ou bit à bit x = 8|1 (résultat = 9)
& opérateur logique et bit à bit x = 11&2 (résultat = 2)
+ - addition, soustraction x=y+z
+= -= addition ou soustraction puis affectation x += 3
* / multiplication, division x=y∗z
division entière, le résultat est de type réel si l’un des nombres
// x = y//3
est réel
% reste d’une division entière (modulo) x = y%3
*= /= multiplication ou division puis affectation x *= 3
** puissance (entière ou non, racine carrée = ** 0.5) x = y ∗ ∗3

Les fonctions int et float permettent de convertir un nombre quelconque ou une chaîne de caractères
respectivement en un entier (arrondi) et en un nombre réel.
x = int (3.5)
y = float (3)
z = int ("3")
print "x:", type(x), " y:", type(y), " z:", type(z)
# affiche x: <type ’int’> y: <type ’float’> z: <type ’int’>

Remarque 3.6 : conversion en nombre entier

Il peut arriver que la conversion en un nombre entier ne soit pas directe. Dans l’exemple qui suit, on
cherche à convertir une chaîne de caractères (voir paragraphe 3.2.4) en entier mais cette chaîne représente
un réel. Il faut d’abord la convertir en réel puis en entier, c’est à ce moment que l’arrondi sera effectué.
i = int ("3.5") # provoque une erreur
i = int (float ("3.5")) # fonctionne

Les opérateurs listés par le tableau ci-dessus ont des priorités différentes, triés par ordre croissant 3 . Tou-
tefois, il est conseillé d’avoir recours aux parenthèses pour enlever les doutes : 3 ∗ 2 ∗ ∗4 = 3 ∗ (2 ∗ ∗4).
Remarque 3.7 : division entière
Il existe un cas pour lequel cet opérateur cache un sens implicite : lorsque la division opère sur deux
nombres entiers ainsi que le montre l’exemple suivant.
3. La page http://docs.python.org/reference/expressions.html#operator-summary est plus complète à ce sujet.
 3. Types et variables du langage Python 33

x = 11
y = 2
z = x / y # le résultat est 5 et non 5.5 car la division est entière

Pour obtenir le résultat juste incluant la partie décimale, il faut convertir les entiers en réels.
x = float (11)
y = float (2)
z = x / y # le résultat est 5.5 car c’est une division entre deux réels

Pour éviter d’écrire le type float, on peut également écrire 11.0/2 de façon à spécifier explicitement que la
valeur 11.0 est réelle et non entière. L’opérateur // permet d’effectuer une division entière lorsque les deux
nombres à diviser sont réels, le résultat est un entier mais la variable est de type réel si l’un des nombres
est de type réel.

3.2.3 Booléen
Les booléens sont le résultat d’opérations logiques et ont deux valeurs possibles : True ou False. Voici la
liste des opérateurs qui s’appliquent aux booléens.

opérateur signification exemple

and or et, ou logique x = True or False (résultat = True)
not négation logique x = not x

x = 4 < 5
print x # affiche True
print not x # affiche False

Voici la liste des opérateurs de comparaisons qui retournent des booléens. Ceux-ci s’applique à tout type,
aux entiers, réels, chaînes de caractères, t-uples... Une comparaison entre un entier et une chaîne de
caractères est syntaxiquement correcte même si le résultat a peu d’intérêt.

opérateur signification exemple

< > inférieur, supérieur x=5<5
<= >= inférieur ou égal, supérieur ou égal x = 5 <= 5
== != égal, différent x = 5 == 5

A l’instar des nombres réels, il est préférable d’utiliser les parenthèses pour éviter les problèmes de priorités
d’opérateurs dans des expressions comme : 3 < x and x < 7. Toutefois, pour cet exemple, Python accepte
l’écriture résumée qui enchaîne des comparaisons : 3 < x and x < 7 est équivalent à 3 < x < 7. Il existe deux
autres mots-clés qui retournent un résultat de type booléen :

opérateur signification
is test d’identification
in test d’appartenance

Ces deux opérateurs seront utilisés ultérieurement, in avec les listes, les dictionnaires, les boucles (para-
graphe 4.3.2), is lors de l’étude des listes (paragraphe 3.3.2) et des classes (chapitre 5). Bien souvent, les
booléens sont utilisés de manière implicite lors de tests (paragraphe 4.2.1) ce qui n’empêche pas de les
déclarer explicitement.
x = True
y = False
 3. Types et variables du langage Python 34

3.2.4 Chaîne de caractères

3.2.4.1 Création d’une chaîne de caractères

Définition 3.8 : chaîne de caractères

Le terme "chaîne de caractères" ou string en anglais signifie une suite finie de caractères, autrement
dit, du texte.

Ce texte est compris entre deux guillemets ou deux apostrophes, ces deux symboles sont interchangeables.
L’exemple suivant montre comment créer une chaîne de caractères. Il ne faut pas confondre la partie entre
guillemets ou apostrophes, qui est une constante, de la variable qui la contient.
t = "string = texte"
print type (t), t
t = ’string = texte, initialisation avec apostrophes’
print type (t), t

t = "morceau 1" \
"morceau 2" # second morceau ajouté au premier par l’ajout du symbole \,
# il ne doit rien y avoir après le symbole \,
# pas d’espace ni de commentaire
print t

t = """première ligne
seconde ligne""" # chaîne de caractères qui s’étend sur deux lignes
print t

Le résultat de ce petit programme est le suivant :

<type ’str’> string = texte
<type ’str’> string = texte, initialisation avec apostrophes
morceau 1morceau 2
première ligne
seconde ligne

La troisième chaîne de caractères créée lors de ce programme s’étend sur deux lignes. Il est parfois plus com-
mode d’écrire du texte sur deux lignes plutôt que de le laisser caché par les limites de fenêtres d’affichage.
Python offre la possibilité de couper le texte en deux chaînes de caractères recollées à l’aide du symbole \
à condition que ce symbole soit le dernier de la ligne sur laquelle il apparaît. De même, lorsque le texte
contient plusieurs lignes, il suffit de les encadrer entre deux symboles """ ou ”’ pour que l’interpréteur
Python considère l’ensemble comme une chaîne de caractères et non comme une série d’instructions.
Par défaut, le Python ne permet pas l’insertion de caractères tels que les accents dans les chaînes de
caractères, le paragraphe 2.5.2 (page 22) explique comment résoudre ce problème. De même, pour insérer
un guillemet dans une chaîne de caractères encadrée elle-même par des guillemets, il faut le faire précéder
du symbole \. La séquence \” est appelée un extra-caractère (voir table 3.1).

\” guillemet
\0 apostrophe
\n passage à la ligne
\\ insertion du symbole \
\% pourcentage, ce symbole est aussi un caractère spécial
\t tabulation
\r
retour à la ligne, peu usité, il a surtout son importance lorsqu’on passe d’un système Windows à
Linux car Windows l’ajoute automatiquement à tous ses fichiers textes

Table 3.1 : Liste des extra-caractères les plus couramment utilisés à l’intérieur d’une chaîne de caractères (voir
page http:// docs.python.org/ reference/ lexical_analysis.html#strings).
 3. Types et variables du langage Python 35

Remarque 3.9 : préfixe "r", chaîne de caractères

Il peut être fastidieux d’avoir à doubler tous les symboles \ d’un nom de fichier. Il est plus simple dans ce
cas de préfixer la chaîne de caractères par r de façon à éviter que l’utilisation du symbole \ ne désigne un
caractère spécial. Les deux lignes suivantes sont équivalentes :
s = "C:\\Users\\Dupre\\exemple.txt"
s = r"C:\Users\Dupre\exemple.txt"

Sans la lettre "r", tous les \ doivent être doublés, dans le cas contraire, Python peut avoir des effets
indésirables selon le caractère qui suit ce symbole.

3.2.4.2 Manipulation d’une chaîne de caractères

Une chaîne de caractères est semblable à un tableau et certains opérateurs qui s’appliquent aux tableaux
s’appliquent également aux chaînes de caractères. Ceux-ci sont regroupés dans la table 3.2. La fonction
str permet de convertir un nombre, un tableau, un objet (voir chapitre 5) en chaîne de caractères afin de
pouvoir l’afficher. La fonction len retourne la longueur de la chaîne de caractères.
x = 5.567
s = str (x)
print type(s), s # <type ’str’> 5.567
print len(s) # affiche 5

opérateur signification exemple

+ concaténation de chaînes de caractères t = ”abc” + ”def”
+= concaténation puis affectation t += "abc"
in, not in une chaîne en contient-elle une autre ? "ed" in "med"
∗ répétition d’une chaîne de caractères t = ”abc” ∗ 4
obtention du nième caractère, le premier caractère a pour t = ”abc”
[n]
indice 0 print t[0] # donne a
obtention des caractères compris entre les indices i et j − 1 t = ”abc”
[i : j]
inclus, le premier caractère a pour indice 0 print t[0 : 2] # donne ab
Table 3.2 : Opérations applicables aux chaînes de caractères.

Il existe d’autres fonctions qui permettent de manipuler les chaînes de caractères.

syntaxe 3.10 : fonctions et chaînes de caractères

res = s.fonction (...)

Où s est une chaîne de caractères, fonction est le nom de l’opération que l’on veut appliquer à s,
res est le résultat de cette manipulation.

La table 3.3 (page 36) présente une liste non exhaustive des fonctions disponibles dont un exemple d’uti-
lisation suit. Cette syntaxe variable.fonction(arguments) est celle des classes 4 .
4. voir chapitre 5
 3. Types et variables du langage Python 36

Retourne le nombre d’occurrences de la chaîne de caractères sub, les paramètres par

count(
défaut st et end permettent de réduire la recherche entre les caractères d’indice st et
sub[, st
end exclu. Par défaut, st est nul tandis que end correspond à la fin de la chaîne de
[, end]])
caractères.
find( Recherche une chaîne de caractères sub, les paramètres par défaut st et end ont la
sub[, st même signification que ceux de la fonction count. Cette fonction retourne -1 si la
[, end]]) recherche n’a pas abouti.
isalpha() Retourne True si tous les caractères sont des lettres, False sinon.
isdigit() Retourne True si tous les caractères sont des chiffres, False sinon.
Retourne une copie de la chaîne de caractères en remplaçant toutes les occurrences de
replace(
la chaîne old par new. Si le paramètre optionnel co est renseigné, alors seules les co
old, new[, co])
premières occurrences seront remplacées.
split( Découpe la chaîne de caractères en se servant de la chaîne sep comme délimiteur. Si
[sep[, mspl]]) le paramètre mspl est renseigné, au plus mspl coupures seront effectuées.
Supprime les espaces au début et en fin de chaîne. Si le paramètre s est renseigné, la
strip([s]) fonction strip supprime tous les caractères qui font partie de s au début et en fin de
chaîne.
upper() Remplace les minuscules par des majuscules.
lower() Remplace les majuscules par des minuscules.
Fait la somme d’un tableau de chaînes de caractères (une liste ou un T-uple). La chaîne
join(words) de caractères sert de séparateur qui doit être ajouté entre chaque élément du tableau
words. Un exemple de cette fonction figure en page 36.
Table 3.3 : Quelques fonctions s’appliquant aux chaînes de caractères, l’aide associée au langage Python fournira
la liste complète (voir page http:// docs.python.org/ library/ stdtypes.html ). Certains des paramètres sont encadrés
par des crochets, ceci signifie qu’ils sont facultatifs.

st = "langage python"
st = st.upper () # mise en lettres majuscules
i = st.find ("PYTHON") # on cherche "PYTHON" dans st
print i # affiche 8
print st.count ("PYTHON") # affiche 1
print st.count ("PYTHON", 9) # affiche 0

L’exemple suivant permet de retourner une chaîne de caractères contenant plusieurs éléments séparés par
”; ”. La chaîne ”un; deux; trois” doit devenir ”trois; deux; un”. On utilise pour cela les fonctionnalités split
et join (voir table 3.3). L’exemple utilise également la fonctionnalité reverse des listes qui seront décrites
plus loin dans ce chapitre. Il faut simplement retenir qu’une liste est un tableau. reverse retourne le
tableau.
s = "un;deux;trois"
mots = s.split (";") # mots est égal à [’un’, ’deux’, ’trois’]
mots.reverse () # retourne la liste, mots devient égal à
# [’trois’, ’deux’, ’un’]
s2 = ";".join (mots) # concaténation des éléments de mots séparés par ";"
print s2 # affiche trois;deux;un

3.2.4.3 Formatage d’une chaîne de caractères

Python offre une manière plus concise de former une chaîne de caractères à l’aide de plusieurs types
d’informations en évitant la conversion explicite de ces informations (fonction str) et leur concaténation.
Il est particulièrement intéressant pour les nombres réels qu’il est possible d’écrire en imposant un nombre
 3. Types et variables du langage Python 37

de décimales fixe. Le format est le suivant :

syntaxe 3.11 : chaîne de caractères, formatage

".... %c1 .... %c2 " % (v1,v2)

c1 est un code choisi parmi ceux de la table 3.4 (page 37). Il indique le format dans lequel la variable
v1 devra être transcrite. Il en est de même pour le code c2 associé à la variable v2. Les codes insérés
dans la chaîne de caractères seront remplacés par les variables citées entre parenthèses après le
symbole % suivant la fin de la chaîne de caractères. Il doit y avoir autant de codes que de variables,
qui peuvent aussi être des constantes.

Voici concrètement l’utilisation de cette syntaxe :

x = 5.5
d = 7
s = "caractères"
res = "un nombre réel %f et un entier %d, une chaîne de %s, \n" \
"un réel d’abord converti en chaîne de caractères %s" % (x,d,s, str(x+4))
print res
res = "un nombre réel " + str (x) + " et un entier " + str (d) + \
", une chaîne de " + s + \
",\n un réel d’abord converti en chaîne de caractères " + str(x+4)
print res

La seconde affectation de la variable res propose une solution équivalente à la première en utilisant
l’opérateur de concaténation +. Les deux solutions sont équivalentes, tout dépend des préférences de celui
qui écrit le programme.
un nombre réel 5.500000 et un entier 7, une chaîne de caractères,
un réel d’abord converti en chaîne de caractères 9.5
un nombre réel 5.5 et un entier 7, une chaîne de caractères,
un réel d’abord converti en chaîne de caractères 9.5

La première option permet néanmoins un formatage plus précis des nombres réels en imposant par exemple
un nombre défini de décimal. Le format est le suivant :

syntaxe 3.12 : chaîne de caractères, formatage des nombres

"%n.df" % x

où n est le nombre de chiffres total et d est le nombre de décimales, f désigne un format réel indiqué
par la présence du symbole %

x = 0.123456789
print x # affiche 0.123456789
print "%1.2f" % x # affiche 0.12
print "%06.2f" % x # affiche 000.12

Il existe d’autres formats regroupés dans la table 3.4. L’aide reste encore le meilleur réflexe car le langage
Python est susceptible d’évoluer et d’ajouter de nouveaux formats.

d entier relatif
e nombre réel au format exponentiel
f nombre réel au format décimal
g nombre réel, format décimal ou exponentiel si la puissance est trop grande ou trop petite
s chaîne de caractères
Table 3.4 : Liste non exhaustive des codes utilisés pour formater des informations dans une chaîne de caractères
(voir page http:// docs.python.org/ library/ stdtypes.html ).
 3. Types et variables du langage Python 38

3.2.5 T-uple

Définition 3.13 : T-uple

Les T-uple sont un tableau d’objets qui peuvent être de tout type. Ils ne sont pas modifiables.

Un T-uple apparaît comme une liste d’objets comprise entre parenthèses et séparés par des virgules. Leur
création reprend le même format :
x = (4,5) # création d’un T-uple composé de 2 entiers
x = ("un",1,"deux",2) # création d’un T-uple composé de 2 chaînes de caractères
# et de 2 entiers, l’ordre d’écriture est important
x = (3,) # création d’un T-uple d’un élément, sans la virgule,
# le résultat est un entier

Ces objets sont des vecteurs d’objets. Il est possible d’effectuer les opérations regroupées dans la table 3.5.
Etant donné que les chaînes de caractères sont également des tableaux, ces opérations reprennent en partie
celles de la table 3.2.
x in s vrai si x est un des éléments de s
x not in s réciproque de la ligne précédente
s+t concaténation de s et t
s∗n concatène n copies de s les unes à la suite des autres
s[i] retourne le ième élément de s
s[i : j] retourne un T-uple contenant une copie des éléments de s d’indices i à j exclu.
retourne un T-uple contenant une copie des éléments de s dont les indices sont compris
s[i : j : k]
entre i et j exclu, ces indices sont espacés de k : i, i + k, i + 2k, i + 3k, ...
len(s) nombre d’éléments de s
plus petit élément de s, résultat difficile à prévoir lorsque les types des éléments sont diffé-
min(s)
rents
max(s) plus grand élément de s
sum(s) retourne la somme de tous les éléments
Table 3.5 : Opérations disponibles sur les T-uples, on suppose que s et t sont des T-uples, x est quant à lui
quelconque.

Remarque 3.14 : T-uple, opérateur []

Les T-uples ne sont pas modifiables, cela signifie qu’il est impossible de modifier un de leurs éléments. Par
conséquent, la ligne d’affectation suivante n’est pas correcte :

a = (4,5)
a [0] = 3 # déclenche une erreur d’exécution

Le message d’erreur suivant apparaît :

Traceback (most recent call last):
File "<pyshell#78>", line 1, in -toplevel-
a[0]=3
TypeError: object doesn’t support item assignment

Pour changer cet élément, il est possible de s’y prendre de la manière suivante :
a = (4,5)
a = (3,) + a[1:2] # crée un T-uple d’un élément concaténé
# avec la partie inchangée de a
 3. Types et variables du langage Python 39

3.2.6 Autres types

Il existe d’autres types comme le type complex permettant de représenter les nombres complexes. Ce
type numérique suit les mêmes règles et fonctionne avec les mêmes opérateurs (excepté les opérateurs de
comparaisons) que ceux présentés au paragraphe 3.2.2 et décrivant les nombres.
print complex (1,1) # affiche (1+1j)

Le langage Python offre la possibilité de créer ses propres types immuables 5 mais ils seront définis à partir
des types immuables présentés jusqu’ici.

3.3 Types modifiables (ou mutable)

Les types modifiables sont des conteneurs (ou containers en anglais) : ils contiennent d’autres objets, que
ce soit des nombres, des chaînes de caractères ou des objets de type modifiable. Plutôt que d’avoir dix
variables pour désigner dix objets, on en n’utilise qu’une seule qui désigne ces dix objets.

Définition 3.15 : type modifiable (ou mutable)

Une variable de type modifiable peut être modifiée, elle conserve le même type et le même identifi-
cateur. C’est uniquement son contenu qui évolue.

3.3.1 Liste
3.3.1.1 Définition et fonctions

Définition 3.16 : liste

Les listes sont des collections d’objets qui peuvent être de tout type. Elles sont modifiables.

Une liste apparaît comme une succession d’objets compris entre crochets et séparés par des virgules. Leur
création reprend le même format :

x = [4,5] # création d’une liste composée de deux entiers

x = ["un",1,"deux",2] # création d’une liste composée de
# deux chaînes de caractères
# et de deux entiers, l’ordre d’écriture est important
x = [3,] # création d’une liste d’un élément, sans la virgule,
# le résultat reste une liste
x = [ ] # crée une liste vide
x = list () # crée une liste vide
y = x [0] # accède au premier élément
y = x [-1] # accède au dernier élément

Ces objets sont des listes chaînées d’autres objets de type quelconque (immuable ou modifiable). Il est
possible d’effectuer les opérations regroupées dans la table 3.6. Ces opérations reprennent celles des T-uples
(voir table 3.5) et incluent d’autres fonctionnalités puisque les listes sont modifiables (voir table 3.6). Il
est donc possible d’insérer, de supprimer des éléments, de les trier. La syntaxe des opérations sur les listes
est similaire à celle des opérations qui s’appliquent sur les chaînes de caractères, elles sont présentées par
la table 3.7.

3.3.1.2 Exemples

L’exemple suivant montre une utilisation de la méthode sort.

5. voir le paragraphe 5.7
 3. Types et variables du langage Python 40

x in l vrai si x est un des éléments de l

x not in l réciproque de la ligne précédente
l+t concaténation de l et t
l∗n concatène n copies de l les unes à la suite des autres
retourne l’élément ième élément de l, à la différence des T-uples, l’instruction l[i] = ”a”
l[i] est valide, elle remplace l’élément i par ”a”. Un indice négatif correspond à la position
len(l) + i.
retourne une liste contenant les éléments de l d’indices i à j exclu. Il est possible de
l[i : j] remplacer cette sous-liste par une autre en utilisant l’affectation l[i : j] = l2 où l2 est une
autre liste (ou un T-uple) de dimension différente ou égale.
retourne une liste contenant les éléments de l dont les indices sont compris entre i et j
exclu, ces indices sont espacés de k : i, i + k, i + 2k, i + 3k, ... Ici encore, il est possible
l[i : j : k]
d’écrire l’affectation suivante : l[i : j : k] = l2 mais l2 doit être une liste (ou un T-uple) de
même dimension que l[i : j : k].
len(l) nombre d’éléments de l
plus petit élément de l, résultat difficile à prévoir lorsque les types des éléments sont
min(l)
différents
max(l) plus grand élément de l
sum(l) retourne la somme de tous les éléments
supprime les éléments d’indices entre i et j exclu. Cette instruction est équivalente à
del l[i : j]
l[i : j] = [].
list(x) convertit x en une liste quand cela est possible
Table 3.6 : Opérations disponibles sur les listes, identiques à celles des T-uples, on suppose que l et t sont des
listes, i et j sont des entiers. x est quant à lui quelconque.

x = [9,0,3,5,4,7,8] # définition d’une liste

print x # affiche cette liste
x.sort () # trie la liste par ordre croissant
print x # affiche la liste triée

Voici les deux listes affichées par cet exemple :

[9, 0, 3, 5, 4, 7, 8]
[0, 3, 4, 5, 7, 8, 9]

Pour classer les objets contenus par la liste mais selon un ordre différent, il faut définir une fonction qui
détermine un ordre entre deux éléments de la liste. C’est la fonction compare de l’exemple suivant.
def compare (x,y): # crée une fonction
if x > y : return -1 # qui retourne -1 si x<y,
elif x == y : return 0 # 0 si x == y
else : return 1 # 1 si x < y

x.sort (compare) # trie la liste x à l’aide de la fonction compare

# cela revient à la trier par ordre décroissant
print x

Le programme affiche cette fois-ci la ligne :

[9, 8, 7, 5, 4, 3, 0]

L’exemple suivant illustre un exemple dans lequel on essaye d’accéder à l’indice d’un élément qui n’existe
pas dans la liste :
x = [9,0,3,5,0]
print x.index (1) # cherche la position de l’élément 1
 3. Types et variables du langage Python 41

Retourne le nombre d’occurrences de l’élément x. Cette notation suit la syntaxe des

l.count(x)
classes développée au chapitre 5. count est une méthode de la classe list.
Retourne l’indice de la première occurrence de l’élément x dans la liste l. Si celle-ci
l.index(x)
n’existe pas, une exception est déclenchée (voir le paragraphe 6 ou l’exemple page 41).
Ajoute l’élément x à la fin de la liste l. Si x est une liste, cette fonction ajoute la liste x
l.append(x)
en tant qu’élément, au final, la liste l ne contiendra qu’un élément de plus.
Ajoute tous les éléments de la liste k à la liste l. La liste l aura autant d’éléments
l.extend(k)
supplémentaires qu’il y en a dans la liste k.
l.insert(i, x) Insère l’élément x à la position i dans la liste l.
Supprime la première occurrence de l’élément x dans la liste l. S’il n’y a aucune occur-
l.remove(x)
rence de x, cette méthode déclenche une exception.
Retourne l’élément l[i] et le supprime de la liste. Le paramètre i est facultatif, s’il n’est
l.pop([i])
pas précisé, c’est le dernier élément qui est retourné puis supprimé de la liste.
Retourne la liste, le premier et dernier élément échange leurs places, le second et l’avant
l.reverse(x)
dernier, et ainsi de suite.
Cette fonction trie la liste par ordre croissant. Le paramètre f est facultatif, il permet
de préciser la fonction de comparaison qui doit être utilisée lors du tri. Cette fonction
l.sort([f,
prend comme paramètre deux éléments x et y de la liste et retourne les valeurs -1,0,1
reverse])
selon que x < y, x == y ou x > y (voir paragraphe 4.4). Si rev est True, alors le tri est
décroissant.
Table 3.7 : Opérations permettant de modifier une liste on suppose que l est une liste, x est quant à lui quelconque.

Comme cet élément n’existe pas, on déclenche ce qu’on appelle une exception qui se traduit par l’affichage
d’un message d’erreur. Le message indique le nom de l’exception générée (ValueError) ainsi qu’un message
d’information permettant en règle générale de connaître l’événement qui en est la cause.
Traceback (most recent call last):
File "c:/temp/temp", line 2, in -toplevel-
print x.index(1)
ValueError: list.index(x): x not in list

Pour éviter cela, on choisit d’intercepter l’exception (voir paragraphe 6).

x = [9,0,3,5,0]
try: print x.index(1)
except ValueError: print "1 n’est pas présent dans la liste x"
else: print "trouvé"

Ce programme a pour résultat :

1 n’est pas présent dans la liste x

3.3.1.3 Fonctions range, xrange

Les listes sont souvent utilisées dans des boucles ou notamment par l’intermédiaire de la fonction range.
Cette fonction retourne une liste d’entiers.

syntaxe 3.17 : range

range (debut, fin [,marche])

Retourne une liste incluant tous les entiers compris entre debut et fin exclu. Si le paramètre facultatif
marche est renseigné, la liste contient tous les entiers n compris debut et fin exclu et tels que n − debut
soit un multiple de marche.

Exemple :
 3. Types et variables du langage Python 42

print range (0,10,2) # affiche [0, 2, 4, 6, 8]

La fonction xrange est d’un usage équivalent à range. Elle permet de parcourir une liste d’entiers sans la
créer vraiment. Elle est plus rapide.
print xrange (0,10,2) # affiche xrange(0,10,2)

Cette fonction est souvent utilisée lors de boucles 6 pour parcourir tous les éléments d’un T-uple, d’une
liste, d’un dictionnaire... Le programme suivant permet par exemple de calculer la somme de tous les
entiers impairs compris entre 1 et 20 exclu.
s = 0
for n in range (1,20,2) : # ce programme est équivalent à
s += n # s = sum (range(1,20,2))

Le programme suivant permet d’afficher tous les éléments d’une liste.

x = ["un", 1, "deux", 2, "trois", 3] x [0] = un

for n in range (0, len(x)) : x [1] = 1
print "x [%d] = %s" % (n, x [n]) x [2] = deux
x [3] = 2
# le résultat est présenté à droite x [4] = trois
x [5] = 3

3.3.1.4 Boucles et listes

Il est possible aussi de ne pas se servir des indices comme intermédiaires pour accéder aux éléments d’une
liste quand il s’agit d’effectuer un même traitement pour tous les éléments de la liste x.
x = ["un", 1, "deux", 2]
for el in x :
print "la liste inclut : ", el

L’instruction for el in x : se traduit littéralement par : pour tous les éléments de la liste, faire... Ce
programme a pour résultat :
la liste inclut : un
la liste inclut : 1
la liste inclut : deux
la liste inclut : 2

Il existe également des notations abrégées lorsqu’on cherche à construire une liste à partir d’une autre.
Le programme suivant construit la liste des entiers de 1 à 5 à partir du résultat retourné par la fonction
range.
y = list ()
for i in range(0,5) : y.append (i+1)
print y # affiche [1,2,3,4,5]

Le langage Python offre la possibilité de résumer cette écriture en une seule ligne. Cette syntaxe sera
reprise au paragraphe 4.3.2.2.
y = [ i+1 for i in range (0,5)]
print y # affiche [1,2,3,4,5]

Cette définition de liste peut également inclure des tests ou des boucles imbriquées.
y = [ i for i in range(0,5) if i % 2 == 0] # sélection les éléments pairs
print y # affiche [0,2,4]
z = [ i+j for i in range(0,5) \
for j in range(0,5)] # construit tous les nombres i+j possibles
print z # affiche [0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2,
# 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8]

6. voir paragraphe 4.3.2

 3. Types et variables du langage Python 43

3.3.1.5 Collage de séquences, fonction zip

On suppose qu’on dispose de n séquences d’éléments (T-uple, liste), toutes de longueur l. La fonction zip
permet de construire une liste de T-uples qui est la juxtaposition de toutes ces séquences. Le iième T-uple
de la liste résultante contiendra tous les iième éléments des séquences juxtaposées. Si les longueurs des
séquences sont différentes, la liste résultante aura même taille que la plus courte des séquences.
a = (1,0,7,0,0,0)
b = [2,2,3,5,5,5]
c = [ "un", "deux", "trois", "quatre" ]
d = zip (a,b,c)
print d # affiche [(1, 2, ’un’), (0, 2, ’deux’),
# (7, 3, ’trois’), (0, 5, ’quatre’)]

3.3.1.6 Concaténation de chaîne de caractères

Il arrive fréquemment de constuire une chaîne de caractères petits bouts par petits bouts comme le montre
le premier exemple ci-dessous. Cette construction peut s’avérer très lente lorsque le résultat est long. Dans
ce cas, il est nettement plus rapide d’ajouter chaque morceau dans une liste puis de les concaténer en une
seule fois grâce à la méthode join.

s = "" s = []
while <condition> : s += ... while <condition> : s.append ( ... )
s = "".join (s)

3.3.2 Copie
A l’inverse des objets de type immuable, une affectation ne signifie pas une copie. Afin d’éviter certaines
opérations superflues et parfois coûteuses en temps de traitement, on doit distinguer la variable de son
contenu. Une variable désigne une liste avec un mot (ou identificateur), une affection permet de créer un
second mot pour désigner la même liste. Il est alors équivalent de faire des opérations avec le premier mot
ou le second comme le montre l’exemple suivant avec les listes l et l2.
l = [4,5,6]
l2 = l
print l # affiche [4,5,6]
print l2 # affiche [4,5,6]
l2 [1] = "modif"
print l # affiche [4, ’modif’, 6]
print l2 # affiche [4, ’modif’, 6]

Dans cet exemple, il n’est pas utile de créer une seconde variable, dans le suivant, cela permet quelques
raccourcis.
l = [[0,1], [2,3]]
l1 = l [0]
l1 [0] = "modif" # ligne équivalente à : l [0][0] = "modif"

Par conséquent, lorsqu’on affecte une liste à une variable, celle-ci n’est pas recopiée, la liste reçoit seulement
un nom de variable. L’affectation est en fait l’association d’un nom avec un objet (voir paragraphe 5.6).
Pour copier une liste, il faut utiliser la fonction copy du module copy 7 . Ce point sera rappelé au para-
graphe 5.6.3 (page 101).
import copy
l = [4,5,6]
l2 = copy.copy(l)

7. Le module copy est une extension interne. C’est une librairie de fonctions dont la fonction copy. Cette syntaxe sera
vue au chapitre 7.
 3. Types et variables du langage Python 44

print l # affiche [4,5,6]

print l2 # affiche [4,5,6]
l2 [1] = "modif"
print l # affiche [4,5,6]
print l2 # affiche [4, ’modif’, 6]

L’opérateur == permet de savoir si deux listes sont égales même si l’une est une copie de l’autre. Le
mot-clé is permet de vérifier si deux variables font référence à la même liste ou si l’une est une copie de
l’autre comme le montre l’exemple suivant :
import copy
l = [1,2,3]
l2 = copy.copy (l)
l3 = l

print l == l2 # affiche True

print l is l2 # affiche False
print l is l3 # affiche True

Remarque 3.18 : fonction copy et deepcopy

Le comportement de la fonction copy peut surprendre dans le cas où une liste contient d’autres listes. Pour
être sûr que chaque élément d’une liste a été correctement recopiée, il faut utiliser la fonction deepcopy.
La fonction est plus longue mais elle recopie toutes les listes que ce soit une liste incluse dans une liste
elle-même incluse dans une autre liste elle-même incluse...
import copy
l = [[1,2,3],[4,5,6]]
l2 = copy.copy (l)
l3 = copy.deepcopy (l)
l [0][0] = 1111
print l # affiche [[1111, 2, 3], [4, 5, 6]]
print l2 # affiche [[1111, 2, 3], [4, 5, 6]]
print l3 # affiche [[1, 2, 3], [4, 5, 6]]
print l is l2 # affiche False
print l [0] is l2 [0] # affiche True
print l [0] is l3 [0] # affiche False

La fonction deepcopy est plus lente à exécuter car elle prend en compte les références récursives comme
celles de l’exemple suivant où deux listes se contiennent l’une l’autre.
l = [1,"a"]
ll = [l,3] # ll contient l
l [0] = ll # l contient ll
print l # affiche [[[...], 3], ’a’]
print ll # affiche [[[...], ’a’], 3]

import copy
z = copy.deepcopy (l)
print z # affiche [[[...], 3], ’a’]

3.3.3 Dictionnaire
Les dictionnaires sont des tableaux plus souples que les listes. Une liste référence les éléments en leur
donnant une position : la liste associe à chaque élément une position entière comprise entre 0 et n − 1
si n est la longueur de la liste. Un dictionnaire permet d’associer à un élément autre chose qu’une position
entière : ce peut être un entier, un réel, une chaîne de caractères, un T-uple contenant des objets immuables.
D’une manière générale, un dictionnaire associe à une valeur ce qu’on appelle une clé de type immuable.
Cette clé permettra de retrouver la valeur associée.
L’avantage principal des dictionnaires est la recherche optimisée des clés. Par exemple, on recense les
noms des employés d’une entreprise dans une liste. On souhaite ensuite savoir si une personne ayant un
nom précisé à l’avance appartient à cette liste. Il faudra alors parcourir la liste jusqu’à trouver ce nom ou
 3. Types et variables du langage Python 45

parcourir toute la liste si jamais celui-ci ne s’y trouve pas 8 . Dans le cas d’un dictionnaire, cette recherche
du nom sera beaucoup plus rapide à écrire et à exécuter.

3.3.3.1 Définition et fonctions

Définition 3.19 : dictionnaire

Les dictionnaires sont des listes de couples. Chaque couple contient une clé et une valeur. Chaque
valeur est indicée par sa clé. La valeur peut-être de tout type, la clé doit être de type immuable, ce
ne peut donc être ni une liste, ni un dictionnaire. Chaque clé comme chaque valeur peut avoir un
type différent des autres clés ou valeurs.

Un dictionnaire apparaît comme une succession de couples d’objets comprise entre accolades et séparés
par des virgules. La clé et sa valeur sont séparées par le symbole :. Leur création reprend le même format :

x = { "cle1":"valeur1", "cle2":"valeur2" }
y = { } # crée un dictionnaire vide
z = dict () # crée aussi un dictionnaire vide

Les indices ne sont plus entiers mais des chaînes de caractères pour cet exemple. Pour associer la valeur à
la clé "cle1", il suffit d’écrire :
print x ["cle1"]

La plupart des fonctions disponibles pour les listes sont interdites pour les dictionnaires comme la conca-
ténation ou l’opération de multiplication (∗). Il n’existe plus non plus d’indices entiers pour repérer les
éléments, le seul repère est leur clé. La table 3.8 dresse la liste des opérations simples sur les dictionnaires
tandis que la table 3.9 dresse la liste des méthodes plus complexes.

x in d vrai si x est une des clés de d

x not in d réciproque de la ligne précédente
d[i] retourne l’élément associé à la clé i
len(d) nombre d’éléments de d
min(d) plus petite clé
max(d) plus grande clé
del d[i] supprime l’élément associé à la clé i
list(d) retourne une liste contenant toutes les clés du dictionnaire d.
dict(x) convertit x en un dictionnaire si cela est possible, d est alors égal à dict(d.items())
Table 3.8 : Opérations disponibles sur les dictionnaires, d est un dictionnaire, x est quant à lui quelconque.

Contrairement à une liste, un dictionnaire ne peut être trié car sa structure interne est optimisée pour
effectuer des recherches rapides parmi les éléments. On peut aussi se demander quel est l’intérêt de la
méthode popitem qui retourne un élément puis le supprime alors qu’il existe le mot-clé del. Cette méthode
est simplement plus rapide car elle choisit à chaque fois l’élément le moins coûteux à supprimer, surtout
lorsque le dictionnaire est volumineux.
Les itérateurs sont des objets qui permettent de parcourir rapidement un dictionnaire, ils seront décrits en
détail au chapitre 5 sur les classes. Un exemple de leur utilisation est présenté dans le paragraphe suivant.

3.3.3.2 Exemples

Il n’est pas possible de trier un dictionnaire. L’exemple suivant permet néanmoins d’afficher tous les
éléments d’un dictionnaire selon un ordre croissant des clés. Ces exemples font appel aux paragraphes sur
8. voir également le paragraphe 4.7.1, page 76
 3. Types et variables du langage Python 46

d.copy() Retourne une copie de d.

d.has_key(x) Retourne True si x est une clé de d.
d.items() Retourne une liste contenant tous les couples (clé, valeur) inclus dans le dictionnaire.
d.keys() Retourne une liste contenant toutes les clés du dictionnaire d.
d.values() Retourne une liste contenant toutes les valeurs du dictionnaire d.
d.iteritems() Retourne un itérateur sur les couples (clé, valeur).
d.iterkeys() Retourne un itérateur sur les clés.
d.itervalues() Retourne un itérateur sur les valeurs.
Retourne d[k], si la clé k est manquante, alors la valeur None est retournée à moins
d.get(k[, x]) que le paramètre optionnel x soit renseigné, auquel cas, ce sera ce paramètre qui sera
retourné.
d.clear() Supprime tous les éléments du dictionnaire.
d.update(d2) Le dictionnaire d reçoit le contenu de d2.
d.setdefault(
Définit d[k] si la clé k existe, sinon, lui affecte x à d[k].
k[, x])
d.popitem() Retourne un élément et le supprime du dictionnaire.
Table 3.9 : Méthodes associées aux dictionnaires, d, d2 sont des dictionnaires, x est quant à lui quelconque.

les boucles (voir chapitre 4).

d = { "un":1, "zéro":0, "deux":2, "trois":3, "quatre":4, "cinq":5, \
"six":6, "sept":1, "huit":8, "neuf":9, "dix":10 }
key = d.keys ()
key.sort ()
for k in key:
print k,d [k]

L’exemple suivant montre un exemple d’utilisation des itérateurs. Il s’agit de construire un dictionnaire
inversé pour lequel les valeurs seront les clés et réciproquement.
d = { "un":1, "zero":0, "deux":2, "trois":3, "quatre":4, "cinq":5, \
"six":6, "sept":1, "huit":8, "neuf":9, "dix":10 }

dinv = { } # création d’un dictionnaire vide, on parcout

for key,value in d.items () : # les éléments du dictionnaire comme si
# c’était une liste de 2-uple (clé,valeur)
dinv [value] = key # on retourne le dictionnaire

print dinv # affiche {0: ’zero’, 1: ’un’, 2: ’deux’,

# 3: ’trois’, 4: ’quatre’, 5: ’cinq’, 6: ’six’,
# 8: ’huit’, 9: ’neuf’, 10: ’dix’}

Pour être plus efficace, on peut remplacer la ligne for key, value in d.items() : par : for key, value in d.iteritems() :.
De cette manière, on parcourt les éléments du dictionnaire sans créer de liste intermédiaire. Il est équi-
valent d’utiliser l’une ou l’autre au sein d’une boucle même si le programme suivant montre une différence.

d = { "un":1, "zero":0, "deux":2, "trois":3, "quatre":4, "cinq":5, \

"six":6, "sept":1, "huit":8, "neuf":9, "dix":10 }
print d.items ()
print d.iteritems ()

Il a pour résultat :
[(’trois’, 3), (’sept’, 1), (’neuf’, 9), (’six’, 6), (’zero’, 0),
(’un’, 1), (’dix’, 10), (’deux’, 2), (’huit’, 8), (’quatre’, 4),
(’cinq’, 5)]

<dictionary-itemiterator object at 0x0115DC40>

 3. Types et variables du langage Python 47

Remarque 3.20 : modification d’un dictionnaire dans une boucle

D’une manière générale, il faut éviter d’ajouter ou de supprimer un élément dans une liste ou un dic-
tionnaire qu’on est en train de parcourir au sein d’une boucle for ou while. Cela peut marcher mais cela
peut aussi aboutir à des résultats imprévisibles surtout avec l’utilisation d’itérateurs (fonction iteritems,
itervalues, iterkeys). Il est préférable de terminer le parcours de la liste ou du dictionnaire puis de faire
les modifications désirées une fois la boucle terminée. Dans le meilleur des cas, l’erreur suivante survient :
File "essai.py", line 6, in <module>
for k in d :
RuntimeError: dictionary changed size during iteration

3.3.3.3 Copie

A l’instar des listes (voir paragraphe 3.3.2), les dictionnaires sont des objets et une affectation n’est pas
équivalente à une copie comme le montre le programme suivant.
d = {4:4,5:5,6:6}
d2 = d
print d # affiche {4: 4, 5: 5, 6: 6}
print d2 # affiche {4: 4, 5: 5, 6: 6}
d2 [5] = "modif"
print d # affiche {4: 4, 5: ’modif’, 6: 6}
print d2 # affiche {4: 4, 5: ’modif’, 6: 6}

Lorsqu’on affecte une liste à une variable, celle-ci n’est pas recopiée, la liste reçoit seulement un nom de
variable. L’affectation est en fait l’association d’un nom avec un objet (voir paragraphe 5.6). Pour copier
une liste, il faut utiliser la fonction copy du module copy.
d = {4:4,5:5,6:6}
import copy
d2 = copy.copy(l)
print d # affiche {4: 4, 5: 5, 6: 6}
print d2 # affiche {4: 4, 5: 5, 6: 6}
d2 [5] = "modif"
print d # affiche {4: 4, 5: 5, 6: 6}
print d2 # affiche {4: 4, 5: ’modif’, 6: 6}

Le mot-clé is a la même signification pour les dictionnaires que pour les listes, l’exemple du para-
graphe 3.3.2 (page 43) est aussi valable pour les dictionnaires. Il en est de même pour la remarque
concernant la fonction deepcopy. Cette fonction recopie les listes et les dictionnaires.

3.3.3.4 Clés de type modifiable

Ce paragraphe concerne davantage des utilisateurs avertis qui souhaitent malgré tout utiliser des clés de
type modifiable. Dans l’exemple qui suit, la clé d’un dictionnaire est également un dictionnaire et cela
provoque une erreur. Il en serait de même si la variable k utilisée comme clé était une liste.
k = { 1:1}
Traceback (most recent call last):
d = { }
File "cledict.py", line 3, in <module>
d [k] = 0
d [k] = 0
TypeError: dict objects are unhashable

Cela ne veut pas dire qu’il faille renoncer à utiliser un dictionnaire ou une liste comme clé. La fonction id
permet d’obtenir un entier qui identifie de manière unique tout objet. Le code suivant est parfaitement
correct.
k = { 1:1}
d = { }
d [id (k)] = 0
 3. Types et variables du langage Python 48

Toutefois, ce n’est pas parce que deux dictionnaires auront des contenus identiques que leurs identifiants
retournés par la fonction id seront égaux. C’est ce qui explique l’erreur que provoque la dernière ligne du
programme suivant.
k = {1:1}
d = { }
d [id (k)] = 0
b = k
print d [id(b)] # affiche bien zéro
c = {1:1}
print d [id(c)] # provoque une erreur car même si k et c ont des contenus égaux,
# ils sont distincts, la clé id(c) n’existe pas dans d

Il existe un cas où on peut se passer de la fonction id mais il inclut la notion de classe définie au chapitre 5.
L’exemple suivant utilise directement l’instance k comme clé. En affichant le dictionnaire d, on vérifie que
la clé est liée au résultat de l’instruction id(k) même si ce n’est pas la clé.
class A : pass

k = A ()
d = { }
d [k] = 0
print d # affiche {<__main__.A object at 0x0120DB90>: 0}
print id (k), hex(id(k)) # affiche 18930576, 0x120db90
print d [id(k)] # provoque une erreur

La fonction hex convertit un entier en notation hexadécimale. Les nombres affichés changent à chaque
exécution. Pour conclure, ce dernier exemple montre comment se passer de la fonction id dans le cas d’une
clé de type dictionnaire.
class A (dict):
def __hash__(self):
return id(self)

k = A ()
k ["t"]= 4
d = { }
d [k] = 0
print d # affiche {{’t’: 4}: 0}

3.4 Extensions
3.4.1 Mot-clé print, repr, conversion en chaîne de caractères
Le mot-clé print est déjà apparu dans les exemples présentés ci-dessus, il permet d’afficher une ou plusieurs
variables préalablement définies, séparées par des virgules. Les paragraphes qui suivent donnent quelques
exemples d’utilisation. La fonction print permet d’afficher n’importe quelle variable ou objet à l’écran,
cet affichage suppose la conversion de cette variable ou objet en une chaîne de caractères. Deux fonctions
permettent d’effectuer cette étape sans toutefois afficher le résultat à l’écran.
La fonction str (voir paragraphe 3.2.4.2) permet de convertir toute variable en chaîne de caractères. Il
existe cependant une autre fonction repr, qui effectue cette conversion. Dans ce cas, le résultat peut être
interprété par la fonction eval (voir paragraphe 3.4.2) qui se charge de la conversion inverse. Pour les types
simples comme ceux présentés dans ce chapitre, ces deux fonctions retournent des résultats identiques.
Pour l’exemple, x désigne n’importe quelle variable.
x == eval (repr(x)) # est toujours vrai (True)
x == eval (str (x)) # n’est pas toujours vrai
 3. Types et variables du langage Python 49

3.4.2 Fonction eval

Comme le suggère le paragraphe précédent, la fonction eval permet d’évaluer une chaîne de caractères
ou plutôt de l’interpréter comme si c’était une instruction en Python. Le petit exemple suivant permet de
tester toutes les opérations de calcul possibles entre deux entiers.
x = 32
y = 9
op = "+ - * / % // & | and or << >>".split ()
for o in op :
s = str (x) + " " + o + " " + str (y)
print s, " = ", eval (s)

Ceci aboutit au résultat suivant :

32 + 9 = 41
32 - 9 = 23
32 * 9 = 288
32 / 9 = 3
32 % 9 = 5
32 // 9 = 3
32 & 9 = 0
32 | 9 = 41
32 and 9 = 9
32 or 9 = 32
32 << 9 = 16384
32 >> 9 = 0

Le programme va créer une chaîne de caractères pour chacune des opérations et celle-ci sera évaluée
grâce à la fonction eval comme si c’était une expression numérique. Il faut bien sûr que les variables que
l’expression mentionne existent durant son évaluation.

3.4.3 Informations fournies par Python

Bien que les fonctions ne soient définies que plus tard (paragraphe 4.4), il peut être intéressant de men-
tionner la fonction dir qui retourne la liste de toutes les variables créées et accessibles à cet instant du
programme. L’exemple suivant :
x = 3
print dir ()

Retourne le résultat suivant :

[’__builtins__’, ’__doc__’, ’__file__’, ’__name__’, ’x’]

Certaines variables - des chaînes des caractères - existent déjà avant même la première instruction. Elles
contiennent différentes informations concernant l’environnement dans lequel est exécuté le programme
Python :

Ce module contient tous les éléments présents dès le début d’un programme Python,
__builtins__ il contient entre autres les types présentés dans ce chapitre et des fonctions simples
comme range.
C’est une chaîne commentant le fichier, c’est une chaîne de caractères insérée aux
__doc__
premières lignes du fichiers et souvent entourée des symboles ””” (voir chapitre 7).
__file__ Contient le nom du fichier où est écrit ce programme.
__name__ Contient le nom du module.

La fonction dir est également pratique pour afficher toutes les fonctions d’un module. L’instruction
dir(sys) affiche la liste des fonctions du module sys (voir chapitre 7).
 3. Types et variables du langage Python 50

Remarque 3.21 : fonction dir

La fonction dir appelée sans argument donne la liste des fonctions et variables définies à cet endroit du
programme. Ce résultat peut varier selon qu’on se trouver dans une fonction, une méthode de classe ou à
l’extérieur du programme. L’instruction dir([]) donne la liste des méthodes qui s’appliquent à une liste.
De la même manière, la fonction type retourne une information concernant le type d’une variable.
x = 3
print x, type(x) # affiche 3 <type ’int’>
x = 3.5
print x, type(x) # affiche 3.5 <type ’float’>

3.4.4 Affectations multiples

Il est possible d’effectuer en Python plusieurs affectations simultanément.
x = 5 # affecte 5 à x
y = 6 # affecte 6 à y
x,y = 5,6 # affecte en une seule instruction 5 à x et 6 à y

Cette particularité reviendra lorsque les fonctions seront décrites puisqu’il est possible qu’une fonction
retourne plusieurs résultats comme la fonction divmod illustrée par le programme suivant.
x,y = divmod (17,5)
print x,y # affiche 3 2
print "17 / 5 = 5 * ", x, " + ",y # affiche 17 / 5 = 5 * 3 + 2

Le langage Python offre la possibilité d’effectuer plusieurs affectations sur la même ligne. Dans l’exemple
qui suit, le couple (5, 5) est affecté à la variable point, puis le couple x, y reçoit les deux valeurs du T-uple
point.
x,y = point = 5,5

3.4.5 Type long

Le type long permet d’écrire des entiers aussi grands que l’on veut. Le langage Python passe automati-
quement du type int à long lorsque le nombre considéré devient trop grand. Ils se comportent de la même
manière excepté que les opérations sur des types long sont plus longues en temps d’exécution 9 .

i = int(2**28) <type ’int’> 536870912

for k in range (0,4) : <type ’int’> 1073741824
i *= int(2) <type ’long’> 2147483648
print type(i),i <type ’long’> 4294967296

3.4.6 Ensemble
Le langage Python définit également ce qu’on appelle un ensemble. Il est défini par les classes set de type
modifiable et la classe frozenset de type immuable. Ils n’acceptent que des types identiques et offrent la
plupart des opérations liées aux ensembles comme l’intersection, l’union. D’un usage moins fréquent, ils
ne seront pas plus détaillés 10 .
print set ( (1,2,3) ) & set ( (2,3,5) )
# construit l’intersection qui est set([2, 3])

Ce chapitre a présenté les différents types de variables définis par le langage Python pour manipuler des
données ainsi que les opérations possibles avec ces types de données. Le chapitre suivant va présenter les
tests, les boucles et les fonctions qui permettent de réaliser la plupart des programmes informatiques.
9. La différence dépend des opérations effectuées.
10. La page http://docs.python.org/library/stdtypes.html#set décrit l’ensemble des fonctionnalités qui leur sont attachées.
Chapitre 4
Syntaxe du langage Python (boucles, tests,
fonctions)

Avec les variables, les boucles et les fonctions, on connaît suffisamment d’éléments pour écrire des pro-
grammes. Le plus difficile n’est pas forcément de les comprendre mais plutôt d’arriver à découper un
algorithme complexe en utilisant ces briques élémentaires. C’est l’objectif des chapitres centrés autour des
exercices. Toutefois, même si ce chapitre présente les composants élémentaires du langage, l’aisance qu’on
peut acquérir en programmation vient à la fois de la connaissance du langage mais aussi de la connaissance
d’algorithmes standards comme celui du tri ou d’une recherche dichotomique. C’est cette connaissance tout
autant que la maîtrise d’un langage de programmation qui constitue l’expérience en programmation.

4.1 Les trois concepts des algorithmes

Les algorithmes sont composés d’instructions, ce sont des opérations élémentaires que le processeur exécute
selon trois schémas :
enchaînement des instructions les unes à la suite des autres : passage d’une instruction à
la séquence
la suivante
passage d’une instruction à une autre qui n’est pas forcément la suivante (c’est une rupture
le saut
de séquence)
le test choix entre deux instructions
Le saut n’apparaît plus de manière explicite dans les langages évolués car il est une source fréquente
d’erreurs. Il intervient dorénavant de manière implicite au travers des boucles qui combinent un saut et
un test comme le montre l’exemple suivant :
Version avec boucles :
initialisation de la variable moy à 0
faire pour i allant de 1 à N
moy reçoit moy + ni
moy reçoit moy / N

Version équivalente avec sauts :

ligne 1 : initialisation de la variable moy à 0
ligne 2 : initialisation de la variable i à 1
ligne 3 : moy reçoit moy + ni
ligne 4 : i reçoit i + 1
ligne 5 : si i est inférieur ou égal à N alors aller à la ligne 3
ligne 6 : moy reçoit moy / N

Tout programme peut se résumer à ces trois concepts. Chaque langage les met en place avec sa propre
syntaxe et parfois quelques nuances mais il est souvent facile de les reconnaître même dans des langages
inconnus. Le calcul d’une somme décrit plus haut et écrit en Python correspond à l’exemple suivant :
moy = 0
for i in range(1,N+1): # de 1 à N+1 exclu --> de 1 à N inclus
moy += n [i]
moy /= N
 4. Syntaxe du langage Python (boucles, tests, fonctions) 52

Le premier élément de cette syntaxe est constitué de ses mots-clés (for et in) (voir également table 4.1)
et des symboles (=, +=, /=, [, ], (, ), :) (voir table 4.2) La fonction iskeyword du module keyword 1 permet
de savoir si un mot-clé donné fait partie du langage Python.
import keyword
print keyword.iskeyword("for") # affiche True
print keyword.iskeyword("until") # affiche False

and as assert break class continue def del

elif else except exec finally for from global
if import in is lambda not or pass
print raise return try while with yield
Table 4.1 : Mots-clés du langage Python, voir également la page http:// docs.python.org/ reference/ lexical_analysis.
html#identifiers.

+ − ∗ ∗∗ / // % << >> & | ˆ \

∼ < > <= >= == != <> ( ) [ ]
{ } " , : . ’ = ; += -= *=
/= //= %= &= |= ˆ= >>= <<= **= """ ”’ #
Table 4.2 : Symbole du langage Python, certains ont plusieurs usages comme : qui est utilisé à chaque test ou
boucle et qui permet aussi de déterminer une plage d’indices dans un tableau. L’opérateur <> est identique à ! =
mais est déclaré obsolète (deprecated) : il est susceptible de disparaître dans une prochaine version de Python.

Remarque 4.1 : syntaxe et espaces

Les espaces entre les mots-clés et les symboles ont peu d’importance, il peut n’y en avoir aucun comme
dix. Les espaces servent à séparer un mot-clé, un nombre d’une variable.
1. Les modules seront décrits au chapitre 7. Dans ce cas-ci, un module est une librairie de fonctionnalités. La syntaxe
keyword.iskeyword permet d’exécuter la fonctionnalité iskeyword du module keyword.
 4. Syntaxe du langage Python (boucles, tests, fonctions) 53

4.2 Tests
4.2.1 Définition et syntaxe

Définition 4.2 : test

Les tests permettent d’exécuter des instructions différentes selon la valeur d’une condition logique.

syntaxe 4.3 : test

if condition1 :
instruction1
instruction2
...
else :
instruction3
instruction4
...

La clause else est facultative. Lorsque la condition condition1 est fausse et qu’il n’y a aucune
instruction à exécuter dans ce cas, la clause else est inutile. La syntaxe du test devient :
if condition1 :
instruction1
instruction2
...

S’il est nécessaire d’enchaîner plusieurs tests d’affilée, il est possible de condenser l’écriture avec le
mot-clé elif :
if condition1 :
instruction1
instruction2
...
elif condition2 :
instruction3
instruction4
...
elif condition3 :
instruction5
instruction6
...
else :
instruction7
instruction8
...

Remarque 4.4 : indentation

Le décalage des instructions par rapport aux lignes contenant les mots-clés if, elif, else est très im-
portant : il fait partie de la syntaxe du langage et s’appelle l’indentation (voir paragraphe 4.5). Celle-ci
permet de grouper les instructions ensemble. Le programme suivant est syntaxiquement correct même si
le résultat n’est pas celui désiré.
x = 1
if x > 0 :
signe = 1
print "le nombre est positif"
else :
signe = -1
print "le nombre est négatif" # ligne mal indentée
print "signe = ", signe

Une ligne est mal indentée (print "le nombre est négatif"). Elle ne devrait être exécutée que si la
condition x > 0 n’est pas vérifiée. Le fait qu’elle soit alignée avec les premières instructions du programme
fait que son exécution n’a plus rien à voir avec cette condition. La programme répond de manière erronée :
 4. Syntaxe du langage Python (boucles, tests, fonctions) 54

le nombre est positif

le nombre est négatif
signe = 1

Dans certains cas, l’interpréteur Python ne sait pas à quel bloc attacher une instruction, c’est le cas de
l’exemple suivant, la même ligne a été décalée de deux espaces, ce qui est différent de la ligne qui précède
et de la ligne qui suit.
x = 1
if x > 0 :
signe = 1
print "le nombre est positif"
else :
signe = -1
print "le nombre est négatif" # ligne mal indentée
print "signe = ", signe

L’interpréteur retourne l’erreur suivante :

File "test.py", line 7
print "le nombre est négatif"
^
IndentationError: unindent does not match any outer indentation level

4.2.2 Comparaisons possibles

Les comparaisons possibles entre deux entités sont avant tout numériques mais ces opérateurs peuvent
être définis pour tout type (voir chapitre 5), notamment sur les chaînes de caractères pour lesquelles les
opérateurs de comparaison transcrivent l’ordre alphabétique.

<,> inférieur, supérieur

<= , >= inférieur ou égal, supérieur ou égal
== , ! = égal, différent
x is y vérifie que x et y sont égaux, not is, différents, l’opérateur is est différent de l’opé-
is , not is
rateur ==, il est expliqué au paragraphe 3.3.2 (page 43).
in, not in appartient, n’appartient pas

4.2.3 Opérateurs logiques

Il existe trois opérateurs logiques qui combinent entre eux les conditions.
not négation and et logique or ou logique

Remarque 4.5 : priorité des opérations

La priorité des opérations numériques est identique à celle rencontrée en mathématiques. L’opérateur
puissance vient en premier, la multiplication/division ensuite puis l’addition/soustraction. Ces opérations
sont prioritaires sur les opérateurs de comparaisons (>, <, ==, ...) qui sont eux-mêmes sur les opérateurs
logiques not, and, or. Il est tout de même conseillé d’ajouter des parenthèses en cas de doute.

4.2.4 Ecriture condensée

Il existe deux écritures condensées de tests. La première consiste à écrire un test et l’unique instruction
qui en dépend sur une seule ligne.
if condition : if condition : instruction1
instruction1 Ce code peut tenir en else : instruction2
else : deux lignes :
instruction2
 4. Syntaxe du langage Python (boucles, tests, fonctions) 55

Le second cas d’écriture condensée concerne les comparaisons enchaînées. Le test if 3 < x and x < 5 : instruction
peut être condensé par if 3 < x < 5 : instruction. Il est ainsi possible de juxtaposer autant de comparai-
sons que nécessaire : if 3 < x < y < 5 : instruction.
Le mot-clé in permet également de condenser certains tests lorsque la variable à tester est entière.
if x == 1 or x == 6 or x == 50 : peut être résumé simplement par if x in (1, 6, 50) :.

4.2.5 Exemple
L’exemple suivant associe à la variable signe le signe de la variable x.
x = -5 x = -5
if x < 0 : if x < 0 : signe = -1
signe = -1 Son écriture condensée elif x == 0 : signe = 0
elif x == 0 : lorsqu’il n’y a qu’une else : signe = 1
signe = 0
else : instruction à exécuter :
signe = 1

Le programme suivant saisit une ligne au clavier et dit si c’est "oui" ou "non" qui a été saisi.
s = raw_input ("dites oui : ") # voir remarque suivante
if s == "oui" or s [0:1] == "o" or s [0:1] == "O" or s == "1" :
print "oui"
else : print "non"

Remarque 4.6 : fonction raw_input

La fonction raw_input invite l’utilisateur d’un programme à saisir une réponse lors de l’exécution du
programme. Tant que la touche entrée n’a pas été pressée, l’exécution du programme ne peut continuer.
Cette fonction est en réalité peu utilisée. Les interfaces graphiques sont faciles d’accès en Python, on
préfère donc saisir une réponse via une fenêtre plutôt qu’en ligne de commande. L’exemple suivant montre
comment remplacer cette fonction à l’aide d’une fenêtre graphique, le résultat apparaît dans la figure 4.1.
On peut améliorer la fonction question en précisant une valeur par défaut par exemple, le chapitre 9 sera
plus explicite à ce sujet.

import Tkinter
def question (legende) :
reponse = [""]
root = Tkinter.Tk ()
root.title ("pseudo raw_input") 5
Tkinter.Label (text = legende).pack (side = Tkinter.LEFT)
s = Tkinter.Entry (text= "def", width=80)
s.pack (side = Tkinter.LEFT)
def rget () :
reponse [0] = s.get () 10
root.destroy ()
Tkinter.Button (text = "ok", command = rget).pack (side = Tkinter.LEFT)
root.mainloop ()
return reponse [0]
15
print "reponse ", question ("texte de la question")

Figure 4.1 : Fenêtre apparaissant lors de l’exécution du programme page 55 proposant une version graphique de la
fonction raw_input.
 4. Syntaxe du langage Python (boucles, tests, fonctions) 56

Remarque 4.7 : if None, if 0

L’écriture de certains tests peut encore être réduite lorsqu’on cherche à comparer une variable entière,
booléenne ou None comme le précise le tableau 4.2.5.
type test test équivalent
bool if v : if v == True :
Table 4.3 : Ce tableau précise le sens de certains tests lorsque leur bool if not v : if v == False :
int if v : if v != 0 :
écriture est tronquée. On suppose que v est une variable. int if not v : if v == 0 :
float if v : if v != 0.0 :
float if not v : if v == 0.0 :
None if v : if v != None :
None if not v : if v == None :

4.2.6 Passer, instruction pass

Dans certains cas, aucune instruction ne doit être exécutée même si un test est validé. En Python, le corps
d’un test ne peut être vide, il faut utiliser l’instruction pass. Lorsque celle-ci est manquante, Python affiche
un message d’erreur.
signe = 0
x = 0
if x < 0 : signe = -1
elif x == 0:
pass # signe est déjà égal à 0
else : signe = 1

Dans ce cas précis, si l’instruction pass est oubliée, l’interpréteur Python génère l’erreur suivante :
File "nopass.py", line 6
else :
^
IndentationError: expected an indented block

4.3 Boucles

Définition 4.8 : boucle

Les boucles permettent de répéter une séquence d’instructions tant qu’une certaine condition est
vérifiée.

Le langage Python propose deux types de boucles. La boucle while suit scrupuleusement la définition 4.8.
La boucle for est une boucle while déguisée (voir paragraphe 4.3.2), elle propose une écriture simplifiée
pour répéter la même séquence d’instructions pour tous les éléments d’un ensemble.
 4. Syntaxe du langage Python (boucles, tests, fonctions) 57

4.3.1 Boucle while

4.3.1.1 Syntaxe et exemples

L’implémentation d’une boucle de type while suit le schéma d’écriture suivant :

syntaxe 4.9 : boucle while

while cond :
instruction 1
...
instruction n

Où cond est une condition qui détermine la poursuite de la répétition des instructions incluses dans
la boucle. Tant que celle-ci est vraie, les instructions 1 à n sont exécutées.

Tout comme les tests, la remarque 4.4 concernant l’indentation reste vraie. Le décalage des lignes d’un
cran vers la droite par rapport à l’instruction while permet de les inclure dans la boucle comme le montre
l’exemple suivant.
n = 0 à l’intérieur 0
while n < 3: à l’intérieur 1
print "à l’intérieur ", n Résultat : à l’intérieur 2
n += 1 à l’extérieur 3
print "à l’extérieur ", n

4.3.1.2 Condition

Les conditions suivent la même syntaxe que celles définies lors des tests (voir paragraphes 4.2.2 et 4.2.3).
A moins d’inclure l’instruction break 2 qui permet de sortir prématurément d’une boucle, la condition
qui régit cette boucle doit nécessairement être modifiée à l’intérieur de celle-ci. Dans le cas contraire, on
appelle une telle boucle une boucle infinie puisqu’il est impossible d’en sortir. L’exemple suivant contient
une boucle infinie car le symbole = est manquant dans la dernière instruction. La variable n n’est jamais
modifiée et la condition n < 3 toujours vraie.
n = 0
while n < 3 :
print n
n + 1 # n n’est jamais modifié, l’instruction correcte serait n += 1

4.3.2 Boucle for

4.3.2.1 Syntaxe et exemples

L’implémentation d’une boucle de type for suit le schéma d’écriture suivant :

syntaxe 4.10 : boucle for

for x in set :
instruction 1
...
instruction n

Où x est un élément de l’ensemble set. Les instructions 1 à n sont exécutées pour chaque élément x de
l’ensemble set. Cet ensemble peut être une chaîne de caractères, un T-uple, une liste, un dictionnaire
ou tout autre type incluant des itérateurs qui sont présentés au chapitre 5 concernant les classes
(page 91).

2. L’instruction break est décrite au paragraphe 4.3.4.2, page 61.

 4. Syntaxe du langage Python (boucles, tests, fonctions) 58

Tout comme les tests, la remarque 4.4 concernant l’indentation reste vraie. L’exemple suivant affiche tous
les éléments d’un T-uple à l’aide d’une boucle for.
t = (1,2,3,4)
for x in t: # affiche les nombres 1,2,3,4
print x # chacun sur une ligne différente

Lors de l’affichage d’un dictionnaire, les éléments n’apparaissent pas triés ni dans l’ordre dans lequel ils
y ont été insérés. L’exemple suivant montre comment afficher les clés et valeurs d’un dictionnaire dans
l’ordre croissant des clés.
d = { 1:2, 3:4, 5:6, 7:-1, 8:-2 }
print d # affiche le dictionnaire {8: -2, 1: 2, 3: 4, 5: 6, 7: -1}
k = d.keys ()
print k # affiche les clés [8, 1, 3, 5, 7]
k.sort ()
print k # affiche les clés triées [1, 3, 5, 7, 8]
for x in k: # affiche les éléments du dictionnaire
print x,":",d [x] # triés par clés croissantes

Le langage Python propose néanmoins la fonction sorted qui réduit l’exemple suivant en trois lignes :
d = { 1:2, 3:4, 5:6, 7:-1, 8:-2 }
for x in sorted(d): # pour les clés dans l’ordre croissant
print x,":",d [x]

La boucle la plus répandue est celle qui parcourt des indices entiers compris entre 0 et n − 1. On utilise
pour cela la boucle for et la fonction range ou xrange comme dans l’exemple qui suit. La différence entre
ces deux fonctions a déjà été présentée au paragraphe 3.3.1.3 (page 41).
sum = 0
N = 10
for n in range(0,N): # ou for n in xrange(0,N): (plus rapide)
sum += n # additionne tous les entiers compris entre 0 et N-1

Ou encore pour une liste quelconque :

l = [ 4, 5, 3, -6, 7, 9]
sum = 0
for n in range(0,len (l)): # ou for n in xrange(0,len (l)) : (plus rapide)
sum += l [n] # additionne tous les éléments de l

4.3.2.2 Listes et boucle for

Le paragraphe 3.3.1.4 a montré comment le mot-clé for peut être utilisé pour simplifier la création d’une
liste à partir d’une autre. La syntaxe suit le schéma suivant :

syntaxe 4.11 : boucle for

[ expression for x in ensemble ]

Où expression est une expression numérique incluant ou non x, la variable de la boucle, ensemble
est un ensemble d’éléments, T-uple, liste, dictionnaire.

Cette syntaxe permet de résumer en une ligne la création de la séquence y du programme suivant.
y = list ()
for i in range(0,5) :
y.append (i+1)
print y # affiche [1,2,3,4,5]

Les trois lignes du milieu sont maintenant résumées en une seule :

y = [ i+1 for i in range(0,5)] # résume trois lignes du programme précédent
print y # affiche [1,2,3,4,5]

Un autre exemple de cette syntaxe réduite a été présenté au paragraphe 3.3.1.4 page 42. Cette écriture
condensée est bien souvent plus lisible même si tout dépend des préférences de celui qui programme.
 4. Syntaxe du langage Python (boucles, tests, fonctions) 59

4.3.2.3 Itérateurs

Toute boucle for peut s’appliquer sur un objet muni d’un itérateur tels que les chaînes de caractères,
T-uples, les listes, les dictionnaires.
d = ["un", "deux", "trois"]
for x in d:
print x # affichage de tous les éléments de d

Cette syntaxe réduite a déjà été introduite pour les listes et les dictionnaires au chapitre précédent. Il existe
une version équivalente avec la boucle while utilisant de façon explicite les itérateurs. Il peut être utile de
lire le chapitre suivant sur les classes et le chapitre 6 sur les exceptions avant de revenir sur la suite de cette
section qui n’est de toutes façons pas essentielle. L’exemple précédent est convertible en une boucle while
en faisant apparaître explicitement les itérateurs (voir paragraphe 5.4.2). Un itérateur est un objet qui
permet de parcourir aisément un ensemble. La fonction it = iter(e) permet d’obtenir un itérateur it sur
l’ensemble e. L’appel à l’instruction it.next() parcourt du premier élément jusqu’au dernier en retournant
la valeur de chacun d’entre eux. Lorsqu’il n’existe plus d’élément, l’exception StopIteration est déclenchée
(voir paragraphe 6). Il suffit de l’intercepter pour mettre fin au parcours.
d = ["un", "deux", "trois"]
it = iter (d) # obtient un itérateur sur d
while True:
try: x = it.next () # obtient l’élément suivant, s’il n’existe pas
except StopIteration: break # déclenche une exception
print x # affichage de tous les éléments de d

4.3.2.4 Plusieurs variables de boucles

Jusqu’à présent, la boucle for n’a été utilisée qu’avec une seule variable de boucle, comme dans l’exemple
suivant où on parcourt une liste de T-uple pour les afficher.
d = [ (1,0,0), (0,1,0), (0,0,1) ]
for v in d: print v

Lorsque les éléments d’un ensemble sont des T-uples, des listes ou des dictionnaires composés de taille
fixe, il est possible d’utiliser une notation qui rappelle les affectations multiples (voir paragraphe 3.4.4).
L’exemple précédent devient dans ce cas :
d = [ (1,0,0), (0,1,0), (0,0,1) ]
for x,y,z in d: print x,y,z

Cette écriture n’est valable que parce que chaque élément de la liste d est un T-uple composé de trois
nombres. Lorsqu’un des éléments est de taille différente à celle des autres, comme dans l’exemple suivant,
une erreur survient.
d = [ (1,0,0), (0,1,0,6), (0,0,1) ] # un élément de taille quatre
for x,y,z in d: print x,y,z

Ce programme génère l’erreur suivante :

Traceback (most recent call last):
File "c:\temp\delete.py", line 2, in -toplevel-
for x,y,z in d: print x,y,z
ValueError: unpack tuple of wrong size

Cette syntaxe est très pratique associée à la fonction zip (voir paragraphe 3.3.1.5). Il est alors possible de
parcourir plusieurs séquences (T-uple, liste, dictionnaire) simultanément.
a = range(0,5) 0 est le carré de 0
b = [x**2 for x in a] 1 est le carré de 1
for x,y in zip (a,b): 4 est le carré de 2
print y, " est le carré de ", x 9 est le carré de 3
# affichage à droite 16 est le carré de 4
 4. Syntaxe du langage Python (boucles, tests, fonctions) 60

4.3.3 Ecriture condensée

Comme pour les tests, lorsque les boucles ne contiennent qu’une seule instruction, il est possible de l’écrire
sur la même ligne que celle de la déclaration de la boucle for ou while.
d = ["un", "deux", "trois"]
for x in d: print x # une seule instruction

Il existe peu de cas où la boucle while s’écrit sur une ligne car elle inclut nécessairement une instruction
permettant de modifier la condition d’arrêt.
d = ["un", "deux", "trois"]
i = 0
while d [i] != "trois" : i += 1
print "trois a pour position ", i

4.3.4 Pilotage d’une boucle

4.3.4.1 Passer à l’itération suivante : continue

Pour certains éléments d’une boucle, lorsqu’il n’est pas nécessaire d’exécuter toutes les instructions, il est
possible de passer directement à l’élément suivant ou l’itération suivante. Le programme suivant utilise la
crible d’Eratosthène 3 pour dénicher tous les nombres premiers compris entre 1 et 99.
d = dict ()
for i in range(1,100): # d [i] est vrai si i est un nombre premier
d [i] = True # au début, comme on ne sait pas, on suppose
# que tous les nombres sont premiers
for i in range(2,100):
# si d [i] est faux,
if not d [i]: continue # les multiples de i ont déjà été cochés
# et peut passer à l’entier suivant
for j in range (2,100):
if i*j < 100:
d [i*j] = False # d [i*j] est faux pour tous les multiples de i
# inférieurs à 100
print "liste des nombres premiers"
for i in d:
if d [i]: print i

Ce programme est équivalent au suivant :

d = dict ()
for i in range(1,100): d [i] = True

for i in range(2,100):
if d [i]:
for j in range (2,100):
if i*j < 100 :
d [i*j] = False

print "liste des nombres premiers"

for i in d:
if d [i]: print i

Le mot-clé continue évite de trop nombreuses indentations et rend les programmes plus lisibles.
3. Le crible d’Eratosthène est un algorithme permettant de déterminer les nombres premiers. Pour un nombre premier p,
il paraît plus simple de considérer tous les entiers de p − 1 à 1 pour savoir si l’un d’eux divise p. C’est ce qu’on fait lorsqu’on
doit vérifier le caractère premier d’un seul nombre. Pour plusieurs nombres à la fois, le crible d’Eratosthène est plus efficace :
au lieu de s’intéresser aux diviseurs, on s’intéresse aux multiples d’un nombre. Pour un nombre i, on sait que 2i, 3i, ... ne
sont pas premiers. On les raye de la liste. On continue avec i + 1, 2(i + 1), 3(i + 1)...
 4. Syntaxe du langage Python (boucles, tests, fonctions) 61

4.3.4.2 Sortie prématurée : break

Lors de l’écriture d’une boucle while, il n’est pas toujours adéquat de résumer en une seule condition
toutes les raisons pour lesquelles il est nécessaire d’arrêter l’exécution de cette boucle. De même, pour une
boucle for, il n’est pas toujours utile de visiter tous les éléments de l’ensemble à parcourir. C’est le cas
par exemple lorsqu’on recherche un élément, une fois qu’il a été trouvé, il n’est pas nécessaire d’aller plus
loin. L’instruction break permet de quitter l’exécution d’une boucle.
l = [6,7,5,4,3]
n = 0
c = 5
for x in l:
if x == c: break# l’élément a été trouvé, on sort de la boucle
n += 1 # si l’élément a été trouvé, cette instruction
# n’est pas exécutée
print "l’élément ",c, " est en position ",
print n # affiche l’élément 5 est en position 2

Si deux boucles sont imbriquées, l’instruction break ne sort que de la boucle dans laquelle elle est insérée.
L’exemple suivant vérifie si un entier est la somme des carrés de deux entiers compris entre 1 et 20.
set = range (1,21)
n = 53
for x in set:
for y in set:
c = x*x + y*y
if c == n: break
if c == n: break # cette seconde instruction break est nécessaire
# pour sortir de la seconde boucle
# lorsque la solution a été trouvée
if c == n:
# le symbole \ permet de passer à la ligne sans changer d’instruction
print n, " est la somme des carrés de deux entiers :", \
x, "*", x, "+", y, "*", y, "=", n
else:
print n, " n’est pas la somme des carrés de deux entiers"

Le programme affiche :
53 est la somme des carrés de deux entiers : 2 * 2 + 7 * 7 = 53

4.3.4.3 Fin normale d’une boucle : else

Le mot-clé else existe aussi pour les boucles et s’utilise en association avec le mot-clé break. L’instruction
else est placée à la fin d’une boucle, indentée au même niveau que for ou while. Les lignes qui suivent
le mot-clé else ne sont exécutées que si aucune instruction break n’a été rencontrée dans le corps de la
boucle. On reprend l’exemple du paragraphe précédent. On recherche cette fois-ci la valeur 1 qui ne se
trouve pas dans la liste L. Les lignes suivant le test if x == c ne seront jamais exécutées au contraire de
la dernière.
L = [6,7,5,4,3]
n = 0
c = 1
for x in L :
if x == c :
print "l’élément ", c, " est en position ", n
break
n += 1
else:
print "aucun élément ", c, " trouvé" # affiche aucun élément 1 trouvé

Les lignes dépendant de la clause else seront exécutées dans tous les cas où l’exécution de la boucle n’est
pas interrompue par une instruction break ou une instruction return 4 ou par la levée d’une exception 5 .
4. voir les fonctions au paragraphe 4.4
5. voir paragraphe 6
 4. Syntaxe du langage Python (boucles, tests, fonctions) 62

4.3.4.4 Suppression ou ajout d’éléments lors d’une boucle

En parcourant la liste en se servant des indices, il est possible de supprimer une partie de cette liste. Il
faut néanmoins faire attention à ce que le code ne produise pas d’erreur comme c’est le cas pour le suivant.
La boucle for parcourt la liste range(0, len(li)) qui n’est pas modifiée en même temps que l’instruction
del li[i : i + 2].

li = range (0,10)
print li # affiche [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in range (0, len (li)):
if i == 5 :
del li [i:i+2]
print li [i] # affiche successivement 0, 1, 2, 3, 4, 7, 8, 9 et
# produit une erreur
print li

Le programme suivant marche parfaitement puisque cette fois-ci la boucle parcourt la liste li. En revanche,
pour la suppression d’une partie de celle-ci, il est nécessaire de conserver en mémoire l’indice de l’élément
visité. C’est le rôle de la variable i.
li = range (0,10)
print li # affiche [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
i = 0
for t in li :
if i == 5 : del li [i:i+2]
i = i+1
print t # affiche successivement 0, 1, 2, 3, 4, 5, 8, 9
print li # affiche [0, 1, 2, 3, 4, 7, 8, 9]

Le langage Python offre la possibilité de supprimer des éléments d’une liste alors même qu’on est en train
de la parcourir. Le programme qui suit ne marche pas puisque l’instruction del i ne supprime pas un
élément de la liste mais l’identificateur i qui prendra une nouvelle valeur lors du passage suivant dans la
boucle.
li = range (0,10)
print li # affiche [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in li :
if i == 5 : del i
print li # affiche [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

On pourrait construire des exemples similaires dans le cadre de l’ajout d’un élément à la liste. Il est en
règle générale déconseillé de modifier une liste, un dictionnaire pendant qu’on le parcourt. Malgré tout, si
cela s’avérait indispensable, il convient de faire plus attention dans ce genre de situations.

4.4 Fonctions
Les fonctions sont des petits programmes qui effectuent des tâches plus précises que le programme entier.
On peut effectivement écrire un programme sans fonction mais ils sont en général illisibles. Utiliser des
fonctions implique de découper un algorithme en tâches élémentaires. Le programme final est ainsi plus
facile à comprendre. Un autre avantage est de pouvoir plus facilement isoler une erreur s’il s’en produit
une : il suffit de tester une à une les fonctions pour déterminer laquelle retourne un mauvais résultat.
L’avantage le plus important intervient lorsqu’on doit effectuer la même chose à deux endroits différentes
d’un programme : une seule fonction suffit et elle sera appelée à ces deux endroits 6 .
6. Pour les utilisateurs experts : en langage Python, les fonctions sont également des variables, elles ont un identificateur
et une valeur qui est dans ce cas un morceau de code. Cette précision explique certaines syntaxes du chapitre 9 sur les
interfaces graphiques ou celle introduite en fin de chapitre au paragraphe 4.7.10.
 4. Syntaxe du langage Python (boucles, tests, fonctions) 63

4.4.1 Définition, syntaxe

Définition 4.12 : fonction

Une fonction est une partie d’un programme - ou sous-programme - qui fonctionne indépendamment
du reste du programme. Elle reçoit une liste de paramètres et retourne un résultat. Le corps de la
fonction désigne toute instruction du programme qui est exécutée si la fonction est appelée.

Lorsqu’on écrit ses premiers programme, on écrit souvent des fonctions plutôt longues avant de s’apercevoir
que certains parties sont identiques ailleurs. On extrait donc la partie répétée pour en faire une fonction.
Avec l’habitude, on finit par écrire des fonctions plus petites et réutilisables.

syntaxe 4.13 : fonction, définition

def fonction_nom (par_1, ..., par_n) :
instruction_1
...
instruction_n
return res_1, ..., res_n

fonction_nom est le nom de la fonction, il suit les mêmes règles que le nom des variables. par_1 à
par_n sont les noms des paramètres et res_1 à res_n sont les résultats retournés par la fonction.
Les instructions associées à une fonction doivent être indentées par rapport au mot-clé def.

S’il n’y a aucun résultat, l’instruction return est facultative ou peut être utilisée seule sans être suivie par
une valeur ou une variable. Cette instruction peut apparaître plusieurs fois dans le code de la fonction
mais une seule d’entre elles sera exécutée. A partir de ce moment, toute autre instruction de la fonction
sera ignorée. Pour exécuter une fonction ainsi définie, il suffit de suivre la syntaxe suivante :

syntaxe 4.14 : fonction, appel

x_1, ..., x_n = fonction_nom (valeur_1, valeur_2, ..., valeur_n)

Où fonction_nom est le nom de la fonction, valeur_1 à valeur_n sont les noms des paramètres,
x_1 à x_n reçoivent les résultats retournés par la fonction. Cette affectation est facultative. Si on
ne souhaite pas conserver les résultats, on peut donc appeler la fonction comme suit :
fonction_nom (valeur_1, valeur_2, ..., valeur_n)

Lorsqu’on commence à programmer, il arrive parfois qu’on confonde le rôle des mots-clés print et return.
Dans ce cas, il faut se reporter à la remarque 11.3 page 222.

4.4.2 Exemple
Le programme suivant utilise deux fonctions. La première convertit des coordonnées cartésiennes en coor-
données polaires. Elle prend deux réels en paramètres et retourne deux autres réels. La seconde fonction
affiche les résultats de la première pour tout couple de valeurs (x, y). Elle ne retourne aucun résultat.
import math
def coordonnees_polaires (x,y):
rho = math.sqrt(x*x+y*y) # calcul la racine carrée de x*x+y*y
theta = math.atan2 (y,x) # calcule l’arc tangente de y/x en tenant
# compte des signes de x et y
return rho, theta

def affichage (x,y):

r,t = coordonnees_polaires(x,y)
print "cartésien (%f,%f) --> polaire (%f,%f degrés)" \
% (x,y,r,math.degrees(t))

affichage (1,1)
affichage (0.5,1)
 4. Syntaxe du langage Python (boucles, tests, fonctions) 64

affichage (-0.5,1)
affichage (-0.5,-1)
affichage (0.5,-1)

Le programme affiche les lignes suivantes :

cartésien (1.000000,1.000000) --> polaire (1.414214,45.000000 degrés)
cartésien (0.500000,1.000000) --> polaire (1.118034,63.434949 degrés)
cartésien (-0.500000,1.000000) --> polaire (1.118034,116.565051 degrés)
cartésien (-0.500000,-1.000000) --> polaire (1.118034,-116.565051 degrés)
cartésien (0.500000,-1.000000) --> polaire (1.118034,-63.434949 degrés)

4.4.3 Paramètres avec des valeurs par défaut

Lorsqu’une fonction est souvent appelée avec les mêmes valeurs pour ses paramètres, il est possible de
spécifier pour ceux-ci une valeur par défaut.

syntaxe 4.15 : fonction, valeur par défaut

def fonction_nom (param_1, param_2 = valeur_2, ..., param_n = valeur_n):
...

Où fonction_nom est le nom de la fonction. param_1 à param_n sont les noms des paramètres,
valeur_2 à valeur_n sont les valeurs par défaut des paramètres param_2 à param_n. La seule
contrainte lors de cette définition est que si une valeur par défaut est spécifiée pour un paramètre,
alors tous ceux qui suivent devront eux aussi avoir une valeur par défaut.

Exemple :
def commander_carte_orange (nom, prenom, paiement = "carte", nombre = 1, zone = 2):
print "nom : ", nom
print "prénom : ", prenom
print "paiement : ", paiement
print "nombre : ", nombre
print "zone :", zone

commander_carte_orange ("Dupré", "Xavier", "chèque")

# les autres paramètres nombre et zone auront pour valeur
# leurs valeurs par défaut

Il est impossible qu’un paramètre sans valeur par défaut associée se situe après un paramètre dont une
valeur par défaut est précisée. Le programme suivant ne pourra être exécuté.
def commander_carte_orange (nom, prenom, paiement = "carte", nombre = 1, zone):
print "nom : ", nom
# ...

Il déclenche l’erreur suivante :

File "problem_zone.py", line 1
def commander_carte_orange (nom, prenom, paiement = "carte", nombre = 1, zone):
SyntaxError: non-default argument follows default argument

Remarque 4.16 : valeurs par défaut de type modifiable

Les valeurs par défaut de type modifiable (liste, dictionnaire, classes) peuvent introduire des erreurs inat-
tendues dans les programmes comme le montre l’exemple suivant :
def fonction (l = [0,0]) :
l [0] += 1
return l

print fonction () # affiche [1,0] : résultat attendu

print fonction () # affiche [2,0] : résultat surprenant
print fonction ( [0,0]) # affiche [1,0] : résultat attendu
 4. Syntaxe du langage Python (boucles, tests, fonctions) 65

L’explication provient du fait que la valeur par défaut est une liste qui n’est pas recréée à chaque appel :
c’est la même liste à chaque fois que la fonction est appelée sans paramètre. Pour remédier à cela, il
faudrait écrire :
import copy
def fonction (l = [0,0]) :
l = copy.copy (l)
l [0] += 1
return l

L’exercice 13.4.7 (page 356) propose un exemple plus complet, voire retors.

4.4.4 Ordre des paramètres

Le paragraphe 4.4.1 a présenté la syntaxe d’appel a une fonction. Lors de l’appel, le nom des paramètres
n’intervient plus, supposant que chaque paramètre reçoit pour valeur celle qui a la même position que lui
lors de l’appel à la fonction. Il est toutefois possible de changer cet ordre en précisant quel paramètre doit
recevoir quelle valeur.

syntaxe 4.17 : fonction, ordre des paramètres

x_1, ..., x_n = fonction_nom (param_1 = valeur_1, ..., param_n = valeur_n)

Où fonction_nom est le nom de la fonction, param_1 à param_n sont les noms des paramètres,
valeur_1 à valeur_n sont les valeurs que reçoivent ces paramètres. Avec cette syntaxe, l’ordre
d’écriture n’importe pas. La valeur valeur_i sera toujours attribuée à param_i. Les variables x_1 à
x_n reçoivent les résultats retournés par la fonction. L’ordre des résultats ne peut pas être changé.
S’il y a plusieurs résultats retournés, il est impossible de choisir lesquels conserver : soit tous, soit
aucun.
Exemple :
def identite (nom, prenom):
print "nom : ", nom, " prénom : ", prenom

identite("Xavier", "Dupré") # nom : Xavier prénom : Dupré

identite(prenom = "Xavier", nom = "Dupré") # nom : Dupré prénom : Xavier

Cette possibilité est intéressante surtout lorsqu’il y a de nombreux paramètres par défaut et que seule la
valeur d’un des derniers paramètres doit être changée.
def commander_carte_orange (paiement = "carte", nombre = 1, zone = 2):
print "paiement : ", paiement
print "nombre : ", nombre
print "zone :", zone

commander_carte_orange (zone = 5) # seule la valeur par défaut

# du paramètre zone sera changée

4.4.5 Surcharge de fonction

Contrairement à d’autres langages, Python n’autorise pas la surcharge de fonction. Autrement dit, il n’est
pas possible que plusieurs fonctions portent le même nom même si chacune d’entre elles a un nombre
différent de paramètres.
def fonction (a,b):
return a + b

def fonction (a,b,c):

return a + b + c

print fonction (5,6)

print fonction (5,6,7)
 4. Syntaxe du langage Python (boucles, tests, fonctions) 66

Le petit programme précédent est syntaxiquement correct mais son exécution génère une erreur parce que
la seconde définition de la fonction fonction efface la première.
Traceback (most recent call last):
File "cours4.py", line 7, in ?
print fonction (5,6)
TypeError: fonction() takes exactly 3 arguments (2 given)

4.4.6 Commentaires
Le langage Python propose une fonction help qui retourne pour chaque fonction un commentaire ou mode
d’emploi qui indique comment se servir de cette fonction. L’exemple suivant affiche le commentaire associé
à la fonction round.
>>> help (round)

Help on built-in function round:

round(...)
round(number[, ndigits]) -> floating point number

Round a number to a given precision in decimal digits (default 0 digits).

This always returns a floating point number. Precision may be negative.

Lorsqu’on utilise cette fonction help sur la fonction coordonnees_polaires définie dans l’exemple du
paragraphe précédent 4.4.2, le message affiché n’est pas des plus explicites.
>>> help (coordonnees_polaires)

Help on function coordonnees_polaires in module __main__:

coordonnees_polaires(x, y)

Pour changer ce message, il suffit d’ajouter en première ligne du code de la fonction une chaîne de carac-
tères.
import math
def coordonnees_polaires (x,y):
"""convertit des coordonnées cartésiennes en coordonnées polaires
(x,y) --> (pho,theta)"""
rho = math.sqrt(x*x+y*y)
theta = math.atan2 (y,x)
return rho, theta
help (coordonnees_polaires)

Le programme affiche alors le message d’aide suivant nettement plus explicite :

Help on function coordonnees_polaires in module __main__:

coordonnees_polaires(x, y)
convertit des coordonnées cartésiennes en coordonnées polaires
(x,y) --> (pho,theta)

Il est conseillé d’écrire ce commentaire pour toute nouvelle fonction avant même que son corps ne soit
écrit. L’expérience montre qu’on oublie souvent de l’écrire après.
 4. Syntaxe du langage Python (boucles, tests, fonctions) 67

4.4.7 Paramètres modifiables

Les paramètres de types immuables et modifiables se comportent de manières différentes à l’intérieur d’une
fonction. Ces paramètres sont manipulés dans le corps de la fonction, voire modifiés parfois. Selon le type
du paramètre, ces modifications ont des répercussions à l’extérieur de la fonction.
Les types immuables ne peuvent être modifiés et cela reste vrai. Lorsqu’une fonction accepte un paramètre
de type immuable, elle ne reçoit qu’une copie de sa valeur. Elle peut donc modifier ce paramètre sans que
la variable ou la valeur utilisée lors de l’appel de la fonction n’en soit affectée. On appelle ceci un passage
de paramètre par valeur. A l’opposé, toute modification d’une variable d’un type modifiable à l’intérieur
d’une fonction est répercutée à la variable qui a été utilisée lors de l’appel de cette fonction. On appelle
ce second type de passage un passage par adresse.
L’exemple suivant utilise une fonction somme_n_premier_terme qui modifie ces deux paramètres. Le pre-
mier, n, est immuable, sa modification n’a aucune incidence sur la variable nb. En revanche, le premier
élément du paramètre liste reçoit la valeur 0. Le premier élément de la liste l n’a plus la même valeur
après l’appel de la fonction somme_n_premier_terme que celle qu’il avait avant.

def somme_n_premier_terme(n,liste):
"""calcul la somme des n premiers termes d’une liste"""
somme = 0
for i in liste:
somme += i
n -= 1 # modification de n (type immuable)
if n <= 0: break
liste[0] = 0 # modification de liste (type modifiable)
return somme

l = [1,2,3,4]
nb = 3
print "avant la fonction ",nb,l # affiche avant la fonction 3 [1, 2, 3, 4]
s = somme_n_premier_terme (nb,l)
print "après la fonction ",nb,l # affiche après la fonction 3 [0, 2, 3, 4]
print "somme : ", s # affiche somme : 6

La liste l est modifiée à l’intérieur de la fonction somme_n_premier_terme comme l’affichage suivant le

montre. En fait, à l’intérieur de la fonction, la liste l est désignée par l’identificateur liste, c’est la même
liste. La variable nb est d’un type immuable. Sa valeur a été recopiée dans le paramètre n de la fonction
somme_n_premier_terme. Toute modification de n à l’intérieur de cette fonction n’a aucune répercussion
à l’extérieur de la fonction.
Remarque 4.18 : passage par adresse
Dans l’exemple précédent, il faut faire distinguer le fait que la liste passée en paramètre ne soit que modifiée
et non changée. L’exemple suivant inclut une fonction qui affecte une nouvelle valeur au paramètre liste
sans pour autant modifier la liste envoyée en paramètre.
def fonction (liste):
liste = []

liste = [0,1,2]
print liste # affiche [0,1,2]
fonction (liste)
print liste # affiche [0,1,2]

Il faut considérer dans ce programme que la fonction fonction reçoit un paramètre appelé liste mais
utilise tout de suite cet identificateur pour l’associer à un contenu différent. L’identificateur liste est en
quelque sorte passé du statut de paramètre à celui de variable locale. La fonction associe une valeur à
liste - ici, une liste vide - sans toucher à la valeur que cet identificateur désignait précédemment.
Le programme qui suit est différent du précédent mais produit les mêmes effets. Ceci s’explique par le fait
que le mot-clé del ne supprime pas le contenu d’une variable mais seulement son identificateur. Le langage
Python détecte ensuite qu’un objet n’est plus désigné par aucun identificateur pour le supprimer. Cette
remarque est à rapprocher de celles du paragraphe 5.6.
 4. Syntaxe du langage Python (boucles, tests, fonctions) 68

def fonction (liste):

del liste

liste = [0,1,2]
print liste # affiche [0,1,2]
fonction (liste)
print liste # affiche [0,1,2]

Le programme qui suit permet cette fois-ci de vider la liste liste passée en paramètre à la fonction
fonction. La seule instruction de cette fonction modifie vraiment le contenu désigné par l’identificateur
liste et cela se vérifie après l’exécution de cette fonction.

def fonction (liste):

del liste[0:len(liste)] # on peut aussi écrire : liste[:] = []

liste = [0,1,2]
print liste # affiche [0,1,2]
fonction (liste)
print liste # affiche []

4.4.8 Fonction récursive

Définition 4.19 : fonction récursive

Une fonction récursive est une fonction qui s’appelle elle-même.

La fonction récursive la plus fréquemment citée en exemple est la fonction factorielle. Celle-ci met en
évidence les deux composantes d’une fonction récursive, la récursion proprement dite et la condition
d’arrêt.
def factorielle(n):
if n == 0 : return 1
else : return n * factorielle(n-1)

La dernière ligne de la fonction factorielle est la récursion tandis que la précédente est la condition
d’arrêt, sans laquelle la fonction ne cesserait de s’appeler, empêchant le programme de terminer son
exécution. Si celle-ci est mal spécifiée ou absente, l’interpréteur Python affiche une suite ininterrompue de
messages. Python n’autorise pas plus de 1000 appels récursifs : factorielle(999) provoque nécessairement
une erreur d’exécution même si la condition d’arrêt est bien spécifiée.
Traceback (most recent call last):
File "fact.py", line 5, in <module>
factorielle(999)
File "fact.py", line 3, in factorielle
else : return n * factorielle(n-1)
File "fact.py", line 3, in factorielle
else : return n * factorielle(n-1)
...

La liste des messages d’erreurs est aussi longue qu’il y a eu d’appels à la fonction récursive. Dans ce cas,
il faut transformer cette fonction en une fonction non récursive équivalente, ce qui est toujours possible.
def factorielle_non_recursive (n) :
r = 1
for i in range (2, n+1) :
r *= i
return r
 4. Syntaxe du langage Python (boucles, tests, fonctions) 69

4.4.9 Portée
4.4.9.1 Portée des variables, des paramètres

Lorsqu’on définit une variable, elle n’est pas utilisable partout dans le programme. Par exemple, elle n’est
pas utilisable avant d’avoir été déclarée au moyen d’une affectation. Le court programme suivant déclenche
une erreur.
print x # déclenche une erreur

Traceback (most recent call last):

File "pas_declaree.py", line 1, in <module>
print x
NameError: name ’x’ is not defined

Il est également impossible d’utiliser une variable à l’extérieur d’une fonction où elle a été déclarée.
Plusieurs fonctions peuvent ainsi utiliser le même nom de variable sans qu’à aucun moment, il n’y ait
confusion. Le programme suivant déclenche une erreur identique à celle reproduite ci-dessus.
def portee_variable(x):
var = x
print var

portee_variable(3)
print var # déclenche une erreur car var est déclarée dans
# la fonction portee_variable

Définition 4.20 : portée d’une variable

La portée d’une variable associée à un identificateur recouvre la portion du programme à l’intérieur
de laquelle ce même identificateur la désigne. Ceci implique que, dans cette portion de code, aucune
autre variable, aucune autre fonction, aucune autre classe, ne peut porter le même identificateur.

Une variable n’a donc d’existence que dans la fonction dans laquelle elle est déclarée. On appelle ce type
de variable une variable locale. Par défaut, toute variable utilisée dans une fonction est une variable locale.

Définition 4.21 : variable locale

Une variable locale est une variable dont la portée est réduite à une fonction.

Par opposition aux variables locales, on définit les variables globales qui sont déclarées à l’extérieur de
toute fonction.

Définition 4.22 : variable globale

Une variable globale est une variable dont la portée est l’ensemble du programme.

L’exemple suivant mélange variable locale et variable globale. L’identificateur n est utilisé à la fois pour
désigner une variable globale égale à 1 et une variable locale égale à 1. A l’intérieur de la fonction, n désigne
la variable locale égale à 2. A l’extérieur de la fonction, n désigne la variable globale égale à 1.
n = 1 # déclaration d’une variable globale
def locale_globale():
n = 2 # déclaration d’une variable locale
print n # affiche le contenu de la variable locale

print n # affiche 1
locale_globale() # affiche 2
print n # affiche 1
 4. Syntaxe du langage Python (boucles, tests, fonctions) 70

Il est possible de faire référence aux variables globales dans une fonction par l’intermédiaire du mot-clé
global. Celui-ci indique à la fonction que l’identificateur n n’est plus une variable locale mais désigne une
variable globale déjà déclarée.
n = 1 # déclaration d’une variable globale
def locale_globale():
global n # cette ligne indique que n désigne la variable globale
n = 2 # change le contenu de la variable globale
print n # affiche le contenu de la variable globale

print n # affiche 1
locale_globale() # affiche 2
print n # affiche 2

Cette possibilité est à éviter le plus possible car on peut considérer que locale_globale est en fait une
fonction avec un paramètre caché. La fonction locale_globale n’est plus indépendante des autres fonctions
puisqu’elle modifie une des données du programme.

4.4.9.2 Portée des fonctions

Le langage Python considère les fonctions également comme des variables d’un type particulier. La portée
des fonctions obéit aux mêmes règles que celles des variables. Une fonction ne peut être appelée que si elle
a été définie avant son appel.
print type(factorielle) # affiche <type ’function’>

Comme il est possible de déclarer des variables locales, il est également possible de définir des fonctions
locales ou fonctions imbriquées. Une fonction locale n’est appelable qu’à l’intérieur de la fonction dans
laquelle elle est définie. Dans l’exemple suivant, la fonction affiche_pair inclut une fonction locale qui
n’est appelable que par cette fonction affiche_pair.
def affiche_pair():
def fonction_locale(i): # fonction locale ou imbriquée
if i % 2 == 0 : return True
else : return False
for i in range(0,10):
if fonction_locale(i):
print i

affiche_pair()
fonction_locale(5) # l’appel à cette fonction locale
# déclenche une erreur d’exécution

A l’intérieur d’une fonction locale, le mot-clé global désigne toujours les variables globales du programme
et non les variables de la fonction dans laquelle cette sous-fonction est définie.

4.4.10 Nombre de paramètres variable

Il est possible de définir des fonctions qui prennent un nombre indéterminé de paramètres, lorsque celui-ci
n’est pas connu à l’avance. Hormis les paramètres transmis selon le mode présenté dans les paragraphes
précédents, des informations peuvent être ajoutées à cette liste lors de l’appel de la fonction, ces informa-
tions sont regroupées soit dans une liste de valeurs, soit dans une liste de couples (identificateur, valeur).
 4. Syntaxe du langage Python (boucles, tests, fonctions) 71

La déclaration d’une telle fonction obéit à la syntaxe suivante :

syntaxe 4.23 : fonction, nombre variable de paramètres

def fonction (param_1, ..., param_n, *liste, **dictionnaire) :

Où fonction est un nom de fonction, param_1 à param_n sont des paramètres de la fonction, liste est
le nom de la liste qui doit recevoir la liste des valeurs seules envoyées à la fonction et qui suivent les
paramètres (plus précisément, c’est un tuple), dictionnaire reçoit la liste des couples (identificateur,
valeur).

L’appel à cette fonction suit quant à lui la syntaxe suivante :

syntaxe 4.24 : fonction, nombre variable de paramètres (appel)

fonction (valeur_1, ..., valeur_n, \
liste_valeur_1, ..., liste_valeur_p, \
nom_1 = v_1, ..., nom_q = v_q)

Où fonction est un nom de fonction, valeur_1 à valeur_n sont les valeurs associées aux para-
mètres param_1 à param_n, liste_valeur_1 à liste_valeur_p formeront la liste liste, les couples
nom_1 : v_1 à nom_q : v_q formeront le dictionnaire dictionnaire.

Exemple :
def fonction(p,*l,**d):
print "p = ",p
print "liste (tuple) l :", l
print "dictionnaire d :", d

fonction (1,2,3,a=5,b=6) # 1 est associé au paramètre p

# 2 et 3 sont insérés dans la liste l
# a=5 et b=6 sont insérés dans le dictionnaire d

Ce programme affiche :
p = 1
liste l : (2, 3)
dictionnaire d : {’a’: 5, ’b’: 6}

A l’instar des paramètres par défaut, la seule contrainte de cette écriture est la nécessité de respecter
l’ordre dans lequel les informations doivent apparaître. Lors de l’appel, les valeurs sans précision de nom
de paramètre seront placées dans une liste (ici le tuple l). Les valeurs associées à un nom de paramètre
seront placées dans un dictionnaire (ici d). Les valeurs par défaut sont obligatoirement placées après les
paramètres non nommés explicitement.
Une fonction qui accepte des paramètres en nombre variable peut à son tour appeler une autre fonction
acceptant des paramètres en nombre variable. Il faut pour cela se servir du symbole ∗ afin de transmettre
à fonction les valeurs reçues par fonction2.
def fonction(p,*l,**d):
print "p = ",p
print "liste l :", l
print "dictionnaire d :", d

def fonction2 (p, *l, **d) :

l += (4,) # on ajoute une valeur au tuple
d ["c"] = 5 # on ajoute un couple (paramètre,valeur)
fonction (p, *l, **d) # ne pas oublier le symbole *

fonction2 (1,2,3,a=5,b=6)

Le programme affiche :
 4. Syntaxe du langage Python (boucles, tests, fonctions) 72

p = 1
liste l : (2, 3, 4)
dictionnaire d : {’a’: 5, ’c’: 5, ’b’: 6}

4.4.11 Ecriture simplifiée pour des fonctions simples

Lorsque le code d’une fonction tient en une ligne et est le résultat d’une expression, il est possible de
condenser son écriture à l’aide du mot-clé lambda.

syntaxe 4.25 : fonction lambda

nom_fonction = lambda param_1, ..., param_n : expression

nom_fonction est le nom de la fonction, param_1 à param_n sont les paramètres de cette fonction
(ils peuvent également recevoir des valeurs par défaut), expression est l’expression retournée par la
fonction.

L’exemple suivant utilise cette écriture pour définir la fonction min retournant le plus petit entre deux
nombres positifs.
min = lambda x,y : (abs (x+y) - abs (x-y))/2

print min (1,2) # affiche 1

print min (5,4) # affiche 4

Cette écriture correspond à l’écriture non condensée suivante :

def min(x,y):
return (abs (x+y) - abs (x-y))/2

print min (1,2) # affiche 1

print min (5,4) # affiche 4

Remarque 4.26 : fonction lambda dans une boucle

La fonction lambda considère le contexte de fonction qui la contient comme son contexte. Il est possible
de créer des fonctions lambda mais celle-ci utiliseront le contexte dans l’état où il est au moment de son
exécution et non au moment de sa création.
fs = []
for a in range (0,10) :
f = lambda x : x + a
fs.append (f)
for f in fs :
print (f(1)) # le programme affiche 10 fois 10 de suite
# car la variable a vaut dix à la fin de la boucle

Pour que le programme affiche les entiers de 1 à 10, il faut préciser à la fonction lambda une variable y
égale à a au moment de la création de la fonction et qui sera intégrée au contexte de la fonction lambda :
fs = []
for a in range (0,10) :
f = lambda x,y=a : x + y # ligne changée
fs.append (f)
for f in fs :
print (f(1))

4.4.12 Fonctions générateur

Le mot-clé yield est un peu à part. Utilisé à l’intérieur d’une fonction, il permet d’interrompre le cours de
son exécution à un endroit précis de sorte qu’au prochain appel de cette fonction, celle-ci reprendra le cours
 4. Syntaxe du langage Python (boucles, tests, fonctions) 73

de son exécution exactement au même endroit avec des variables locales inchangées. Le mot-clé return
ne doit pas être utilisé. Ces fonctions ou générateurs sont utilisées en couple avec le mot-clé for pour
simuler un ensemble. L’exemple suivant implémente une fonction fonction_yield qui simule l’ensemble
des entiers compris entre 0 et n exclu.
def fonction_yield(n):
i = 0
while i < n-1:
print "yield 1" # affichage : pour voir ce que fait le programme
yield i # arrête la fonction qui reprendra
i = i+1 # à la ligne suivante lors du prochain appel
print "yield 2" # affichage : pour voir ce que fait le programme
yield i # arrête la fonction qui ne reprendra pas
# lors du prochain appel car le code de la fonction
# prend fin ici

for a in fonction_yield(2):
print a # affiche tous les éléments que retourne la
# fonction fonction_yield, elle simule la liste
# [0,1]
print "-----------------------------------------------"
for a in fonction_yield(3):
print a # nouvel appel, l’exécution reprend
# au début de la fonction,
# affiche tous les éléments que retourne la
# fonction fonction_yield, elle simule la liste
# [0,1,2]

Le programme affiche tous les entiers compris entre 0 et 4 inclus ainsi que le texte ”yield 1” ou ”yield 2”
selon l’instruction yield qui a retourné le résultat. Lorsque la fonction a finalement terminé son exécution,
le prochain appel agit comme si c’était la première fois qu’on l’appelait.
yield 1
0
yield 2
1
-----------------------------------------------
yield 1
0
yield 1
1
yield 2
2

4.4.13 Identificateur appelable

La fonction callable retourne un booléen permettant de savoir si un identificateur est une fonction (voir
chapitre 5), de savoir par conséquent si tel identificateur est appelable comme une fonction.
x = 5
def y () :
return None
print callable (x) # affiche False car x est une variable
print callable (y) # affiche True car y est une fonction

4.4.14 Fonctions ajoutées lors de l’exécution du programme

4.4.14.1 Fonction eval

Cette fonction a déjà été abordée lors des paragraphes 3.4.1 (paragraphe 3.4.2, page 49). Un exemple a
déjà été présenté page 49. Elle évalue toute chaîne de caractères contenant une expression écrite avec la
syntaxe du langage Python. Cette expression peut utiliser toute variable ou toute fonction accessible au
moment où est appelée la fonction eval.
 4. Syntaxe du langage Python (boucles, tests, fonctions) 74

x = 3
y = 4
print eval ("x*x+y*y+2*x*y") # affiche 49
print (x+y)**2 # affiche 49

Si l’expression envoyée à la fonction eval inclut une variable non définie, l’interpréteur Python génère une
erreur comme le montre l’exemple suivant.
x = 3
y = 4
print eval ("x*x+y*y+2*x*y+z")

La variable z n’est pas définie et l’expression n’est pas évaluable.

Traceback (most recent call last):
File "c:\temp\cours.py", line 3, in -toplevel-
print eval ("x*x+y*y+2*x*y+z")
File "<string>", line 0, in -toplevel-
NameError: name ’z’ is not defined

L’erreur se produit dans une chaîne de caractères traduite en programme informatique, c’est pourquoi
l’interpréteur ne peut pas situer l’erreur dans un fichier. L’erreur ne se produit dans aucun fichier, cette
chaîne de caractères pourrait être définie dans un autre.

4.4.14.2 Fonctions compile, exec

Plus complète que la fonction eval, la fonction compile permet d’ajouter une ou plusieurs fonctions au
programme, celle-ci étant définie par une chaîne de caractères. Le code est d’abord compilé (fonction
compile) puis incorporé au programme (fonction exec) comme le montre l’exemple suivant.

import math
str = """def coordonnees_polaires (x,y):
rho = math.sqrt(x*x+y*y)
theta = math.atan2 (y,x)
return rho, theta""" # fonction définie par une chaîne de caractères

obj = compile(str,"","exec") # fonction compilée

exec obj # fonction incorporée au programme
print coordonnees_polaires(1,1)# affiche (1.4142135623730951, 0.78539816339744828)

La fonction compile prend en fait trois arguments. Le premier est la chaîne de caractères contenant le code
à compiler. Le second paramètre ("" dans l’exemple) contient un nom de fichier dans lequel seront placées
les erreurs de compilation. Le troisième paramètre est une chaîne de caractères à choisir parmi "exec" ou
"eval". Selon ce choix, ce sera la fonction exec ou eval qui devra être utilisée pour agréger le résultat de la
fonction compile au programme. L’exemple suivant donne un exemple d’utilisation de la fonction compile
avec la fonction eval.
import math
str = """math.sqrt(x*x+y*y)""" # expression définie par une chaîne de caractères

obj = compile(str,"","eval") # expression compilée

x = 1
y = 2
print eval (obj) # résultat de l’expression

4.5 Indentation
L’indentation est synonyme de décalage. Pour toute boucle, test, fonction, et plus tard, toute définition
de classe, le fait d’indenter ou décaler les lignes permet de définir une dépendance d’un bloc de lignes par
 4. Syntaxe du langage Python (boucles, tests, fonctions) 75

rapport à un autre. Les lignes indentées par rapport à une boucle for dépendent de celle-ci puisqu’elle
seront exécutées à chaque passage dans la boucle. Les lignes indentées par rapport au mot-clé def sont
considérées comme faisant partie du corps de la fonction. La remarque 4.4 page 53 précise l’erreur que
l’interpréteur Python retourne en cas de mauvaise indentation.
Contrairement à d’autres langages comme le C ou PERL, Python n’utilise pas de délimiteurs pour regrou-
per les lignes. L’indentation, souvent présentée comme un moyen de rendre les programmes plus lisibles,
est ici intégrée à la syntaxe du langage. Il n’y a pas non plus de délimiteurs entre deux instructions autre
qu’un passage à la ligne. Le caractère \ placé à la fin d’une ligne permet de continuer l’écriture d’une
instruction à la ligne suivante.

4.6 Fonctions usuelles

Certaines fonctions sont communes aux dictionnaires et aux listes, elles sont également définis pour de
nombreux objets présents dans les extensions du langages. Quelque soit le contexte, le résultat attendu à
la même signification. Les plus courantes sont présentées par la table 4.4.
La fonction map permet d’écrire des boucles de façon simplifiée. Elle est utile dans le cas où on souhaite
appliquer la même fonction à tous les éléments d’un ensemble. Par exemple les deux dernières lignes du
programme suivant sont équivalentes.
l = [0,3,4,4,5,6]
print [ est_pair (i) for i in l ] # affiche [0, 1, 0, 0, 1, 0]
print map (est_pair, l) # affiche [0, 1, 0, 0, 1, 0]

Elle peut aider à simplifier l’écriture lorsque plusieurs listes sont impliquées. Ici encore, les deux dernières
lignes sont équivalentes.
def addition (x,y) : return x + y
l = [0,3,4,4,5,6]
m = [1,3,4,5,6,8]
print [ addition (l [i], m [i]) for i in range (0, len (l)) ]
print map (addition, l, m) # affiche [1, 6, 8, 9, 11, 14]

Il est possible de substituer None à la fonction f pour obtenir l’équivalent de la fonction zip.
print map (None, l,m) # affiche [(0, 1), (3, 3), (4, 4), (4, 5), (5, 6), (6, 8)]
print zip (l,m) # affiche [(0, 1), (3, 3), (4, 4), (4, 5), (5, 6), (6, 8)]

Comme pour les dictionnaires, la fonction sorted permet de parcourir les éléments d’une liste de façon
ordonnée. Les deux exemples qui suivent sont presque équivalents. Dans le second, la liste l demeure
inchangée alors qu’elle est triée dans le premier programme.

l = [ 4, 5, 3, -6, 7, 9] l = [ 4, 5, 3, -6, 7, 9]
l.sort ()
for n in l : for n in sorted (l) :
print n print n

La fonction enumerate permet d’éviter l’emploi de la fonction range ou xrange lorsqu’on souhaite parcourir
une liste alors que l’indice et l’élément sont nécessaires.

l = [ 4, 5, 3, -6, 7, 9] l = [ 4, 5, 3, -6, 7, 9]
for i in xrange (0, len (l)) : for i,v in enumerate (l) :
print i, l [i] print i, v
 4. Syntaxe du langage Python (boucles, tests, fonctions) 76

abs(x) Retourne la valeur absolue de x.

callable(x) Dit si la variable x peut être appelée.
chr(i) Retourne le caractère associé au code numérique i.
cmp(x, y) Compare x et y, retourne -1 si x < y, 0 en cas d’égalité, 1 sinon.
Retourne l’ensemble des méthodes associées à x qui peut être un objet, un module,
dir(x)
un variable,...
enumerate(x) parcourt un ensemble itérable (voir paragraphe 4.6)
help(x) Retourne l’aide associée à x.
Retourne un identifiant unique associé à l’objet x. Le mot-clé is est relié à cet iden-
id(x)
tifiant.
isinstance(
Dit si l’objet x est de type classe, voir le chapitre 5 sur les classes.
x, classe
issubclass(
Dit si la classe cl1 hérite de la classe cl2, voir le chapitre 5 sur les classes.
cl1, cl2)
len(l) Retourne la longueur de l.
map(f, l1, l2, ...) Applique la fonction f sur les listes l1, l2... Voir l’exemple page 75.
max(l) Retourne le plus grand élément de l.
min(l) Retourne le plus petit élément de l.
ord(s) Fonction réciproque de chr.
range(i, j[, k] Construit la liste des entiers de i à j. Si k est précisé, va de k en k à partir de i.
reload(module) Recharge un module (voir paragraphe 7).
repr(o) Retourne une chaîne de caractères qui représente l’objet o.
round(x[, n]) Arrondi x à n décimales près ou aucune si n n’est pas précisé.
sorted(x
[, cmp[, key[, tri un ensemble itérable (voir paragraphe 4.6)
reverse]]])
str(o) Retourne une chaîne de caractères qui représente l’objet o.
sum(l) Retourne la somme de l’ensemble l.
type(o) Retourne le type de la variable o.
xrange(i, j[, k] Plus rapide que la fonction range mais utilisable que dans une boucle for.
zip(l1, l2, ...) Construit une liste de tuples au lieu d’un tuple de listes.
Table 4.4 : Liste non exhaustive de fonctions définis par le langage Python sans qu’aucune extension ne soit
nécessaire. Elles ne sont pas toujours applicables même si la syntaxe d’appel est correcte, elles produisent une erreur
dans ce cas.

4.7 Constructions classiques

Les paragraphes qui suivent décrivent des schémas qu’on retrouve dans les programmes dans de nombreuses
situations. Ce sont des combinaisons simples d’une ou deux boucles, d’un test, d’une liste, d’un dictionnaire.

4.7.1 Recherche d’un élément

Rechercher un élément consiste à parcourir un ensemble jusqu’à ce qu’on le trouve : le résultat souhaité
est sa position ou un résultat indiquant qu’il n’a pas été trouvé. Cette recherche est souvent insérée dans
une fonction dont voici le schéma :
def recherche (li, c) :
for i,v in enumerate (li) :
if v == c : return i
return -1
li = [ 45, 32, 43, 56 ]
print recherche (li, 43) # affiche 2
 4. Syntaxe du langage Python (boucles, tests, fonctions) 77

La méthode index permet de réduire ce programme.

print li.index (43)

Néanmoins, la fonction recherche peut être adaptée pour rechercher la première valeur trouvée parmi deux
possibles, ce qu’il n’est pas possible de faire avec la méthode index.
def recherche (li, c,d) :
for i,v in enumerate (li) :
if v in [c,d] : return i
return -1
li = [ 45, 32, 43, 56 ]
print recherche (li, 43, 32) # affiche 1

Ce court exemple montre qu’il est utile de connaître quelques algorithmes simples. Ils ne sont pas forcément
les plus efficaces mais ils aident à construire des programmes plus rapidement et à obtenir un résultat. S’il
est positif alors il sera toujours temps de se pencher sur l’optimisation du programme pour qu’il soit plus
efficace.

4.7.2 Maximum, minimum

La recherche d’un extremum comme le calcul d’une somme fait toujours intervenir une boucle. La différence
est qu’on souhaite parfois obtenir la position du maximum.
li = [ 0, 434, 43, 6436, 5 ]
m = li [0] # initialisation
for l in li : # boucle
if m < l : m = l # m est le maximum

Ce code est équivalent à l’instruction li = [ 0, 434, 43, 6436, 5 ]

max(li). Pour récupérer la position du m = 0
maximum, il faut itérer sur les positions for i in xrange (0, len (li)) :
if li [m] < li [i] : m = i
et non sur les éléments.

Pour éviter la boucle, on peut utiliser l’astuce décrite au paragraphe 4.7.7 qui consiste à former une liste
de couples avec la position initiale :
k = [ (v,i) for i,v in enumerate (li) ]
m = max (k) [1]

Il arrive fréquemment qu’on ne doive pas chercher le maximum d’une liste mais le maximum au sein
d’un sous-ensemble de cette liste. Dans l’exemple qui suit, on cherche le tuple dont la première valeur est
maximale et dont la seconde valeur est égale à 1.
li = [ (0,0), (434,0), (43,1), (6436,1), (5,0) ]
m = -1 # -1 car le premier élément peut ne pas faire partie du sous-ensemble
for i in range (0, len (li)) :
if li [i][1] == 0 and (m == -1 or li [m][0] < li [i][0]) : m = i

4.7.3 Recherche dichotomique

La recherche dichotomique est plus rapide qu’une recherche classique mais elle suppose que celle-ci s’ef-
fectue dans un ensemble trié. L’idée est de couper en deux l’intervalle de recherche à chaque itération.
Comme l’ensemble est trié, en comparant l’élément cherché à l’élément central, on peut éliminer une partie
de l’ensemble : la moitié inférieure ou supérieure.
 4. Syntaxe du langage Python (boucles, tests, fonctions) 78

def recherche_dichotomique (li, c) :

a,b = 0, len (li)-1
while a <= b :
m = (a+b)/2
if c == li [m] : return m 5
elif c < li [m] : b = m-1 # partie supérieure éliminée
else : a = m+1 # partie inférieure éliminée
return -1 # élément non trouvé

li = range (0,100,2) 10
print recherche_dichotomique (li, 48) # affiche 24
print recherche_dichotomique (li, 49) # affiche -1

4.7.4 Décomposition en matrice

Les quelques lignes qui suivent permettent de décomposer une chaîne de caractères en matrice. Chaque
ligne et chaque colonne sont séparées par des séparateurs différents. Ce procédé intervient souvent lorsqu’on
récupère des informations depuis un fichier texte lui-même provenant d’un tableur.
s = "case11;case12;case13|case21;case22;case23"
# décomposition en matrice
ligne = s.split ("|") # lignes
mat = [ l.split (";") for l in ligne ] # colonnes

L’opération inverse :

ligne = [ ";".join (l) for l in mat ] # colonnes

s = "|".join (ligne) # lignes

4.7.5 Somme
Le calcul d’une somme fait toujours intervenir une boucle car le langage Python ne peut faire des additions
qu’avec deux nombres. Le schéma est toujours le même : initialisation et boucle.
li = [ 0, 434, 43, 6456 ]
s = 0 # initialisation
for l in li : # boucle
s += l # addition

Ce code est équivalent à l’instruction sum(li). Dans ce cas où la somme intègre le résultat d’une fonction
et non les éléments d’une liste, il faudrait écrire :
def fonction (x) : return x*x
s = 0
for l in li : s += fonction (l)

Et ces deux lignes pourraient être résu- s = sum ( [fonction (l) for l in li] )
mées en une seule grâce à l’une de ces
s = sum ( map (fonction, li) )
deux instructions.
L’avantage de la solution avec la boucle est qu’elle évite la création d’une liste intermédiaire, c’est un point
à prendre en compte si la liste sur laquelle opère la somme est volumineuse. Il peut être intéressant de
regarder l’exercice 13.1.9 page 330.
 4. Syntaxe du langage Python (boucles, tests, fonctions) 79

4.7.6 Tri
Le tri est une opération fréquente. On n’a pas toujours le temps de programmer le tri le plus efficace comme
un tri quicksort et un tri plus simple suffit la plupart du temps. Le tri suivant consiste à recherche le plus
petit élément puis à échanger sa place avec le premier élément du tableau du tableau. On recommence la
même procédure à partir de la seconde position, puis la troisième et ainsi de suite jusqu’à la fin du tableau.

for i in xrange (0, len (li)) :

# recherche du minimum entre i et len (li) exclu
pos = i
for j in xrange (i+1, len (li)) :
if li [j] < li [pos] : pos = j
# échange
ech = li [pos]
li [pos] = li [i]
li [i] = ech

La méthode sort tri également une liste mais selon un algorithme plus efficace que celui-ci dont la logique
est présentée par l’exercice 11.5.1, page 227. Ceci explique pourquoi on hésite toujours à programmer un
tri quitte à avoir recours à une astuce telle que celle présentées au paragraphe suivant.

4.7.7 Tri et position initiale

Il arrive parfois qu’on souhaite trier un tableau puis appliquer la même transformation à un second tableau.
Pour cela, il faut récupérer la position initiale des éléments dans le tableau trié. Une possibilité consiste à
trier non pas le tableau mais une liste de couples (valeur, position) comme le montre l’exemple suivant :
tab = ["zéro", "un", "deux"] # tableau à trier
pos = [ (tab [i],i) for i in range (0, len (tab)) ] # tableau de couples
pos.sort () # tri
print pos # affiche [(’deux’, 2), (’un’, 1), (’zéro’, 0)]

La liste [p[1] for p in pos] correspond à l’ensemble des positions initiales des éléments de la liste tab. Les
deux lignes qui suivent permettent d’en déduire la position de chaque élément dans l’ensemble trié. ordre[i]
est le rang de l’élément d’indice i avant le tri.
ordre = range (0, len (pos))
for i in xrange (0, len (pos)) : ordre [pos [i][1]] = i

4.7.8 Comptage
On souhaite ici compter le nombre d’occurrences de chaque élément d’un tableau. Par exemple, on pourrait
connaître par ce moyen la popularité d’un mot dans un discours politique ou l’étendue du vocabulaire
utilisé. L’exemple suivant compte les mots d’une liste de mots.
li = ["un", "deux", "un", "trois"]
d = { }
for l in li :
if l not in d : d [l] = 1
else : d [l] += 1
print d # affiche {’un’: 2, ’trois’: 1, ’deux’: 1}

La structure la plus appropriée ici est un dictionnaire puisqu’on cherche à associer une valeur à un élément
d’une liste qui peut être de tout type. Si la liste contient des éléments de type modifiable comme une
liste, il faudrait convertir ceux-ci en un type immuable comme une chaîne de caractères. L’exemple suivant
illustre ce cas en comptant les occurrences des lignes d’une matrice.
 4. Syntaxe du langage Python (boucles, tests, fonctions) 80

mat = [ [1,1,1], [2,2,2], [1,1,1]]

d = { }
for l in mat :
k = str (l) # k = tuple (l) lorsque cela est possible
if k not in d : d [k] = 1
else : d [k] += 1
print d # affiche {’[1, 1, 1]’: 2, ’[2, 2, 2]’: 1}

On peut également vouloir non pas compter le nombre d’occurrence mais mémoriser les positions des
éléments tous identiques. On doit utiliser un dictionnaire de listes :
li = ["un", "deux", "un", "trois"]
d = { }
for i,v in enumerate (li) :
if v not in d : d [v] = [ i ]
else : d [v].append (i)
print d # affiche {’un’: [0, 2], ’trois’: [3], ’deux’: [1]}

4.7.9 Matrice en un vecteur

Dans un langage comme le C++, il arrive fréquemment qu’une matrice ne soit pas représentée par une
liste de listes mais par une seule liste car cette représentation est plus efficace. Il faut donc convertir un
indice en deux indices ligne et colonne. Il faut bien sûr que le nombre de colonnes sur chaque ligne soit
constant. Le premier programme convertit une liste de listes en une seule liste.
mat = [[0,1,2],[3,4,5]]
lin = [ i * len (mat [i]) + j \
for i in range (0, len (mat)) \
for j in range (0, len (mat [i])) ]

Le programme suivant fait l’inverse. Il faut faire attention à la position des crochets et l’ordre des boucles
for.
nc = len (mat [0])
mat = [ [ lin [i * nc + j] for j in range (0, len (mat [i])) ] \
for i in range (0, len (mat)) ]

4.7.10 Fonctions et variables

Une fonction peut aussi recevoir en paramètre une autre fonction. L’exemple suivant inclut la fonction
calcul_n_valeur qui prend comme paramètres l et f. Cette fonction calcule pour toutes les valeurs x
de la liste l la valeur f(x). fonction_carre ou fonction_cube sont passées en paramètres à la fonction
calcul_n_valeur qui les exécute. Le paragraphe 5.10.1 page 114 présente le même programme mais rédigé
avec des classes.
def fonction_carre(x) : return x*x
def fonction_cube (x) : return x*x*x

def calcul_n_valeur (l,f):

res = [ f(i) for i in l ]
return res

l = [0,1,2,3]
print l # affiche [0, 1, 2, 3]

l1 = calcul_n_valeur (l, fonction_carre)

print l1 # affiche [0, 1, 4, 9]

l2 = calcul_n_valeur (l, fonction_cube)

print l2 # affiche [0, 1, 8, 27]
Chapitre 5
Classes

Imaginons qu’une banque détienne un fichier contenant des informations sur ses clients et qu’il soit impos-
sible pour un client d’avoir accès directement à ces informations. Toutefois, il lui est en théorie possible
de demander à son banquier quelles sont les informations le concernant détenues par sa banque. Il est en
théorie également possible de les rectifier s’il estime qu’elles sont incorrectes. 1 .
On peut comparer cette banque à un objet qui possède des informations et des moyens permettant de lire
ces informations et de les modifier. Vu de l’extérieur, cette banque cache son fonctionnement interne et les
informations dont elle dispose, mais propose des services à ses utilisateurs.
On peut considérer la banque comme un objet au sens informatique. Ce terme désigne une entité possédant
des données et des méthodes permettant de les manipuler. Plus concrètement, une classe est un assemblage
de variables appelées attributs et de fonctions appelées méthodes. L’ensemble des propriétés associées aux
classes est regroupé sous la désignation de programmation objet.

5.1 Présentation des classes : méthodes et attributs

5.1.1 Définition, déclaration

Définition 5.1 : classe

Une classe est un ensemble incluant des variables ou attributs et des fonctions ou méthodes. Les
attributs sont des variables accessibles depuis toute méthode de la classe où elles sont définies. En
Python, les classes sont des types modifiables.

syntaxe 5.2 : classe, définition

class nom_classe :
# corps de la classe
# ...

Le corps d’une classe peut être vide, inclure des variables ou attributs, des fonctions ou méthodes.
Il est en tout cas indenté de façon à indiquer à l’interpréteur Python les lignes qui forment le corps
de la classe.
Les classes sont l’unique moyen en langage Python de définir de nouveaux types propres à celui qui
programme. Il n’existe pas de type "matrice" ou de type "graphe" en langage Python qui soit prédéfini 2 .
Il est néanmoins possible de les définir au moyen des classes. Une matrice est par exemple un objet qui
inclut les attributs suivant : le nombre de lignes, le nombre de colonnes, les coefficients de la matrice.
Cette matrice inclut aussi des méthodes comme des opérations entre deux matrices telles que l’addition,
la soustraction, la multiplication ou des opérations sur elle-même comme l’inversion, la transposition, la
diagonalisation.
Cette liste n’est pas exhaustive, elle illustre ce que peut être une classe "matrice" - représentation infor-
matique d’un objet "matrice" -, un type complexe incluant des informations de types variés (entier pour
les dimensions, réels pour les coefficients), et des méthodes propres à cet objet, capables de manipuler ces
1. Tout fichier contenant des données à caractère personnel doit être recensé auprès de la Commission nationale de
l’informatique et des libertés (CNIL). Cet organisme facilite l’accès à ces informations.
2. Les matrices sont définies dans une extension externe numpy (voir le chapitre 7).
 5. Classes 82

informations.
Il est tout-à-fait possible de se passer des classes pour rédiger un programme informatique. Leur utilisation
améliore néanmoins sa présentation et la compréhension qu’on peut en avoir. Bien souvent, ceux qui passent
d’un langage uniquement fonctionnel à un langage objet ne font pas marche arrière.

syntaxe 5.3 : classe, création d’une variable de type objet

cl = nom_classe ()

La création d’une variable de type objet est identique à celle des types standards du langage Python :
elle passe par une simple affectation. On appelle aussi cl une instance de la classe nom_classe.

Cette syntaxe est identique à la syntaxe d’appel d’une fonction. La création d’une instance peut également
faire intervenir des paramètres (voir paragraphe 5.4). Le terme instance va de paire avec le terme classe :

Définition 5.4 : instance

Une instance d’une classe C désigne une variable de type C. Le terme instance ne s’applique qu’aux
variables dont le type est une classe.

L’exemple suivant permet de définir une classe vide. Le mot-clé pass permet de préciser que le corps de la
classe ne contient rien.
class classe_vide:
pass

Il est tout de même possible de définir une instance de la classe classe_vide simplement par l’instruction
suivante :
class classe_vide:
pass
cl = classe_vide ()

Remarque 5.5 : type d’une instance

Dans l’exemple précédent, la variable nb n’est pas de type exemple_classe mais de type instance comme
le montre la ligne suivante :
print type (cl) # affiche <type ’instance’>

Pour savoir si une variable est une instance d’une classe donnée, il faut utiliser la fonction isinstance :
isinstance (cl,classe_vide) # affiche True

5.1.2 Méthodes

Définition 5.6 : méthode

Les méthodes sont des fonctions qui sont associées de manière explicite à une classe. Elles ont comme
particularité un accès privilégié aux données de la classe elle-même.

Ces données ou attributs sont définis plus loin. Les méthodes sont en fait des fonctions pour lesquelles
la liste des paramètres contient obligatoirement un paramètre explicite qui est l’instance de la classe à
 5. Classes 83

laquelle cette méthode est associée. Ce paramètre est le moyen d’accéder aux données de la classe.

syntaxe 5.7 : classe, méthode, définition

class nom_classe :
def nom_methode (self, param_1, ..., param_n) :
# corps de la méthode...

A part le premier paramètre qui doit de préférence s’appeler self, la syntaxe de définition d’une
méthode ressemble en tout point à celle d’une fonction. Le corps de la méthode est indenté par
rapport à la déclaration de la méthode, elle-même indentée par rapport à la déclaration de la classe.

L’appel à cette méthode obéit à la syntaxe qui suit :

syntaxe 5.8 : classe, méthode, appel

cl = nom_classe () # variable de type nom_classe
t = cl.nom_methode (valeur_1, ..., valeur_n)

L’appel d’une méthode nécessite tout d’abord la création d’une variable. Une fois cette variable créée,
il suffit d’ajouter le symbole "." pour exécuter la méthode. Le paramètre self est ici implicitement
remplacé par cl lors de l’appel.

L’exemple suivant simule le tirage de nombres aléatoires à partir d’une suite définie par récurrence un+1 =
(un ∗A) mod B où A et B sont des entiers très grands. Cette suite n’est pas aléatoire mais son comportement
imite celui d’une suite aléatoire. Le terme un est dans cet exemple contenu dans la variable globale rnd.
rnd = 42

class exemple_classe:
def methode1(self,n):
"""simule la génération d’un nombre aléatoire
compris entre 0 et n-1 inclus"""
global rnd
rnd = 397204094 * rnd % 2147483647
return int (rnd % n)

nb = exemple_classe ()
l = [ nb.methode1(100) for i in range(0,10) ]
print l # affiche [19, 46, 26, 88, 44, 56, 56, 26, 0, 8]

nb2 = exemple_classe ()
l2 = [ nb2.methode1(100) for i in range(0,10) ]
print l2 # affiche [46, 42, 89, 66, 48, 12, 61, 84, 71, 41]

Deux instances nb et nb2 de la classe exemple_classe sont créées, chacune d’elles est utilisée pour générer
aléatoirement dix nombres entiers compris entre 0 et 99 inclus. Les deux listes sont différentes puisque
l’instance nb2 utilise la variable globale rnd précédemment modifiée par l’appel nb.methode1(100).
Remarque 5.9 : méthodes et fonctions
Les méthodes sont des fonctions insérées à l’intérieur d’une classe. La syntaxe de la déclaration d’une
méthode est identique à celle d’une fonction en tenant compte du premier paramètre qui doit impérati-
vement être self. Les paramètres par défaut, l’ordre des paramètres, les nombres variables de paramètres
présentés au paragraphe 4.4 sont des extensions tout autant applicables aux méthodes qu’aux fonctions.

5.1.3 Attributs

Définition 5.10 : attribut

Les attributs sont des variables qui sont associées de manière explicite à une classe. Les attributs de
la classe se comportent comme des variables globales pour toutes les méthodes de cette classe.
 5. Classes 84

Une classe permet en quelque sorte de regrouper ensemble des informations liées. Elles n’ont de sens
qu’ensemble et les méthodes manipulent ces données liées. C’est le cas pour un segment qui est toujours
défini par ces deux extrémités qui ne vont pas l’une sans l’autre.

syntaxe 5.11 : classe, attribut, définition

class nom_classe :
def nom_methode (self, param_1, ..., param_n) :
self.nom_attribut = valeur

Le paramètre self n’est pas un mot-clé même si le premier paramètre est le plus souvent appelé
self. Il désigne l’instance de la classe sur laquelle va s’appliquer la méthode. La déclaration d’une
méthode inclut toujours un paramètre self de sorte que self.nom_attribut désigne un attribut de
la classe. nom_attribut seul désignerait une variable locale sans aucun rapport avec un attribut
portant le même nom. Les attributs peuvent être déclarés à l’intérieur de n’importe quelle méthode,
voire à l’extérieur de la classe elle-même.

L’endroit où est déclaré un attribut a peu d’importance pourvu qu’il le soit avant sa première utilisation.
Dans l’exemple qui suit, la méthode methode1 utilise l’attribut rnd sans qu’il ait été créé.
class exemple_classe:
def methode1(self,n):
"""simule la génération d’un nombre aléatoire
compris entre 0 et n-1 inclus"""
self.rnd = 397204094 * self.rnd % 2147483647
return int (self.rnd % n)

nb = exemple_classe ()
l = [ nb.methode1(100) for i in range(0,10) ]
print l

Cet exemple déclenche donc une erreur (ou exception) signifiant que l’attribut rnd n’a pas été créé.
Traceback (most recent call last):
File "cours.py", line 8, in -toplevel-
l = [ nb.methode1(100) for i in range(0,10) ]
File "cours.py", line 4, in methode1
self.rnd = 397204094 * self.rnd % 2147483647
AttributeError: exemple_classe instance has no attribute ’rnd’

Pour remédier à ce problème, il existe plusieurs endroits où il est possible de créer l’attribut rnd. Il est
possible de créer l’attribut à l’intérieur de la méthode methode1. Mais le programme n’a plus le même
sens puisqu’à chaque appel de la méthode methode1, l’attribut rnd reçoit la valeur 42. La liste de nombres
aléatoires contient dix fois la même valeur.
class exemple_classe:
def methode1(self,n):
"""simule la génération d’un nombre aléatoire
compris entre 0 et n-1 inclus"""
self.rnd = 42 # déclaration à l’intérieur de la méthode,
# doit être précédé du mot-clé self
self.rnd = 397204094 * self.rnd % 2147483647
return int (self.rnd % n)

nb = exemple_classe ()
l = [ nb.methode1(100) for i in range(0,10) ]
print l # affiche [19, 19, 19, 19, 19, 19, 19, 19, 19, 19]

Il est possible de créer l’attribut rnd à l’extérieur de la classe. Cette écriture devrait toutefois être évitée
puisque la méthode methode1 ne peut pas être appelée sans que l’attribut rnd ait été ajouté.
class exemple_classe:
def methode1(self,n):
"""simule la génération d’un nombre aléatoire
compris entre 0 et n-1 inclus"""
 5. Classes 85

self.rnd = 397204094 * self.rnd % 2147483647

return int (self.rnd % n)

nb = exemple_classe ()
nb.rnd = 42 # déclaration à l’extérieur de la classe,
# indispensable pour utiliser la méthode methode1
l = [ nb.methode1(100) for i in range(0,10) ]
print l # affiche [19, 46, 26, 88, 44, 56, 56, 26, 0, 8]

5.2 Constructeur
L’endroit le plus approprié pour déclarer un attribut est à l’intérieur d’une méthode appelée le constructeur.
S’il est défini, il est implicitement exécuté lors de la création de chaque instance. Le constructeur d’une
classe se présente comme une méthode et suit la même syntaxe à ceci près que son nom est imposé :
__init__. Hormis le premier paramètre, invariablement self, il n’existe pas de contrainte concernant la
liste des paramètres excepté que le constructeur ne doit pas retourner de résultat.

syntaxe 5.12 : classe, constructeur

class nom_classe :
def __init__(self, param_1, ..., param_n):
# code du constructeur

nom_classe est une classe, __init__ est son constructeur, sa syntaxe est la même que celle d’une
méthode sauf que le constructeur ne peut employer l’instruction return.

La modification des paramètres du constructeur implique également la modification de la syntaxe de

création d’une instance de cette classe.

syntaxe 5.13 : classe, instance

x = nom_classe (valeur_1,...,valeur_n)

nom_classe est une classe, valeur_1 à valeur_n sont les valeurs associées aux paramètres param_1
à param_n du constructeur.

L’exemple suivant montre deux classes pour lesquelles un constructeur a été défini. La première n’ajoute
aucun paramètre, la création d’une instance ne nécessite pas de paramètre supplémentaire. La seconde
classe ajoute deux paramètres a et b. Lors de la création d’une instance de la classe classe2, il faut ajouter
deux valeurs.
class classe1:
def __init__(self):
# pas de paramètre supplémentaire
print "constructeur de la classe classe1"
self.n = 1 # ajout de l’attribut n

x = classe1 () # affiche constructeur de la classe classe1

print x.n # affiche 1

class classe2:
def __init__(self,a,b):
# deux paramètres supplémentaires
print "constructeur de la classe classe2"
self.n = (a+b)/2 # ajout de l’attribut n

x = classe2 (5,9) # affiche constructeur de la classe classe2

print x.n # affiche 7

Remarque 5.14 : constructeur et fonction

Le constructeur autorise autant de paramètres qu’on souhaite lors de la création d’une instance et celle-ci
suit la même syntaxe qu’une fonction. La création d’une instance pourrait être considérée comme l’appel
à une fonction à ceci près que le type du résultat est une instance de classe.
 5. Classes 86

En utilisant un constructeur, l’exemple du paragraphe précédent simulant une suite de variable aléatoire
permet d’obtenir une classe autonome qui ne fait pas appel à une variable globale ni à une déclaration
d’attribut extérieur à la classe.
class exemple_classe:
def __init__ (self) : # constructeur
self.rnd = 42 # on crée l’attribut rnd, identique pour chaque instance
# --> les suites générées auront toutes le même début
def methode1(self,n):
self.rnd = 397204094 * self.rnd % 2147483647
return int (self.rnd % n)

nb = exemple_classe ()
l = [ nb.methode1(100) for i in range(0,10) ]
print l # affiche [19, 46, 26, 88, 44, 56, 56, 26, 0, 8]

nb2 = exemple_classe ()
l2 = [ nb2.methode1(100) for i in range(0,10) ]
print l2 # affiche [19, 46, 26, 88, 44, 56, 56, 26, 0, 8]

De la même manière qu’il existe un constructeur exécuté à chaque création d’instance, il existe un des-
tructeur exécuté à chaque destruction d’instance. Il suffit pour cela de redéfinir la méthode __del__. A
l’inverse d’autres langages comme le C++, cet opérateur est peu utilisé car le Python nettoie automati-
quement les objets qui ne sont plus utilisés ou plus référencés par une variable. Un exemple est donné
page 99.

5.3 Apport du langage Python

5.3.1 Liste des attributs
Chaque attribut d’une instance de classe est inséré dans un dictionnaire appelé __dict__, attribut
implicitement présent dès la création d’une instance.
class exemple_classe:
def __init__ (self) :
self.rnd = 42
def methode1(self,n):
self.rnd = 397204094 * self.rnd % 2147483647
return int (self.rnd % n)

nb = exemple_classe ()
print nb.__dict__ # affiche {’rnd’: 42}

Ce dictionnaire offre aussi la possibilité de tester si un attribut existe ou non. Dans un des exemples du
paragraphe précédent, l’attribut rnd était créé dans la méthode methode1, sa valeur était alors initialisée
à chaque appel et la fonction retournait sans cesse la même valeur. En testant l’existence de l’attribut
rnd, il est possible de le créer dans la méthode methode1 au premier appel sans que les appels suivants ne
réinitialisent sa valeur à 42.
class exemple_classe:
def methode1(self,n):
if "rnd" not in self.__dict__ : # l’attribut existe-t-il ?
self.rnd = 42 # création de l’attribut
self.__dict__ ["rnd"] = 42 # autre écriture possible
self.rnd = 397204094 * self.rnd % 2147483647
return int (self.rnd % n)

nb = exemple_classe ()
l = [ nb.methode1(100) for i in range(0,10) ]
print l # affiche [19, 46, 26, 88, 44, 56, 56, 26, 0, 8]
 5. Classes 87

5.3.2 Attributs implicites

Certains attributs sont créés de manière implicite lors de la création d’une instance. Ils contiennent des
informations sur l’instance.

__module__ Contient le nom du module dans lequel est incluse la classe (voir chapitre 7).
Contient le nom de la classe de l’instance. Ce nom est précédé du nom du module suivi
__class__
d’un point.
__dict__ Contient la liste des attributs de l’instance (voir paragraphe 5.3.1).
__doc__ Contient un commentaire associé à la classe (voir paragraphe 5.3.3).

L’attribut __class__ contient lui même d’autres d’attributs :

__doc__ Contient un commentaire associé à la classe (voir paragraphe 5.3.3).

Contient la liste des attributs statiques (définis hors d’une méthode) et des méthodes
__dict__
(voir paragraphe 5.5.2).
__name__ Contient le nom de l’instance.
__bases__ Contient les classes dont la classe de l’instance hérite (voir paragraphe 5.8).

class classe_vide:
pass
cl = classe_vide ()
print cl.__module__ # affiche __main__
print cl.__class__ # affiche __main__.classe_vide ()
print cl.__dict__ # affiche {}
print cl.__doc__ # affiche None (voir paragraphe suivant)
print cl.__class__.__doc__ # affiche None
print cl.__class__.__dict__ # affiche {’__module__’: ’__main__’,
# ’__doc__’: None}
print cl.__class__.__name__ # affiche classe_vide
print cl.__class__.__bases__ # affiche ()

5.3.3 Commentaires, aide

Comme les fonctions et les méthodes, des commentaires peuvent être associés à une classe, ils sont affichés
grâce à la fonction help. Cette dernière présente le commentaire associé à la classe, la liste des méthodes
ainsi que chacun des commentaires qui leur sont associés. Ce commentaire est affecté à l’attribut implicite
__doc__. L’appel à la fonction help rassemble le commentaire de toutes les méthodes, le résultat suit le
programme ci-dessous.
class exemple_classe:
"""simule une suite de nombres aléatoires"""
def __init__ (self) :
"""constructeur : initialisation de la première valeur"""
self.rnd = 42
def methode1(self,n):
"""simule la génération d’un nombre aléatoire
compris entre 0 et n-1 inclus"""
self.rnd = 397204094 * self.rnd % 2147483647
return int (self.rnd % n)
nb = exemple_classe ()
help (exemple_classe) # appelle l’aide associée à la classe

class exemple_classe
| simule une suite de nombres aléatoires
|
| Methods defined here:
|
| __init__(self)
 5. Classes 88

| constructeur : initialisation de la première valeur

|
| methode1(self, n)
| simule la génération d’un nombre aléatoire
| compris entre 0 et n-1 inclus

Pour obtenir seulement le commentaire associé à la classe, il suffit d’écrire l’une des trois lignes suivantes :

print exemple_classe.__doc__ # affiche simule une suite de nombres aléatoires

print nb.__doc__ # affiche simule une suite de nombres aléatoires
print nb.__class__.__doc__ # affiche simule une suite de nombres aléatoires

La fonction help permet d’accéder à l’aide associée à une fonction, une classe. Il existe des outils qui
permettent de collecter tous ces commentaires pour construire une documentation au format HTML à
l’aide d’outils comme pydoc 3 ou Doxygen 4 . Ces outils sont souvent assez simples d’utilisation.
La fonction dir permet aussi d’obtenir des informations sur la classe. Cette fonction appliquée à la classe
ou à une instance retourne l’ensemble de la liste des attributs et des méthodes. L’exemple suivant utilise la
fonction dir avant et après l’appel de la méthode meth. Etant donné que cette méthode ajoute un attribut,
la fonction dir retourne une liste plus longue après l’appel.
class essai_class:
def meth(self):
x = 6
self.y = 7

a = essai_class()
print dir (a) # affiche [’__doc__’, ’__module__’, ’meth’]
a.meth ()
print dir (a) # affiche [’__doc__’, ’__module__’, ’meth’, ’y’]
print dir (essai_class) # affiche [’__doc__’, ’__module__’, ’meth’]

La fonction dir appliquée à la classe elle-même retourne une liste qui inclut les méthodes et les attributs
déjà déclarés. Elle n’inclut pas ceux qui sont déclarés dans une méthode jamais exécutée jusqu’à présent.

5.3.4 Classe incluse

Parfois, il arrive qu’une classe soit exclusivement utilisée en couple avec une autre, c’est par exemple le
cas des itérateurs (voir paragraphe 5.4.2). Il est alors possible d’inclure dans la déclaration d’une classe
celle d’une sous-classe.
L’exemple qui suit contient la classe ensemble_element. C’est un ensemble de points en trois dimensions
(classe element) qui n’est utilisé que par cette classe. Déclarer la classe element à l’intérieur de la classe
ensemble_element est un moyen de signifier ce lien.

class ensemble_element :

class element :
def __init__ (self) :
self.x, self.y, self.z = 0,0,0

def __init__ (self) :

self.all = [ ensemble_element.element () for i in xrange (0,3) ]

def barycentre (self) :

b = ensemble_element.element ()
for el in self.all :
b.x += el.x
b.y += el.y
b.z += el.z
b.x /= len (self.all)

3. voir http://pydoc.org/ ou http://docs.python.org/library/pydoc.html

4. http://www.stack.nl/~dimitri/doxygen/ associé à doxypy (http://code.foosel.org/doxypy).
 5. Classes 89

b.y /= len (self.all)

b.z /= len (self.all)
return b

f = ensemble_element ()
f.all [0].x, f.all [0].y, f.all [0].z = 4.5,1.5,1.5
b = f.barycentre ()
print b.x,b.y,b.z # affiche 1.5 0.5 0.5

Pour créer une instance de la classe element, il faut faire précéder son nom de la classe où elle est déclarée :
b = ensemble_element.element() comme c’est le cas dans la méthode barycentre par exemple.

5.4 Opérateurs, itérateurs

Les opérateurs sont des symboles du langages comme +, -, +=, ... Au travers des opérateurs, il est possible
de donner un sens à une syntaxe comme celle de l’exemple suivant :
class nouvelle_classe:
pass
x = nouvelle_classe () + nouvelle_classe ()

L’addition n’est pas le seul symbole concerné, le langage Python permet de donner un sens à tous les
opérateurs numériques et d’autres reliés à des fonctions du langage comme len ou max.

5.4.1 Opérateurs
Le programme suivant contient une classe définissant un nombre complexe. La méthode ajoute définit ce
qu’est une addition entre nombres complexes.
class nombre_complexe:
def __init__ (self, a = 0, b= 0) : self.a, self.b = a,b
def get_module (self) : return math.sqrt (self.a * self.a + self.b * self.b)

def ajoute (self,c):

return nombre_complexe (self.a + c.a, self.b + c.b)

c1 = nombre_complexe (0,1)
c2 = nombre_complexe (1,0)
c = c1.ajoute (c2) # c = c1 + c2
print c.a, c.b

Toutefois, on aimerait bien écrire simplement c = c1 + c2 au lieu de c = c1.ajoute(c2) car cette syntaxe
est plus facile à lire et surtout plus intuitive. Le langage Python offre cette possibilité. Il existe en effet
des méthodes clés dont l’implémentation définit ce qui doit être fait dans le cas d’une addition, d’une
comparaison, d’un affichage, ... A l’instar du constructeur, toutes ces méthodes clés, qu’on appelle des
opérateurs, sont encadrées par deux blancs soulignés, leur déclaration suit invariablement le même schéma.
Voici celui de l’opérateur __add__ qui décrit ce qu’il faut faire pour une addition.

syntaxe 5.15 : classe, opérateur __add__

class nom_class :
def __add__ (self, autre) :
# corps de l’opérateur
return ... # nom_classe

nom_classe est une classe. L’opérateur __add__ définit l’addition entre l’instance self et l’instance
autre et retourne une instance de la classe nom_classe.

Le programme suivant reprend le précédent de manière à ce que l’addition de deux nombres complexes
soit dorénavant une syntaxe correcte.
 5. Classes 90

class nombre_complexe:
def __init__ (self, a = 0, b= 0) : self.a, self.b = a,b
def get_module (self) : return math.sqrt (self.a * self.a + self.b * self.b)

def __add__(self, c):

return nombre_complexe (self.a + c.a, self.b + c.b)

c1 = nombre_complexe (0,1)
c2 = nombre_complexe (1,0)
c = c1 + c2 # cette expression est maintenant syntaxiquement correcte
c = c1.__add__ (c2) # même ligne que la précédente mais écrite explicitement
print c.a, c.b

L’avant dernière ligne appelant la méthode __add__ transcrit de façon explicite ce que le langage Py-
thon fait lorsqu’il rencontre un opérateur + qui s’applique à des classes. Plus précisément, c1 et c2 pour-
raient être de classes différentes, l’expression serait encore valide du moment que la classe dont dépend
c1 a redéfini la méthode __add__. Chaque opérateur possède sa méthode-clé associée. L’opérateur +=,
différent de + est associé à la méthode-clé __iadd__.

syntaxe 5.16 : classe, opérateur __iadd__

class nom_class :
def __iadd__ (self, autre) :
# corps de l’opérateur
return self

nom_classe est une classe. L’opérateur __iadd__ définit l’addition entre l’instance self et l’instance
autre. L’instance self est modifiée pour recevoir le résultat. L’opérateur retourne invariablement
l’instance modifiée self.
On étoffe la classe nombre_complexe à l’aide de l’opérateur __iadd__.
class nombre_complexe:
def __init__ (self, a = 0, b= 0) : self.a, self.b = a,b
def get_module (self) : return math.sqrt (self.a * self.a + self.b * self.b)
def __add__(self, c) : return nombre_complexe (self.a + c.a, self.b + c.b)

def __iadd__(self, c) :
self.a += c.a
self.b += c.b
return self

c1 = nombre_complexe (0,1)
c2 = nombre_complexe (1,0)
c1 += c2 # utilisation de l’opérateur +=
c1.__iadd__ (c2) # c’est la transcription explicite de la ligne précédente
print c1.a, c1.b

Un autre opérateur souvent utilisé est __str__ qui permet de redéfinir l’affichage d’un objet lors d’un
appel à l’instruction print.

syntaxe 5.17 : classe, opérateur __str__

class nom_class :
def __str__ (self) :
# corps de l’opérateur
return...

nom_classe est une classe. L’opérateur __str__ construit une chaîne de caractères qu’il retourne
comme résultat de façon à être affiché.

L’exemple suivant reprend la classe nombre_complexe pour que l’instruction print affiche un nombre com-
plexe sous la forme a + ib.
class nombre_complexe:
def __init__ (self, a = 0, b= 0) : self.a, self.b = a,b
 5. Classes 91

def __add__(self, c) : return nombre_complexe (self.a + c.a, self.b + c.b)

def __str__ (self) :

if self.b == 0 : return "%f" % (self.a)
elif self.b > 0 : return "%f + %f i" % (self.a, self.b)
else : return "%f - %f i" % (self.a, -self.b)

c1 = nombre_complexe (0,1)
c2 = nombre_complexe (1,0)
c3 = c1 + c2
print c3 # affiche 1.000000 + 1.000000 i

Il existe de nombreux opérateurs qu’il est possible de définir. La table 5.1 (page 117) présente les plus
utilisés. Parmi ceux-là, on peut s’attarder sur les opérateurs __getitem__ et __setitem__, ils redéfi-
nissent l’opérateur [] permettant d’accéder à un élément d’une liste ou d’un dictionnaire. Le premier,
__getitem__ est utilisé lors d’un calcul, un affichage. Le second, __setitem__, est utilisé pour affecter
une valeur.
L’exemple suivant définit un point de l’espace avec trois coordonnées. Il redéfinit ou surcharge les opérateurs
__getitem__ et __setitem__ de manière à pouvoir accéder aux coordonnées de la classe point_espace
qui définit un point dans l’espace. En règle générale, lorsque les indices ne sont pas corrects, ces deux
opérateurs lèvent l’exception IndexError (voir le chapitre 6).
class point_espace:
def __init__ (self, x,y,z): self._x, self._y, self._z = x,y,z

def __getitem__(self,i):
if i == 0 : return self._x
if i == 1 : return self._y
if i == 2 : return self._z
# pour tous les autres cas --> erreur
raise IndexError ("indice impossible, 0,1,2 autorisés")

def __setitem__(self,i,x):
if i == 0 : self._x = x
elif i == 1 : self._y = y
elif i == 2 : self._z = z
# pour tous les autres cas --> erreur
raise IndexError ("indice impossible, 0,1,2 autorisés")

def __str__(self):
return "(%f,%f,%f)" % (self._x, self._y, self._z)

a = point_espace (1,-2,3)

print a # affiche (1.000000,-2.000000,3.000000)

a [1] = -3 # (__setitem__) affecte -3 à a.y
print "abscisse : ", a [0] # (__getitem__) affiche abscisse : 1
print "ordonnée : ", a [1] # (__getitem__) affiche ordonnée : -3
print "altitude : ", a [2] # (__getitem__) affiche altitude : 3

Par le biais de l’exception IndexError, les expressions a[i] avec i 6= 0, 1, 2 sont impossibles et arrêtent le
programme par un message comme celui qui suit obtenu après l’interprétation de print a [4] :
Traceback (most recent call last):
File "point_espace.py", line 31, in ?
print a [4]
File "point_espace.py", line 13, in __getitem__
raise IndexError, "indice impossible, 0,1,2 autorisés"
IndexError: indice impossible, 0,1,2 autorisés

5.4.2 Itérateurs
L’opérateur __iter__ permet de définir ce qu’on appelle un itérateur. C’est un objet qui permet d’en
explorer un autre, comme une liste ou un dictionnaire. Un itérateur est un objet qui désigne un élément
d’un ensemble à parcourir et qui connaît l’élément suivant à visiter. Il doit pour cela contenir une référence
 5. Classes 92

à l’objet qu’il doit explorer et inclure une méthode next qui retourne l’élément suivant ou lève une exception
si l’élément actuel est le dernier.
Par exemple, on cherche à explorer tous les éléments d’un objet de type point_espace défini au paragraphe
précédent. Cette exploration doit s’effectuer au moyen d’une boucle for.
a = point_espace (1,-2,3)
for x in a:
print x # affiche successivement 1,-2,3

Cette boucle cache en fait l’utilisation d’un itérateur qui apparaît explicitement dans l’exemple suivant
équivalent au précédent (voir paragraphe 4.3.2.3, page 59).
a = point_espace (1,-2,3)
it = iter (a)
while True:
try : print it.next ()
except StopIteration : break

Afin que cet extrait de programme fonctionne, il faut définir un itérateur pour la classe point_espace.
Cet itérateur doit inclure la méthode next. La classe point_espace doit quant à elle définir l’opérateur
__iter__ pour retourner l’itérateur qui permettra de l’explorer.

class point_espace:
def __init__ (self, x,y,z):
self._x, self._y, self._z = x,y,z
def __str__(self):
return "(%f,%f,%f)" % (self._x, self._y, self._z)
def __getitem__(self,i):
if i == 0 : return self._x
if i == 1 : return self._y
if i == 2 : return self._z
# pour tous les autres cas --> erreur
raise IndexError ("indice impossible, 0,1,2 autorisés")

class class_iter:
"""cette classe définit un itérateur pour point_espace"""
def __init__ (self,ins):
"""initialisation, self._ins permet de savoir quelle
instance de point_espace on explore,
self._n mémorise l’indice de l’élément exploré"""
self._n = 0
self._ins = ins

def __iter__ (self) : # le langage impose cette méthode

return self # dans certaines configurations

def next (self):

"""retourne l’élément d’indice self._n et passe à l’élément suivant"""
if self._n <= 2:
v = self._ins [self._n]
self._n += 1
return v
else :
# si cet élément n’existe pas, lève une exception
raise StopIteration

def __iter__(self):
"""opérateur de la classe point_espace, retourne un itérateur
permettant de l’explorer"""
return point_espace.class_iter (self)

a = point_espace (1,-2,3)
for x in a:
print x # affiche successivement 1,-2,3

Cette syntaxe peut paraître fastidieuse mais elle montre de manière explicite le fonctionnement des ité-
rateurs. Cette construction est plus proche de ce que d’autres langages objets proposent. Python offre
néanmoins une syntaxe plus courte avec le mot-clé yield qui permet d’éviter la création de la classe
 5. Classes 93

class_iter. Le code de la méthode __iter__ change mais les dernières lignes du programme précédent
qui affichent successivement les éléments de point_espace sont toujours valides.
class point_espace:
def __init_