Dive Into Python

Python from novice to pro

Mark Pilgrim
Dive Into Python: Python from novice to pro
by Mark Pilgrim

Published 20 May 2004

Copyright © 2000, 2001, 2002, 2003, 2004 Mark Pilgrim [mailto:[email protected]]

This book lives at http://diveintopython.org/. If you're reading it somewhere else, you may not have the
latest 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 license.
Table of Contents
1. Chapter 1 ........................................................................................................................ 1
Which Python is right for you? ....................................................................................... 1
Python on Windows ..................................................................................................... 1
Python on Mac OS X ................................................................................................... 3
Python on Mac OS 9 .................................................................................................... 4
Python on RedHat Linux ............................................................................................... 5
Python on Debian GNU/Linux ....................................................................................... 6
Python Installation from Source ..................................................................................... 7
The Interactive Shell .................................................................................................... 8
Summary ................................................................................................................... 9
2. Chapter 2 ...................................................................................................................... 10
Diving in .................................................................................................................. 10
Declaring Functions ................................................................................................... 11
How Python's Datatypes Compare to Other Programming Languages .......................... 11
Documenting Functions .............................................................................................. 12
Everything Is an Object ............................................................................................... 13
The Import Search Path ....................................................................................... 13
What's an Object? .............................................................................................. 14
Indenting Code .......................................................................................................... 15
Testing Modules ........................................................................................................ 16
3. Chapter 3 ...................................................................................................................... 18
Introducing Dictionaries .............................................................................................. 18
Defining Dictionaries .......................................................................................... 18
Modifying Dictionaries ....................................................................................... 19
Deleting Items From Dictionaries .......................................................................... 20
Introducing Lists ........................................................................................................ 21
Defining Lists ................................................................................................... 21
Adding Elements to Lists ..................................................................................... 23
Searching Lists .................................................................................................. 25
Deleting List Elements ........................................................................................ 26
Using List Operators ........................................................................................... 27
Introducing Tuples ..................................................................................................... 27
Declaring variables ..................................................................................................... 29
Referencing Variables ......................................................................................... 30
Assigning Multiple Values at Once ........................................................................ 30
Formatting Strings ..................................................................................................... 31
Mapping Lists ........................................................................................................... 33
Joining Lists and Splitting Strings ................................................................................. 35
Historical Note on String Methods ........................................................................ 36
Summary .................................................................................................................. 36
4. Chapter 4 ...................................................................................................................... 38
Diving In .................................................................................................................. 38
Using Optional and Named Arguments ........................................................................... 39
Using type, str, dir, and Other Built-In Functions .............................................................. 40
The type Function .............................................................................................. 40
The str Function ................................................................................................ 41
Built-In Functions .............................................................................................. 43
Getting Object References With getattr ........................................................................... 44
getattr with Modules ........................................................................................... 45
getattr As a Dispatcher ........................................................................................ 46
Filtering Lists ............................................................................................................ 47

iii
 Dive Into Python

The Peculiar Nature of and and or ................................................................................. 49

Using the and-or Trick ........................................................................................ 50
Using lambda Functions .............................................................................................. 51
Real-World lambda Functions .............................................................................. 51
Putting It All Together ................................................................................................. 53
Summary .................................................................................................................. 55
5. Chapter 5 ...................................................................................................................... 57
Diving In .................................................................................................................. 57
Importing Modules Using from module import ................................................................ 60
Defining Classes ........................................................................................................ 61
Initializing and Coding Classes ............................................................................. 63
Knowing When to Use self and __init__ ................................................................. 64
Instantiating Classes ................................................................................................... 65
Garbage Collection ............................................................................................ 65
Exploring UserDict: A Wrapper Class ............................................................................ 66
Special Class Methods ................................................................................................ 69
Getting and Setting Items .................................................................................... 70
Advanced Special Class Methods .................................................................................. 72
Introducing Class Attributes ......................................................................................... 74
Private Functions ....................................................................................................... 76
Summary .................................................................................................................. 77
6. Chapter 6 ...................................................................................................................... 79
Handling Exceptions .................................................................................................. 79
Using Exceptions For Other Purposes .................................................................... 80
Working with File Objects ........................................................................................... 82
Reading Files .................................................................................................... 82
Closing Files ..................................................................................................... 83
Handling I/O Errors ............................................................................................ 84
Writing to Files ................................................................................................. 85
Iterating with for Loops ............................................................................................... 86
Using sys.modules ..................................................................................................... 89
Working with Directories ............................................................................................. 92
Putting It All Together ................................................................................................. 97
Summary .................................................................................................................. 99
7. Chapter 7 .................................................................................................................... 101
Diving In ................................................................................................................ 101
Case Study: Street Addresses ...................................................................................... 101
Case Study: Roman Numerals ..................................................................................... 103
Checking for Thousands .................................................................................... 104
Checking for Hundreds ...................................................................................... 105
Using the {n,m} Syntax ............................................................................................. 107
Checking for Tens and Ones ............................................................................... 109
Verbose Regular Expressions ...................................................................................... 110
Case study: Parsing Phone Numbers ............................................................................ 111
Summary ................................................................................................................ 116
8. Chapter 8 .................................................................................................................... 118
Diving in ................................................................................................................ 118
Introducing sgmllib.py .............................................................................................. 124
Extracting data from HTML documents ........................................................................ 127
Introducing BaseHTMLProcessor.py ............................................................................ 129
locals and globals ..................................................................................................... 132
Dictionary-based string formatting ............................................................................... 136
Quoting attribute values ............................................................................................. 138
Introducing dialect.py ............................................................................................... 139

iv
 Dive Into Python

Putting it all together ................................................................................................. 142

