frdiveintopython.pdf

(910 KB) Pobierz
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 lintrospection ....................................................................................................................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 à laide dun dictionnaire.......................................................................................84
4.7. Mettre les valeurs dattributs 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:f8dy@diveintopython.org)
Copyright © 2001 Xavier Defrang (mailto:xavier@defrang.com)
Copyright © 2004 Alexandre Drahon (mailto:python@adrahon.org)
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 nest 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 daccueil (http://diveintopython.org/) pour des liens de
téléchargement de Python pour votre système dexploitation favori. Python 2.0 ou une version plus récente
est requis, Python 2.2.1 est recommandé. Lorsquil 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 dexemple
(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 lapprendre 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 dautres
introductions à la programmation en Python (http://www.python.org/doc/Intros.html) pour les non−programmeurs.
Plongeons.
Plongez au coeur de Python
2

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin