Plongez au coeur de Python

Table of Contents
Plongez au coeur de Python............................................................................................................................................1
Preface...................................................................................................................................................................2
Chapter 1. Faire connaissance de Python......................................................................................................................3
1.1. Plonger...........................................................................................................................................................3
1.2. Déclaration de fonctions................................................................................................................................3
1.3. Documentation des fonctions.........................................................................................................................4
1.4. Tout est objet..................................................................................................................................................5
1.5. Indentation du code........................................................................................................................................7
1.6. Test des modules............................................................................................................................................7
1.7. Présentation des dictionnaires........................................................................................................................8
1.8. Présentation des listes..................................................................................................................................11
1.9. Présentation des tuples.................................................................................................................................14
1.10. Définitions de variables.............................................................................................................................16
1.11. Assignation simultanée de plusieurs valeurs.............................................................................................17
1.12. Formatage de chaînes.................................................................................................................................18
1.13. Mutation de listes.......................................................................................................................................19
1.14. Jointure de listes et découpage de chaînes.................................................................................................21
1.15. Résumé.......................................................................................................................................................22
Chapter 2. Le pouvoir de lintrospection ....................................................................................................................24
2.1. Plonger.........................................................................................................................................................24
2.2. Arguments optionnels et nommés................................................................................................................25
2.3. type, str, dir et autres fonctions intégrées....................................................................................................26
2.4. Obtenir des références objet avec getattr.....................................................................................................29
2.5. Filtrage de listes...........................................................................................................................................30
2.6. Particularités de and et or.............................................................................................................................31
2.7. Utiliser des fonctions lambda.......................................................................................................................33
2.8. Assembler les pièces....................................................................................................................................35
2.9. Résumé.........................................................................................................................................................37
Chapter 3. Un framework orienté objet.......................................................................................................................39
3.1. Plonger.........................................................................................................................................................39
3.2. Importation de modules avec from module import......................................................................................41
3.3. Définition de classes....................................................................................................................................42
3.4. Instantiation de classes.................................................................................................................................45
3.5. UserDict : une classe enveloppe..................................................................................................................46
3.6. Méthodes de classe spéciales.......................................................................................................................48
3.7. Méthodes spéciales avancées.......................................................................................................................51
3.8. Attributs de classe........................................................................................................................................52
3.9. Fonctions privées.........................................................................................................................................54
3.10. Traitement des exceptions..........................................................................................................................55
3.11. Les objets fichier........................................................................................................................................57
3.12. Boucles for.................................................................................................................................................60
3.13. Complément sur les modules.....................................................................................................................62
3.14. Le module os..............................................................................................................................................64
3.15. Assembler les pièces..................................................................................................................................67
3.16. Résumé.......................................................................................................................................................68
Plongez au coeur de Python i

Table of Contents
Chapter 4. Traitement du HTML................................................................................................................................71
4.1. Plonger.........................................................................................................................................................71
4.2. Présentation de sgmllib.py...........................................................................................................................75
4.3. Extraction de données de documents HTML...............................................................................................77
4.4. Présentation de BaseHTMLProcessor.py....................................................................................................80
4.5. locals et globals............................................................................................................................................82
4.6. Formatage de chaînes à laide dun dictionnaire.......................................................................................84
4.7. Mettre les valeurs dattributs entre guillemets............................................................................................86
4.8. Présentation de dialect.py............................................................................................................................87
4.9. Introduction aux expressions régulières.......................................................................................................89
4.10. Assembler les pièces..................................................................................................................................91
4.11. Résumé.......................................................................................................................................................93
Chapter 5. XML Processing..........................................................................................................................................95
5.1. Diving in......................................................................................................................................................95
5.2. Packages.....................................................................................................................................................101
5.3. Parsing XML..............................................................................................................................................103
5.4. Unicode......................................................................................................................................................105
5.5. Searching for elements...............................................................................................................................109
5.6. Accessing element attributes......................................................................................................................110
5.7. Abstracting input sources...........................................................................................................................112
5.8. Standard input, output, and error...............................................................................................................115
5.9. Caching node lookups................................................................................................................................118
5.10. Finding direct children of a node.............................................................................................................119
5.11. Creating separate handlers by node type.................................................................................................120
5.12. Handling command line arguments.........................................................................................................122
5.13. Putting it all together................................................................................................................................125
5.14. Summary..................................................................................................................................................126
Chapter 6. Tests unitaires...........................................................................................................................................128
6.1. Plonger.......................................................................................................................................................128
6.2. Présentation de romantest.py.....................................................................................................................129
6.3. Tester la réussite........................................................................................................................................132
6.4. Tester léchec ............................................................................................................................................134
6.5. Tester la cohérence....................................................................................................................................136
6.6. roman.py, étape 1.......................................................................................................................................138
6.7. roman.py, étape 2.......................................................................................................................................141
6.8. roman.py, étape 3.......................................................................................................................................144
6.9. roman.py, étape 4.......................................................................................................................................147
6.10. roman.py, étape 5.....................................................................................................................................150
6.11. Prise en charge des bogues......................................................................................................................154
6.12. Prise en charge des changements de spécifications.................................................................................156
6.13. Refactorisation.........................................................................................................................................162
6.14. Postscriptum.............................................................................................................................................166
6.15. Résumé.....................................................................................................................................................168
Chapter 7. Data−Centric Programming....................................................................................................................169
7.1. Diving in....................................................................................................................................................169
7.2. Finding the path.........................................................................................................................................170
7.3. Filtering lists revisited................................................................................................................................172
Plongez au coeur de Python ii