Summary ................................................................................................................ 144
9. Chapter 9 .................................................................................................................... 146
Diving in ................................................................................................................ 146
Packages ................................................................................................................ 154
Parsing XML ........................................................................................................... 156
Unicode .................................................................................................................. 159
Searching for elements .............................................................................................. 164
Accessing element attributes ....................................................................................... 165
Segue ..................................................................................................................... 167
10. Chapter 10 ................................................................................................................. 168
Abstracting input sources ........................................................................................... 168
Standard input, output, and error ................................................................................. 173
Caching node lookups ............................................................................................... 177
Finding direct children of a node ................................................................................. 178
Creating separate handlers by node type ....................................................................... 179
Handling command-line arguments .............................................................................. 181
Putting it all together ................................................................................................. 185
Summary ................................................................................................................ 187
11. Chapter 11 ................................................................................................................. 188
Diving in ................................................................................................................ 188
How not to fetch data over HTTP ................................................................................ 191
Features of HTTP ..................................................................................................... 191
User-Agent ..................................................................................................... 191
Redirects ........................................................................................................ 192
Last-Modified/If-Modified-Since ......................................................................... 192
ETag/If-None-Match ......................................................................................... 193
Compression ................................................................................................... 193
Debugging HTTP web services ................................................................................... 193
Setting the User-Agent .............................................................................................. 195
Handling Last-Modified and ETag ............................................................................... 196
Handling redirects .................................................................................................... 199
Handling compressed data ......................................................................................... 205
Putting it all together ................................................................................................. 207
Summary ................................................................................................................ 210
12. Chapter 12 ................................................................................................................. 211
Diving In ................................................................................................................ 211
Installing the SOAP Libraries ..................................................................................... 212
Installing PyXML ............................................................................................ 213
Installing fpconst .............................................................................................. 213
Installing SOAPpy ............................................................................................ 214
First Steps with SOAP ............................................................................................... 214
Debugging SOAP Web Services .................................................................................. 215
Introducing WSDL ................................................................................................... 217
Introspecting SOAP Web Services with WSDL .............................................................. 218
Searching Google ..................................................................................................... 222
Troubleshooting SOAP Web Services ........................................................................... 225
Summary ................................................................................................................ 230
13. Chapter 13 ................................................................................................................. 231
Introduction to Roman numerals ................................................................................. 231
Diving in ................................................................................................................ 232
Introducing romantest.py ........................................................................................... 232
Testing for success .................................................................................................... 236
Testing for failure ..................................................................................................... 238

v
 Dive Into Python

Testing for sanity ...................................................................................................... 240

14. Chapter 14 ................................................................................................................. 243
roman.py, stage 1 ..................................................................................................... 243
roman.py, stage 2 ..................................................................................................... 246
roman.py, stage 3 ..................................................................................................... 251
roman.py, stage 4 ..................................................................................................... 255
roman.py, stage 5 ..................................................................................................... 259
15. Chapter 15 ................................................................................................................. 263
Handling bugs ......................................................................................................... 263
Handling changing requirements ................................................................................. 265
Refactoring ............................................................................................................. 274
Postscript ................................................................................................................ 278
Summary ................................................................................................................ 281
16. Chapter 16 ................................................................................................................. 283
Diving in ................................................................................................................ 283
Finding the path ....................................................................................................... 284
Filtering lists revisited ............................................................................................... 287
Mapping lists revisited .............................................................................................. 289
Data-centric programming ......................................................................................... 290
Dynamically importing modules .................................................................................. 291
Putting it all together ................................................................................................. 293
Summary ................................................................................................................ 296
17. Chapter 17 ................................................................................................................. 297
Diving in ................................................................................................................ 297
plural.py, stage 1 ...................................................................................................... 297
plural.py, stage 2 ...................................................................................................... 300
plural.py, stage 3 ...................................................................................................... 302
plural.py, stage 4 ...................................................................................................... 303
plural.py, stage 5 ...................................................................................................... 306
plural.py, stage 6 ...................................................................................................... 307
Summary ................................................................................................................ 311
18. Chapter 18 ................................................................................................................. 313
Diving in ................................................................................................................ 313
Using the timeit Module ............................................................................................ 316
Optimizing Regular Expressions ................................................................................. 318
Optimizing Dictionary Lookups .................................................................................. 322
Optimizing List Operations ........................................................................................ 325
Optimizing String Manipulation .................................................................................. 328
Summary ................................................................................................................ 330
A. Further reading ............................................................................................................ 331
B. A 5-minute review ........................................................................................................ 332
C. Tips and tricks ............................................................................................................. 333
D. List of examples ........................................................................................................... 334
E. Revision history ........................................................................................................... 335
F. About the book ............................................................................................................. 336
G. GNU Free Documentation License .................................................................................. 337
0. Preamble ............................................................................................................. 337
1. Applicability and definitions ................................................................................... 337
2. Verbatim copying .................................................................................................. 338
3. Copying in quantity ............................................................................................... 338
4. Modifications ....................................................................................................... 339
5. Combining documents ........................................................................................... 340
6. Collections of documents ....................................................................................... 340
7. Aggregation with independent works ........................................................................ 340

vi
 Dive Into Python

8. Translation .......................................................................................................... 341

9. Termination ......................................................................................................... 341
10. Future revisions of this license ............................................................................... 341
11. How to use this License for your documents ............................................................. 341
H. Python license ............................................................................................................. 343
A. History of the software .......................................................................................... 343
B. Terms and conditions for accessing or otherwise using Python ...................................... 343
B.. PSF license agreement .................................................................................. 343
B.. BeOpen Python open source license agreement version 1 .................................... 344
B.. CNRI open source GPL-compatible license agreement ....................................... 345
B.. CWI permissions statement and disclaimer ....................................................... 346

