Plongez au coeur de Python

Table of Contents
Plongez au coeur de Python............................................................................................................................................1
Chapitre 1. Installation de Python..................................................................................................................................2
1.1. Quel Python vous faut−il ?............................................................................................................................2
1.2. Python sous Windows....................................................................................................................................2
1.3. Python sous Mac OS X..................................................................................................................................3
1.4. Python sous Mac OS 9...................................................................................................................................5
1.5. Python sous RedHat Linux............................................................................................................................5
1.6. Python sous Debian GNU/Linux...................................................................................................................6
1.7. Installation de Python à partir du source........................................................................................................7
1.8. L'interface interactive.....................................................................................................................................7
1.9. Résumé...........................................................................................................................................................8
Chapitre 2. Votre premier programme Python............................................................................................................9
2.1. Plonger...........................................................................................................................................................9
2.2. Déclaration de fonctions..............................................................................................................................10
2.3. Documentation des fonctions.......................................................................................................................11
2.4. Tout est objet................................................................................................................................................11
2.5. Indentation du code......................................................................................................................................13
2.6. Test des modules..........................................................................................................................................14
Chapitre 3. Types prédéfinis.........................................................................................................................................16
3.1. Présentation des dictionnaires......................................................................................................................16
3.2. Présentation des listes..................................................................................................................................18
3.3. Présentation des tuples.................................................................................................................................23
3.4. Définitions de variables...............................................................................................................................24
3.5. Formatage de chaînes...................................................................................................................................26
3.6. Mutation de listes.........................................................................................................................................28
3.7. Jointure de listes et découpage de chaînes...................................................................................................30
3.8. Résumé.........................................................................................................................................................31
Chapitre 4. Le pouvoir de lintrospection ...................................................................................................................33
4.1. Plonger.........................................................................................................................................................33
4.2. Arguments optionnels et nommés................................................................................................................34
4.3. Utilisation de type, str, dir et autres fonction prédéfinies............................................................................35
4.4. Obtenir des références objet avec getattr.....................................................................................................38
4.5. Filtrage de listes...........................................................................................................................................40
4.6. Particularités de and et or.............................................................................................................................42
4.7. Utiliser des fonctions lambda.......................................................................................................................44
4.8. Assembler les pièces....................................................................................................................................45
4.9. Résumé.........................................................................................................................................................48
Chapitre 5. Les objets et l'orienté objet.......................................................................................................................49
5.1. Plonger.........................................................................................................................................................49
5.2. Importation de modules avec from module import......................................................................................51
5.3. Définition de classes....................................................................................................................................52
5.4. Instantiation de classes.................................................................................................................................55
5.5. UserDict : une classe enveloppe..................................................................................................................56
5.6. Méthodes de classe spéciales.......................................................................................................................59
5.7. Méthodes spéciales avancées.......................................................................................................................61
Plongez au coeur de Python i

Table of Contents
Chapitre 5. Les objets et l'orienté objet
5.8. Attributs de classe........................................................................................................................................63
5.9. Fonctions privées.........................................................................................................................................64
5.10. Résumé.......................................................................................................................................................65
Chapitre 6. Traitement des exceptions et utilisation de fichiers................................................................................67
6.1. Traitement des exceptions............................................................................................................................67
6.2. Les objets−fichier.........................................................................................................................................69
6.3. Itérations avec des boucles for.....................................................................................................................73
6.4. Utilisation de sys.modules...........................................................................................................................76
6.5. Travailler avec des répertoires.....................................................................................................................78
6.6. Assembler les pièces....................................................................................................................................81
6.7. Résumé.........................................................................................................................................................82
Chapitre 7. Expressions régulières...............................................................................................................................84
7.1. Plonger.........................................................................................................................................................84
7.2. Exemple : adresses postales.........................................................................................................................84
7.3. Exemple : chiffres romains..........................................................................................................................86
7.4. Utilisation de la syntaxe {n,m}....................................................................................................................88
7.5. Expressions régulières détaillées.................................................................................................................91
7.6. Etude de cas : reconnaissance de numéros de téléphone.............................................................................92
7.7. Résumé.........................................................................................................................................................96
Chapitre 8. Traitement du HTML...............................................................................................................................98
8.1. Plonger.........................................................................................................................................................98
8.2. Présentation de sgmllib.py.........................................................................................................................102
8.3. Extraction de données de documents HTML.............................................................................................104
8.4. Présentation de BaseHTMLProcessor.py..................................................................................................106
8.5. locals et globals..........................................................................................................................................108
8.6. Formatage de chaînes à laide dun dictionnaire.....................................................................................111
8.7. Mettre les valeurs dattributs entre guillemets..........................................................................................113
8.8. Présentation de dialect.py..........................................................................................................................114
8.9. Assembler les pièces..................................................................................................................................116
8.10. Résumé.....................................................................................................................................................118
Chapitre 9. Traitement de données XML..................................................................................................................120
9.1. Plonger.......................................................................................................................................................120
9.2. Les paquetages...........................................................................................................................................126
9.3. Analyser un document XML.....................................................................................................................128
9.4. Le standard Unicode..................................................................................................................................130
9.5. Rechercher des éléments............................................................................................................................134
9.6. Accéder aux attributs d'un élément............................................................................................................136
9.7. Transition...................................................................................................................................................137
Chapitre 10. Des scripts et des flots de données (streams).......................................................................................139
10.1. Extraire les sources de données en entrée................................................................................................139
10.2. Entrée, sortie et erreur standard...............................................................................................................143
10.3. Mettre en cache la consultation de noeuds..............................................................................................146
10.4. Trouver les descendants directs d'un noeud.............................................................................................147
10.5. Créer des gestionnaires distincts pour chaque type de noeud..................................................................148
Plongez au coeur de Python ii