Table of Contents
Chapter 7. Data−Centric Programming
7.4. Mapping lists revisited...............................................................................................................................174
7.5. Data−centric programming........................................................................................................................175
7.6. Dynamically importing modules................................................................................................................176
Appendix A. Pour en savoir plus................................................................................................................................177
Appendix B. Survol en cinq minutes..........................................................................................................................183
Appendix C. Trucs et astuces......................................................................................................................................193
Appendix D. Liste des exemples..................................................................................................................................200
Appendix E. Historique des révisions........................................................................................................................208
Appendix F. A propos de ce livre................................................................................................................................217
Appendix G. GNU Free Documentation License......................................................................................................218
G.0. Preamble....................................................................................................................................................218
G.1. Applicability and definitions.....................................................................................................................218
G.2. Verbatim copying......................................................................................................................................219
G.3. Copying in quantity...................................................................................................................................219
G.4. Modifications............................................................................................................................................220
G.5. Combining documents..............................................................................................................................221
G.6. Collections of documents..........................................................................................................................221
G.7. Aggregation with independent works.......................................................................................................221
G.8. Translation................................................................................................................................................221
G.9. Termination...............................................................................................................................................222
G.10. Future revisions of this license................................................................................................................222
G.11. How to use this License for your documents..........................................................................................222
Appendix H. Python 2.1.1 license...............................................................................................................................223
H.A. History of the software.............................................................................................................................223
H.B. Terms and conditions for accessing or otherwise using Python..............................................................223
Plongez au coeur de Python iii

Plongez au coeur de Python
11 February 2004
Copyright © 2000, 2001, 2002 Mark Pilgrim (mailto:[email protected])
Copyright © 2001 Xavier Defrang (mailto:[email protected])
Copyright © 2004 Alexandre Drahon (mailto:[email protected])
Les évolutions de cet ouvrage (et de sa traduction française) sont disponibles sur le site http://diveintopython.org/. Si
vous le lisez ailleurs, il est possible que vous ne disposiez pas de la dernière version.
Permission is granted to copy, distribute, and/or modify this document under the terms of the GNU Free
Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no
Invariant Sections, no Front−Cover Texts, and no Back−Cover Texts. A copy of the license is included in
Appendix G, GNU Free Documentation License.
The example programs in this book are free software; you can redistribute and/or modify them under the terms of the
Python license as published by the Python Software Foundation. A copy of the license is included in Appendix H,
Python 2.1.1 license.
Plongez au coeur de Python 1

Preface
Cet ouvrage nest pas pour les débutants, les faiblards ou Pour Les Nuls. Il attend de vous beaucoup de choses.
Vous connaissez au moins un véritable langage orienté objet, tel que Java, C++ ou Delphi.• Vous connaissez au moins un langage de script, tel que Perl, Visual Basic ou JavaScript.• Vous avez déjà installé Python. Voir la page daccueil (http://diveintopython.org/) pour des liens de
téléchargement de Python pour votre système dexploitation favori. Python 2.0 ou une version plus récente
est requis, Python 2.2.1 est recommandé. Lorsquil existe des différences notables entre 2.0 et 2.2.1, elles
sont mentionnées clairement dans le texte.
•
Vous avez téléchargé les programmes dexemple
(http://diveintopython.org/download/diveintopython−examples−4.1.zip) utilisés dans ce livre.
•
Si vous venez à peine de débuter en programmation, cela ne veut pas dire que vous ne pouvez pas apprendre Python.
Python est un langage facile à apprendre, mais vous devrez sans doute lapprendre ailleurs. Je vous recommande
chaudement Learning to Program (http://www.freenetpages.co.uk/hp/alan.gauld/) et How to Think Like a Computer
Scientist (http://www.ibiblio.org/obp/thinkCSpy/), Python.org (http://www.python.org/) a des liens vers dautres
introductions à la programmation en Python (http://www.python.org/doc/Intros.html) pour les non−programmeurs.
Plongeons.
Plongez au coeur de Python 2