vii
List of Examples
1.1. Two versions of Python ................................................................................................... 4
1.2. Installing on RedHat Linux 9 ........................................................................................... 6
1.3. Installing on Debian GNU/Linux ...................................................................................... 7
1.4. Installing from source ..................................................................................................... 8
1.5. First Steps in the Interactive Shell ..................................................................................... 9
2.1. odbchelper.py .............................................................................................................. 10
2.2. Defining the buildConnectionString Function's doc string .................................................... 12
2.3. Accessing the buildConnectionString Function's doc string .................................................. 13
2.4. Import Search Path ....................................................................................................... 14
2.5. Indenting the buildConnectionString Function ................................................................... 15
2.6. if Statements ............................................................................................................... 15
3.1. Defining a Dictionary ................................................................................................... 18
3.2. Modifying a Dictionary ................................................................................................. 19
3.3. Dictionary Keys Are Case-Sensitive ................................................................................. 19
3.4. Mixing Datatypes in a Dictionary .................................................................................... 20
3.5. Deleting Items from a Dictionary .................................................................................... 20
3.6. Defining a List ............................................................................................................. 21
3.7. Negative List Indices .................................................................................................... 21
3.8. Slicing a List ............................................................................................................... 22
3.9. Slicing Shorthand ......................................................................................................... 22
3.10. Adding Elements to a List ............................................................................................ 23
3.11. The Difference between extend and append ..................................................................... 24
3.12. Searching a List ......................................................................................................... 25
3.13. Removing Elements from a List .................................................................................... 26
3.14. List Operators ............................................................................................................ 27
3.15. Defining a tuple ......................................................................................................... 28
3.16. Tuples Have No Methods ............................................................................................. 28
3.17. Defining the myParams Variable .................................................................................... 29
3.18. Referencing an Unbound Variable .................................................................................. 30
3.19. Assigning multiple values at once .................................................................................. 30
3.20. Assigning Consecutive Values ....................................................................................... 31
3.21. Introducing String Formatting ....................................................................................... 32
3.22. String Formatting vs. Concatenating ............................................................................... 32
3.23. Formatting Numbers ................................................................................................... 33
3.24. Introducing List Comprehensions .................................................................................. 33
3.25. The keys, values, and items Functions ............................................................................ 34
3.26. List Comprehensions in buildConnectionString, Step by Step ............................................. 34
3.27. Output of odbchelper.py ............................................................................................... 35
3.28. Splitting a String ........................................................................................................ 36
4.1. apihelper.py ................................................................................................................ 38
4.2. Sample Usage of apihelper.py ......................................................................................... 39
4.3. Advanced Usage of apihelper.py ..................................................................................... 39
4.4. Valid Calls of info ........................................................................................................ 40
4.5. Introducing type ........................................................................................................... 41
4.6. Introducing str ............................................................................................................. 41
4.7. Introducing dir ............................................................................................................. 42
4.8. Introducing callable ...................................................................................................... 43
4.9. Built-in Attributes and Functions ..................................................................................... 44
4.10. Introducing getattr ...................................................................................................... 45
4.11. The getattr Function in apihelper.py ............................................................................... 46
4.12. Creating a Dispatcher with getattr .................................................................................. 46

viii
 Dive Into Python

4.13. getattr Default Values .................................................................................................. 47

4.14. Introducing List Filtering ............................................................................................. 48
4.15. Introducing and .......................................................................................................... 49
4.16. Introducing or ............................................................................................................ 49
4.17. Introducing the and-or Trick ......................................................................................... 50
4.18. When the and-or Trick Fails .......................................................................................... 50
4.19. Using the and-or Trick Safely ....................................................................................... 50
4.20. Introducing lambda Functions ....................................................................................... 51
4.21. split With No Arguments .............................................................................................. 52
4.22. Getting a doc string Dynamically ................................................................................... 53
4.23. Why Use str on a doc string? ........................................................................................ 54
4.24. Introducing ljust ......................................................................................................... 54
4.25. Printing a List ............................................................................................................ 55
5.1. fileinfo.py ................................................................................................................... 58
5.2. import module vs. from module import ............................................................................ 61
5.3. The Simplest Python Class ............................................................................................. 62
5.4. Defining the FileInfo Class ............................................................................................ 62
5.5. Initializing the FileInfo Class .......................................................................................... 63
5.6. Coding the FileInfo Class .............................................................................................. 64
5.7. Creating a FileInfo Instance ........................................................................................... 65
5.8. Trying to Implement a Memory Leak ............................................................................... 66
5.9. Defining the UserDict Class ........................................................................................... 67
5.10. UserDict Normal Methods ........................................................................................... 68
5.11. Inheriting Directly from Built-In Datatype dict ................................................................. 69
5.12. The __getitem__ Special Method ................................................................................... 70
5.13. The __setitem__ Special Method ................................................................................... 70
5.14. Overriding __setitem__ in MP3FileInfo .......................................................................... 71
5.15. Setting an MP3FileInfo's name ...................................................................................... 72
5.16. More Special Methods in UserDict ................................................................................ 73
5.17. Introducing Class Attributes ......................................................................................... 75
5.18. Modifying Class Attributes ........................................................................................... 76
5.19. Trying to Call a Private Method ..................................................................................... 77
6.1. Opening a Non-Existent File .......................................................................................... 80
6.2. Supporting Platform-Specific Functionality ....................................................................... 81
6.3. Opening a File ............................................................................................................. 82
6.4. Reading a File ............................................................................................................. 83
6.5. Closing a File .............................................................................................................. 84
6.6. File Objects in MP3FileInfo ........................................................................................... 85
6.7. Writing to Files ............................................................................................................ 86
6.8. Introducing the for Loop ................................................................................................ 87
6.9. Simple Counters .......................................................................................................... 87
6.10. Iterating Through a Dictionary ...................................................................................... 88
6.11. for Loop in MP3FileInfo .............................................................................................. 89
6.12. Introducing sys.modules .............................................................................................. 90
6.13. Using sys.modules ...................................................................................................... 91
6.14. The __module__ Class Attribute .................................................................................... 91
6.15. sys.modules in fileinfo.py ............................................................................................ 92
6.16. Constructing Pathnames ............................................................................................... 93
6.17. Splitting Pathnames .................................................................................................... 94
6.18. Listing Directories ...................................................................................................... 95
6.19. Listing Directories in fileinfo.py .................................................................................... 96
6.20. Listing Directories with glob ........................................................................................ 97
6.21. listDirectory .............................................................................................................. 98
7.1. Matching at the End of a String ..................................................................................... 102

ix
 Dive Into Python

7.2. Matching Whole Words ............................................................................................... 103