Table of Contents
Chapitre 10. Des scripts et des flots de données (streams)
10.6. Manipuler les arguments de la ligne de commande.................................................................................150
10.7. Assembler les pièces................................................................................................................................153
10.8. Résumé.....................................................................................................................................................155
Chapitre 11. Services Web HTTP..............................................................................................................................156
11.1. Plonger.....................................................................................................................................................156
11.2. Obtenir des données par HTTP : la mauvaise méthode...........................................................................158
11.3. Fonctionnalités de HTTP.........................................................................................................................159
11.4. débogage de services Web HTTP............................................................................................................161
11.5. Changer la chaîne User−Agent................................................................................................................162
11.6. Prise en charge de Last−Modified et ETag..............................................................................................163
11.7. Prise en charge des redirections...............................................................................................................166
11.8. Prise en charge des données compressées...............................................................................................170
11.9. Assembler les pièces................................................................................................................................173
11.10. Résumé...................................................................................................................................................175
Chapitre 12. Services Web SOAP...............................................................................................................................176
12.1. Plonger.....................................................................................................................................................176
12.2. Installation des bibliothèques SOAP.......................................................................................................177
12.3. Premiers pas avec SOAP.........................................................................................................................179
12.4. Débogage de services Web SOAP...........................................................................................................180
12.5. Présentation de WSDL.............................................................................................................................182
12.6. Introspection de services Web SOAP avec WSDL.................................................................................182
12.7. Recherche Google....................................................................................................................................185
12.8. Recherche d'erreurs dans les services Web SOAP..................................................................................187
12.9. Résumé.....................................................................................................................................................190
Chapitre 13. Tests unitaires........................................................................................................................................192
13.1. Introduction au chiffres romains..............................................................................................................192
13.2. Présentation de romantest.py...................................................................................................................193
13.3. Présentation de romantest.py...................................................................................................................193
13.4. Tester la réussite......................................................................................................................................196
13.5. Tester léchec ..........................................................................................................................................198
13.6. Tester la cohérence..................................................................................................................................200
Chapitre 14. Ecriture des tests en premier................................................................................................................202
14.1. roman.py, étape 1.....................................................................................................................................202
14.2. roman.py, étape 2.....................................................................................................................................205
14.3. roman.py, étape 3.....................................................................................................................................209
14.4. roman.py, étape 4.....................................................................................................................................212
14.5. roman.py, étape 5.....................................................................................................................................214
Chapitre 15. Refactorisation.......................................................................................................................................217
15.1. Gestion des bogues..................................................................................................................................217
15.2. Gestion des changements de spécification...............................................................................................219
15.3. Refactorisation.........................................................................................................................................225
15.4. Postscriptum.............................................................................................................................................229
15.5. Résumé.....................................................................................................................................................231
Plongez au coeur de Python iii

Table of Contents
Chapitre 16. Programmation fonctionnelle...............................................................................................................232
16.1. Plonger.....................................................................................................................................................232
16.2. Trouver le chemin....................................................................................................................................233
16.3. Le filtrage de liste revisité........................................................................................................................236
16.4. La mutation de liste revisitée...................................................................................................................237
16.5. Programmation centrée sur les données...................................................................................................238
16.6. Importation dynamique de modules.........................................................................................................239
16.7. Assembler les pièces................................................................................................................................241
16.8. Résumé.....................................................................................................................................................243
Chapitre 17. Fonctions dynamiques...........................................................................................................................244
17.1. Plonger.....................................................................................................................................................244
17.2. plural.py, étape 1......................................................................................................................................244
17.3. plural.py, étape 2......................................................................................................................................246
17.4. plural.py, étape 3......................................................................................................................................248
17.5. plural.py, étape 4......................................................................................................................................249
17.6. plural.py, étape 5......................................................................................................................................251
17.7. plural.py, étape 6......................................................................................................................................253
17.8. Résumé.....................................................................................................................................................255
Chapitre 18. Ajustements des performances.............................................................................................................257
18.1. Plonger.....................................................................................................................................................257
18.2. Utilisation du module timeit....................................................................................................................259
18.3. Optimisation d'expressions régulières......................................................................................................260
18.4. Optimisation de la lecture d'un dictionnaire............................................................................................264
18.5. Optimisation des opérations sur les listes................................................................................................266
18.6. Optimisation des manipulations de chaînes.............................................................................................268
18.7. Résumé.....................................................................................................................................................270
Annexe A. Pour en savoir plus....................................................................................................................................271
Annexe B. Survol en cinq minutes..............................................................................................................................278
Annexe C. Trucs et astuces..........................................................................................................................................293
Annexe D. Liste des exemples.....................................................................................................................................301
Annexe E. Historique des révisions............................................................................................................................314
Annexe F. A propos de ce livre...................................................................................................................................326
Annexe G. GNU Free Documentation License..........................................................................................................327
G.0. Preamble....................................................................................................................................................327
G.1. Applicability and definitions.....................................................................................................................327
G.2. Verbatim copying......................................................................................................................................328
G.3. Copying in quantity...................................................................................................................................328
G.4. Modifications............................................................................................................................................329
G.5. Combining documents..............................................................................................................................330
G.6. Collections of documents..........................................................................................................................330
G.7. Aggregation with independent works.......................................................................................................330
Plongez au coeur de Python iv

Table of Contents
Annexe G. GNU Free Documentation License
G.8. Translation................................................................................................................................................330
G.9. Termination...............................................................................................................................................331
G.10. Future revisions of this license................................................................................................................331
G.11. How to use this License for your documents..........................................................................................331
Annexe H. Python license............................................................................................................................................332
H.A. History of the software.............................................................................................................................332
H.B. Terms and conditions for accessing or otherwise using Python..............................................................332
Plongez au coeur de Python v