7.3. Checking for Thousands .............................................................................................. 105
7.4. Checking for Hundreds ................................................................................................ 107
7.5. The Old Way: Every Character Optional ......................................................................... 108
7.6. The New Way: From n o m ........................................................................................... 108
7.7. Checking for Tens ...................................................................................................... 109
7.8. Validating Roman Numerals with {n,m} ......................................................................... 110
7.9. Regular Expressions with Inline Comments ..................................................................... 111
7.10. Finding Numbers ...................................................................................................... 112
7.11. Finding the Extension ................................................................................................ 113
7.12. Handling Different Separators ..................................................................................... 113
7.13. Handling Numbers Without Separators ......................................................................... 114
7.14. Handling Leading Characters ...................................................................................... 115
7.15. Phone Number, Wherever I May Find Ye ....................................................................... 115
7.16. Parsing Phone Numbers (Final Version) ........................................................................ 116
8.1. BaseHTMLProcessor.py .............................................................................................. 119
8.2. dialect.py .................................................................................................................. 121
8.3. Output of dialect.py .................................................................................................... 124
8.4. Sample test of sgmllib.py ............................................................................................. 126
8.5. Introducing urllib ....................................................................................................... 127
8.6. Introducing urllister.py ................................................................................................ 128
8.7. Using urllister.py ........................................................................................................ 129
8.8. Introducing BaseHTMLProcessor .................................................................................. 131
8.9. BaseHTMLProcessor output ......................................................................................... 132
8.10. Introducing locals ..................................................................................................... 134
8.11. Introducing globals ................................................................................................... 135
8.12. locals is read-only, globals is not .................................................................................. 136
8.13. Introducing dictionary-based string formatting ............................................................... 137
8.14. Dictionary-based string formatting in BaseHTMLProcessor.py .......................................... 137
8.15. More dictionary-based string formatting ........................................................................ 138
8.16. Quoting attribute values ............................................................................................. 139
8.17. Handling specific tags ................................................................................................ 140
8.18. SGMLParser ............................................................................................................ 141
8.19. Overriding the handle_data method .............................................................................. 142
8.20. The translate function, part 1 ....................................................................................... 143
8.21. The translate function, part 2: curiouser and curiouser ...................................................... 143
8.22. The translate function, part 3 ....................................................................................... 144
9.1. kgp.py ...................................................................................................................... 147
9.2. toolbox.py ................................................................................................................. 152
9.3. Sample output of kgp.py .............................................................................................. 153
9.4. Simpler output from kgp.py .......................................................................................... 154
9.5. Loading an XML document (a sneak peek) ...................................................................... 154
9.6. File layout of a package ............................................................................................... 154
9.7. Packages are modules, too ............................................................................................ 155
9.8. Loading an XML document (for real this time) ................................................................. 156
9.9. Getting child nodes ..................................................................................................... 157
9.10. toxml works on any node ............................................................................................ 157
9.11. Child nodes can be text .............................................................................................. 158
9.12. Drilling down all the way to text .................................................................................. 159
9.13. Introducing unicode .................................................................................................. 160
9.14. Storing non-ASCII characters ...................................................................................... 161
9.15. sitecustomize.py ....................................................................................................... 161
9.16. Effects of setting the default encoding ........................................................................... 162
9.17. Specifying encoding in .py files ................................................................................... 162

x
 Dive Into Python

9.18. russiansample.xml .................................................................................................... 162

9.19. Parsing russiansample.xml .......................................................................................... 163
9.20. binary.xml ............................................................................................................... 164
9.21. Introducing getElementsByTagName ............................................................................ 164
9.22. Every element is searchable ........................................................................................ 165
9.23. Searching is actually recursive ..................................................................................... 165
9.24. Accessing element attributes ....................................................................................... 166
9.25. Accessing individual attributes .................................................................................... 167
10.1. Parsing XML from a file ............................................................................................ 168
10.2. Parsing XML from a URL .......................................................................................... 169
10.3. Parsing XML from a string (the easy but inflexible way) .................................................. 170
10.4. Introducing StringIO ................................................................................................. 170
10.5. Parsing XML from a string (the file-like object way) ....................................................... 171
10.6. openAnything .......................................................................................................... 172
10.7. Using openAnything in kgp.py .................................................................................... 172
10.8. Introducing stdout and stderr ....................................................................................... 173
10.9. Redirecting output .................................................................................................... 174
10.10. Redirecting error information .................................................................................... 175
10.11. Printing to stderr ..................................................................................................... 175
10.12. Chaining commands ................................................................................................ 176
10.13. Reading from standard input in kgp.py ........................................................................ 177
10.14. loadGrammar ......................................................................................................... 178
10.15. Using the ref element cache ...................................................................................... 178
10.16. Finding direct child elements ..................................................................................... 179
10.17. Class names of parsed XML objects ........................................................................... 180
10.18. parse, a generic XML node dispatcher ......................................................................... 180
10.19. Functions called by the parse dispatcher ...................................................................... 181
10.20. Introducing sys.argv ................................................................................................ 182
10.21. The contents of sys.argv ........................................................................................... 182
10.22. Introducing getopt ................................................................................................... 183
10.23. Handling command-line arguments in kgp.py ............................................................... 185
11.1. openanything.py ....................................................................................................... 189
11.2. Downloading a feed the quick-and-dirty way .................................................................. 191
11.3. Debugging HTTP ..................................................................................................... 194
11.4. Introducing urllib2 .................................................................................................... 195
11.5. Adding headers with the Request ................................................................................. 196
11.6. Testing Last-Modified ................................................................................................ 197
11.7. Defining URL handlers .............................................................................................. 198
11.8. Using custom URL handlers ....................................................................................... 198
11.9. Supporting ETag/If-None-Match .................................................................................. 199
11.10. Accessing web services without a redirect handler ......................................................... 200
11.11. Defining the redirect handler ..................................................................................... 201
11.12. Using the redirect handler to detect permanent redirects .................................................. 202
11.13. Using the redirect handler to detect temporary redirects .................................................. 204
11.14. Telling the server you would like compressed data ......................................................... 205
11.15. Decompressing the data ............................................................................................ 206
11.16. Decompressing the data directly from the server ........................................................... 207
11.17. The openanything function ........................................................................................ 208
11.18. The fetch function ................................................................................................... 209
11.19. Using openanything.py ............................................................................................. 210
12.1. search.py ................................................................................................................. 211
12.2. Sample Usage of search.py ......................................................................................... 212
12.3. Verifying PyXML Installation ..................................................................................... 213
12.4. Verifying fpconst Installation ...................................................................................... 214

xi
 Dive Into Python

12.5. Verifying SOAPpy Installation ..................................................................................... 214

12.6. Getting the Current Temperature .................................................................................. 215
12.7. Debugging SOAP Web Services .................................................................................. 216
12.8. Discovering The Available Methods ............................................................................. 219
12.9. Discovering A Method's Arguments .............................................................................. 219
12.10. Discovering A Method's Return Values ........................................................................ 220
12.11. Calling A Web Service Through A WSDL Proxy ........................................................... 221
12.12. Introspecting Google Web Services ............................................................................. 223
12.13. Searching Google .................................................................................................... 224
12.14. Accessing Secondary Information From Google ............................................................ 225
12.15. Calling a Method With an Incorrectly Configured Proxy ................................................. 226
12.16. Calling a Method With the Wrong Arguments ............................................................... 227
12.17. Calling a Method and Expecting the Wrong Number of Return Values ............................... 227
12.18. Calling a Method With An Application-Specific Error .................................................... 229
13.1. romantest.py ............................................................................................................ 233
13.2. testToRomanKnownValues ......................................................................................... 237
13.3. Testing bad input to toRoman ...................................................................................... 239
13.4. Testing bad input to fromRoman .................................................................................. 240
13.5. Testing toRoman against fromRoman ........................................................................... 241
13.6. Testing for case ........................................................................................................ 242
14.1. roman1.py ............................................................................................................... 243
14.2. Output of romantest1.py against roman1.py ................................................................... 244
14.3. roman2.py ............................................................................................................... 247
14.4. How toRoman works ................................................................................................. 248
14.5. Output of romantest2.py against roman2.py ................................................................... 249
14.6. roman3.py ............................................................................................................... 252
14.7. Watching toRoman handle bad input ............................................................................. 253
14.8. Output of romantest3.py against roman3.py ................................................................... 254
14.9. roman4.py ............................................................................................................... 256
14.10. How fromRoman works ........................................................................................... 257
14.11. Output of romantest4.py against roman4.py .................................................................. 258
14.12. roman5.py ............................................................................................................. 260
14.13. Output of romantest5.py against roman5.py .................................................................. 261
15.1. The bug .................................................................................................................. 263
15.2. Testing for the bug (romantest61.py) ............................................................................. 263
15.3. Output of romantest61.py against roman61.py ................................................................ 264
15.4. Fixing the bug (roman62.py) ....................................................................................... 264
15.5. Output of romantest62.py against roman62.py ................................................................ 265
15.6. Modifying test cases for new requirements (romantest71.py) ............................................. 266
15.7. Output of romantest71.py against roman71.py ................................................................ 270
15.8. Coding the new requirements (roman72.py) ................................................................... 272
15.9. Output of romantest72.py against roman72.py ................................................................ 273
15.10. Compiling regular expressions ................................................................................... 274
15.11. Compiled regular expressions in roman81.py ................................................................ 275
15.12. Output of romantest81.py against roman81.py .............................................................. 276
15.13. roman82.py ............................................................................................................ 276
15.14. Output of romantest82.py against roman82.py .............................................................. 277
15.15. roman83.py ............................................................................................................ 278
15.16. Output of romantest83.py against roman83.py .............................................................. 278
15.17. roman9.py ............................................................................................................. 280
15.18. Output of romantest9.py against roman9.py .................................................................. 281
16.1. regression.py ............................................................................................................ 283
16.2. Sample output of regression.py .................................................................................... 284
16.3. fullpath.py ............................................................................................................... 285

xii
 Dive Into Python

16.4. Further explanation of os.path.abspath .......................................................................... 285

16.5. Sample output from fullpath.py ................................................................................... 286
16.6. Running scripts in the current directory ......................................................................... 287
16.7. Introducing filter ....................................................................................................... 288
16.8. filter in regression.py ................................................................................................. 288
16.9. Filtering using list comprehensions instead .................................................................... 289
16.10. Introducing map ...................................................................................................... 289
16.11. map with lists of mixed datatypes ............................................................................... 290
16.12. map in regression.py ................................................................................................ 290
16.13. Importing multiple modules at once ............................................................................ 291
16.14. Importing modules dynamically ................................................................................. 292
16.15. Importing a list of modules dynamically ...................................................................... 292
16.16. The regressionTest function ....................................................................................... 293
16.17. Step 1: Get all the files ............................................................................................. 293
16.18. Step 2: Filter to find the files you care about ................................................................. 294
16.19. Step 3: Map filenames to module names ...................................................................... 294
16.20. Step 4: Mapping module names to modules .................................................................. 295
16.21. Step 5: Loading the modules into a test suite ................................................................ 295
16.22. Step 6: Telling unittest to use your test suite ................................................................. 296
17.1. plural1.py ................................................................................................................ 298
17.2. Introducing re.sub ..................................................................................................... 298
17.3. Back to plural1.py ..................................................................................................... 299
17.4. More on negation regular expressions ........................................................................... 299
17.5. More on re.sub ......................................................................................................... 300
17.6. plural2.py ................................................................................................................ 301
17.7. Unrolling the plural function ....................................................................................... 302
17.8. plural3.py ................................................................................................................ 303
17.9. plural4.py ................................................................................................................ 304
17.10. plural4.py continued ................................................................................................ 304
17.11. Unrolling the rules definition ..................................................................................... 305
17.12. plural4.py, finishing up ............................................................................................. 305
17.13. Another look at buildMatchAndApplyFunctions ............................................................ 305
17.14. Expanding tuples when calling functions ..................................................................... 306
17.15. rules.en ................................................................................................................. 306
17.16. plural5.py .............................................................................................................. 307
17.17. plural6.py .............................................................................................................. 308
17.18. Introducing generators ............................................................................................. 309
17.19. Using generators instead of recursion .......................................................................... 310
17.20. Generators in for loops ............................................................................................. 310
17.21. Generators that generate dynamic functions .................................................................. 311
18.1. soundex/stage1/soundex1a.py ...................................................................................... 315
18.2. Introducing timeit ..................................................................................................... 317
18.3. Best Result So Far: soundex/stage1/soundex1e.py ........................................................... 321
18.4. Best Result So Far: soundex/stage2/soundex2c.py ........................................................... 325
18.5. Best Result So Far: soundex/stage2/soundex2c.py ........................................................... 328

xiii
Chapter 1. Installing Python
Welcome to Python. Let's dive in. In this chapter, you'll install the version of Python that's right for you.

Which Python is right for you?

The first thing you need to do with Python is install it. Or do you?

If you're using an account on a hosted server, your ISP may have already installed Python. Most popular
Linux distributions come with Python in the default installation. Mac OS X 10.2 and later includes a
command-line version of Python, although you'll probably want to install a version that includes a more
Mac-like graphical interface.

Windows does not come with any version of Python, but don't despair! There are several ways to point-
and-click your way to Python on Windows.

As you can see already, Python runs on a great many operating systems. The full list includes Windows,
Mac OS, Mac OS X, and all varieties of free UNIX-compatible systems like Linux. There are also versions
that run on Sun Solaris, AS/400, Amiga, OS/2, BeOS, and a plethora of other platforms you've probably
never even heard of.

What's more, Python programs written on one platform can, with a little care, run on any supported platform.
For instance, I regularly develop Python programs on Windows and later deploy them on Linux.

So back to the question that started this section, “Which Python is right for you?” The answer is whichever
one runs on the computer you already have.

Python on Windows
On Windows, you have a couple choices for installing Python.

ActiveState makes a Windows installer for Python called ActivePython, which includes a complete version
of Python, an IDE with a Python-aware code editor, plus some Windows extensions for Python that allow
complete access to Windows-specific services, APIs, and the Windows Registry.

ActivePython is freely downloadable, although it is not open source. It is the IDE I used to learn Python,
and I recommend you try it unless you have a specific reason not to. One such reason might be that Act-
iveState is generally several months behind in updating their ActivePython installer when new version of
Python are released. If you absolutely need the latest version of Python and ActivePython is still a version
behind as you read this, you'll want to use the second option for installing Python on Windows.

The second option is the “official” Python installer, distributed by the people who develop Python itself.
It is freely downloadable and open source, and it is always current with the latest version of Python.

Procedure 1.1. Option 1: Installing ActivePython

Here is the procedure for installing ActivePython:

1. Download ActivePython from http://www.activestate.com/Products/ActivePython/.

1
 Chapter 1

2. If you are using Windows 95, Windows 98, or Windows ME, you will also need to download and
install Windows Installer 2.0 [http://download.microsoft.com/download/WindowsInstaller/Install/2.0/-
W9XMe/EN-US/InstMsiA.exe] before installing ActivePython.

3. Double-click the installer, ActivePython-2.2.2-224-win32-ix86.msi.

4. Step through the installer program.

5. If space is tight, you can do a custom installation and deselect the documentation, but I don't recommend
this unless you absolutely can't spare the 14MB.

6. After the installation is complete, close the installer and choose Start->Programs->ActiveState Act-
ivePython 2.2->PythonWin IDE. You'll see something like the following:

PythonWin 2.2.2 (#37, Nov 26 2002, 10:24:37) [MSC 32 bit (Intel)] on win32.
Portions Copyright 1994-2001 Mark Hammond ([email protected]) -
see 'Help/About PythonWin' for further copyright information.
>>>

Procedure 1.2. Option 2: Installing Python from Python.org [http://www.python.org/

]
1. Download the latest Python Windows installer by going to http://www.python.org/ftp/python/ and
selecting the highest version number listed, then downloading the .exe installer.

2. Double-click the installer, Python-2.xxx.yyy.exe. The name will depend on the version of Python
available when you read this.

3. Step through the installer program.

4. If disk space is tight, you can deselect the HTMLHelp file, the utility scripts (Tools/), and/or the test
suite (Lib/test/).

5. If you do not have administrative rights on your machine, you can select Advanced Options, then
choose Non-Admin Install. This just affects where Registry entries and Start menu shortcuts are created.

6. After the installation is complete, close the installer and select Start->Programs->Python 2.3->IDLE
(Python GUI). You'll see something like the following:

Python 2.3.2 (#49, Oct 2 2003, 20:02:00) [MSC v.1200 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.

****************************************************************
Personal firewall software may warn about the connection IDLE
makes to its subprocess using this computer's internal loopback
interface. This connection is not visible on any external
interface and no data is sent to or received from the Internet.
****************************************************************

IDLE 1.0
>>>

2
 Chapter 1

Python on Mac OS X
On Mac OS X, you have two choices for installing Python: install it, or don't install it. You probably want
to install it.

Mac OS X 10.2 and later comes with a command-line version of Python preinstalled. If you are comfortable
with the command line, you can use this version for the first third of the book. However, the preinstalled
version does not come with an XML parser, so when you get to the XML chapter, you'll need to install
the full version.

Rather than using the preinstalled version, you'll probably want to install the latest version, which also
comes with a graphical interactive shell.

Procedure 1.3. Running the Preinstalled Version of Python on Mac OS X

To use the preinstalled version of Python, follow these steps:

1. Open the /Applications folder.

2. Open the Utilities folder.

3. Double-click Terminal to open a terminal window and get to a command line.

4. Type python at the command prompt.

Try it out:

Welcome to Darwin!
[localhost:~] you% python
Python 2.2 (#1, 07/14/02, 23:25:09)
[GCC Apple cpp-precomp 6.14] on darwin
Type "help", "copyright", "credits", or "license" for more information.
>>> [press Ctrl+D to get back to the command prompt]
[localhost:~] you%

Procedure 1.4. Installing the Latest Version of Python on Mac OS X

Follow these steps to download and install the latest version of Python:

1. Download the MacPython-OSX disk image from http://homepages.cwi.nl/~jack/macpython/down-

load.html.

2. If your browser has not already done so, double-click MacPython-OSX-2.3-1.dmg to mount the disk
image on your desktop.

3. Double-click the installer, MacPython-OSX.pkg.

4. The installer will prompt you for your administrative username and password.

5. Step through the installer program.

6. After installation is complete, close the installer and open the /Applications folder.

7. Open the MacPython-2.3 folder

3
 Chapter 1

8. Double-click PythonIDE to launch Python.

The MacPython IDE should display a splash screen, then take you to the interactive shell. If the interactive
shell does not appear, select Window->Python Interactive (Cmd-0). The opening window will look
something like this:

Python 2.3 (#2, Jul 30 2003, 11:45:28)

[GCC 3.1 20020420 (prerelease)]
Type "copyright", "credits" or "license" for more information.
MacPython IDE 1.0.1
>>>

Note that once you install the latest version, the pre-installed version is still present. If you are running
scripts from the command line, you need to be aware which version of Python you are using.

Example 1.1. Two versions of Python

[localhost:~] you% python

Python 2.2 (#1, 07/14/02, 23:25:09)
[GCC Apple cpp-precomp 6.14] on darwin
Type "help", "copyright", "credits", or "license" for more information.
>>> [press Ctrl+D to get back to the command prompt]
[localhost:~] you% /usr/local/bin/python
Python 2.3 (#2, Jul 30 2003, 11:45:28)
[GCC 3.1 20020420 (prerelease)] on darwin
Type "help", "copyright", "credits", or "license" for more information.
>>> [press Ctrl+D to get back to the command prompt]
[localhost:~] you%

Python on Mac OS 9
Mac OS 9 does not come with any version of Python, but installation is very simple, and there is only one
choice.

Follow these steps to install Python on Mac OS 9:

1. Download the MacPython23full.bin file from http://homepages.cwi.nl/~jack/macpython/down-

load.html.

2. If your browser does not decompress the file automatically, double-click MacPython23full.bin to
decompress the file with Stuffit Expander.

3. Double-click the installer, MacPython23full.

4. Step through the installer program.

5. AFter installation is complete, close the installer and open the /Applications folder.

6. Open the MacPython-OS9 2.3 folder.

7. Double-click Python IDE to launch Python.

4
 Chapter 1

The MacPython IDE should display a splash screen, and then take you to the interactive shell. If the inter-
active shell does not appear, select Window->Python Interactive (Cmd-0). You'll see a screen like this:

Python 2.3 (#2, Jul 30 2003, 11:45:28)

[GCC 3.1 20020420 (prerelease)]
Type "copyright", "credits" or "license" for more information.
MacPython IDE 1.0.1
>>>

Python on RedHat Linux

Installing under UNIX-compatible operating systems such as Linux is easy if you're willing to install a
binary package. Pre-built binary packages are available for most popular Linux distributions. Or you can
always compile from source.

Download the latest Python RPM by going to http://www.python.org/ftp/python/ and selecting the highest
version number listed, then selecting the rpms/ directory within that. Then download the RPM with the
highest version number. You can install it with the rpm command, as shown here:

5
 Chapter 1

Example 1.2. Installing on RedHat Linux 9

localhost:~$ su -
Password: [enter your root password]
[root@localhost root]# wget
http://python.org/ftp/python/2.3/rpms/redhat-9/python2.3-2.3-5pydotorg.i386.rpm
Resolving python.org... done.
Connecting to python.org[194.109.137.226]:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 7,495,111 [application/octet-stream]
...
[root@localhost root]# rpm -Uvh python2.3-2.3-5pydotorg.i386.rpm
Preparing... ########################################### [100%]
1:python2.3 ########################################### [100%]
[root@localhost root]# python ❶
Python 2.2.2 (#1, Feb 24 2003, 19:13:11)
[GCC 3.2.2 20030222 (Red Hat Linux 3.2.2-4)] on linux2
Type "help", "copyright", "credits", or "license" for more information.
>>> [press Ctrl+D to exit]
[root@localhost root]# python2.3 ❷
Python 2.3 (#1, Sep 12 2003, 10:53:56)
[GCC 3.2.2 20030222 (Red Hat Linux 3.2.2-5)] on linux2
Type "help", "copyright", "credits", or "license" for more information.
>>> [press Ctrl+D to exit]
[root@localhost root]# which python2.3 ❸
/usr/bin/python2.3

❶ Whoops! Just typing python gives you the older version of Python -- the one that was installed by
default. That's not the one you want.
❷ At the time of this writing, the newest version is called python2.3. You'll probably want to change
the path on the first line of the sample scripts to point to the newer version.
❸ This is the complete path of the newer version of Python that you just installed. Use this on the #!
line (the first line of each script) to ensure that scripts are running under the latest version of Python,
and be sure to type python2.3 to get into the interactive shell.

Python on Debian GNU/Linux

If you are lucky enough to be running Debian GNU/Linux, you install Python through the apt command.

6
 Chapter 1

Example 1.3. Installing on Debian GNU/Linux

localhost:~$ su -
Password: [enter your root password]
localhost:~# apt-get install python
Reading Package Lists... Done
Building Dependency Tree... Done
The following extra packages will be installed:
python2.3
Suggested packages:
python-tk python2.3-doc
The following NEW packages will be installed:
python python2.3
0 upgraded, 2 newly installed, 0 to remove and 3 not upgraded.
Need to get 0B/2880kB of archives.
After unpacking 9351kB of additional disk space will be used.
Do you want to continue? [Y/n] Y
Selecting previously deselected package python2.3.
(Reading database ... 22848 files and directories currently installed.)
Unpacking python2.3 (from .../python2.3_2.3.1-1_i386.deb) ...
Selecting previously deselected package python.
Unpacking python (from .../python_2.3.1-1_all.deb) ...
Setting up python (2.3.1-1) ...
Setting up python2.3 (2.3.1-1) ...
Compiling python modules in /usr/lib/python2.3 ...
Compiling optimized python modules in /usr/lib/python2.3 ...
localhost:~# exit
logout
localhost:~$ python
Python 2.3.1 (#2, Sep 24 2003, 11:39:14)
[GCC 3.3.2 20030908 (Debian prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> [press Ctrl+D to exit]

Python Installation from Source

If you prefer to build from source, you can download the Python source code from http://www.python.org/-
ftp/python/. Select the highest version number listed, download the .tgz file), and then do the usual
configure, make, make install dance.

7
 Chapter 1

Example 1.4. Installing from source

localhost:~$ su -
Password: [enter your root password]
localhost:~# wget http://www.python.org/ftp/python/2.3/Python-2.3.tgz
Resolving www.python.org... done.
Connecting to www.python.org[194.109.137.226]:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 8,436,880 [application/x-tar]
...
localhost:~# tar xfz Python-2.3.tgz
localhost:~# cd Python-2.3
localhost:~/Python-2.3# ./configure
checking MACHDEP... linux2
checking EXTRAPLATDIR...
checking for --without-gcc... no
...
localhost:~/Python-2.3# make
gcc -pthread -c -fno-strict-aliasing -DNDEBUG -g -O3 -Wall -Wstrict-prototypes
-I. -I./Include -DPy_BUILD_CORE -o Modules/python.o Modules/python.c
gcc -pthread -c -fno-strict-aliasing -DNDEBUG -g -O3 -Wall -Wstrict-prototypes
-I. -I./Include -DPy_BUILD_CORE -o Parser/acceler.o Parser/acceler.c
gcc -pthread -c -fno-strict-aliasing -DNDEBUG -g -O3 -Wall -Wstrict-prototypes
-I. -I./Include -DPy_BUILD_CORE -o Parser/grammar1.o Parser/grammar1.c
...
localhost:~/Python-2.3# make install
/usr/bin/install -c python /usr/local/bin/python2.3
...
localhost:~/Python-2.3# exit
logout
localhost:~$ which python
/usr/local/bin/python
localhost:~$ python
Python 2.3.1 (#2, Sep 24 2003, 11:39:14)
[GCC 3.3.2 20030908 (Debian prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> [press Ctrl+D to get back to the command prompt]
localhost:~$

The Interactive Shell

Now that you have Python installed, what's this interactive shell thing you're running?

It's like this: Python leads a double life. It's an interpreter for scripts that you can run from the command
line or run like applications, by double-clicking the scripts. But it's also an interactive shell that can evaluate
arbitrary statements and expressions. This is extremely useful for debugging, quick hacking, and testing.
I even know some people who use the Python interactive shell in lieu of a calculator!

Launch the Python interactive shell in whatever way works on your platform, and let's dive in with the
steps shown here:

8
 Chapter 1

Example 1.5. First Steps in the Interactive Shell

>>> 1 + 1 ❶
2
>>> print 'hello world' ❷
hello world
>>> x = 1 ❸
>>> y = 2
>>> x + y
3

❶ The Python interactive shell can evaluate arbitrary Python expressions, including any basic arithmetic
expression.
❷ The interactive shell can execute arbitrary Python statements, including the print statement.
❸ You can also assign values to variables, and the values will be remembered as long as the shell is
open (but not any longer than that).

Summary
You should now have a version of Python installed that works for you.

Depending on your platform, you may have more than one version of Python intsalled. If so, you need to
be aware of your paths. If simply typing python on the command line doesn't run the version of Python
that you want to use, you may need to enter the full pathname of your preferred version.

Congratulations, and welcome to Python.

9
Chapter 2. Your First Python Program
You know how other books go on and on about programming fundamentals and finally work up to building
a complete, working program? Let's skip all that.

Diving in
Here is a complete, working Python program.

It probably makes absolutely no sense to you. Don't worry about that, because you're going to dissect it
line by line. But read through it first and see what, if anything, you can make of it.

Example 2.1. odbchelper.py
If you have not already done so, you can download this and other examples [http://diveintopython.org/-
download/diveintopython-examples-5.4.zip] used in this book.

def buildConnectionString(params):
"""Build a connection string from a dictionary of parameters.

Returns string."""
return ";".join(["%s=%s" % (k, v) for k, v in params.items()])

if __name__ == "__main__":
myParams = {"server":"mpilgrim", \
"database":"master", \
"uid":"sa", \
"pwd":"secret" \
}
print buildConnectionString(myParams)

Now run this program and see what happens.

Running Programs on Windows

In the ActivePython IDE on Windows, you can run the Python program you're editing by choosing
File->Run... (Ctrl-R). Output is displayed in the interactive window.

Running Programs on Mac OS

In the Python IDE on Mac OS, you can run a Python program with Python->Run window...
(Cmd-R), but there is an important option you must set first. Open the .py file in the IDE, pop
up the options menu by clicking the black triangle in the upper-right corner of the window, and
make sure the Run as __main__ option is checked. This is a per-file setting, but you'll only need
to do it once per file.

Running Programs in UNIX

On UNIX-compatible systems (including Mac OS X), you can run a Python program from the
command line: python odbchelper.py

10
 Chapter 2

The output of odbchelper.py will look like this:

server=mpilgrim;uid=sa;database=master;pwd=secret

Declaring Functions
Python has functions like most other languages, but it does not have separate header files like C++ or
interface/implementation sections like Pascal. When you need a function, just declare it, like this:

def buildConnectionString(params):

Note that the keyword def starts the function declaration, followed by the function name, followed by the
arguments in parentheses. Multiple arguments (not shown here) are separated with commas.

Also note that the function doesn't define a return datatype. Python functions do not specify the datatype
of their return value; they don't even specify whether or not they return a value. In fact, every Python
function returns a value; if the function ever executes a return statement, it will return that value, otherwise
it will return None, the Python null value.

Python vs. Visual Basic: Return Values

In Visual Basic, functions (that return a value) start with function, and subroutines (that do not
return a value) start with sub. There are no subroutines in Python. Everything is a function, all
functions return a value (even if it's None), and all functions start with def.

The argument, params, doesn't specify a datatype. In Python, variables are never explicitly typed. Python
figures out what type a variable is and keeps track of it internally.

Python vs. Java: Return Values

In Java, C++, and other statically-typed languages, you must specify the datatype of the function
return value and each function argument. In Python, you never explicitly specify the datatype of
anything. Based on what value you assign, Python keeps track of the datatype internally.

How Python's Datatypes Compare to Other Programming

Languages
An erudite reader sent me this explanation of how Python compares to other programming languages:

statica