Beginning Python - From Novice To Professional (2005)

x ■C O N T E N T S

More About print and import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 Printing with Commas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

Importing Something As Something Else. . . . . . . . . . . . . . . . . . . . . . 82

Assignment Magic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 Sequence Unpacking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 Chained Assignments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 Augmented Assignments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 Blocks: The Joy of Indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

Conditions and Conditional Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 So That’s What Those Boolean Values Are For . . . . . . . . . . . . . . . . . 86 Conditional Execution and the if Statement. . . . . . . . . . . . . . . . . . . . 87 else Clauses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 elif Clauses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 Nesting Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 More Complex Conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 Assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 while Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 for Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 Iterating Over Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 Some Iteration Utilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 Breaking Out of Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 else Clauses in Loops. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

List Comprehension—Slightly Loopy . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

And Three for the Road . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Nothing Happened! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Deleting with del . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

Executing and Evaluating Strings with exec and eval . . . . . . . . . . 104

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

Laziness Is a Virtue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

Abstraction and Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

Creating Your Own Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

Documenting Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

Functions That Aren’t Really Functions . . . . . . . . . . . . . . . . . . . . . . 112

The Magic of Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

Where Do the Values Come From? . . . . . . . . . . . . . . . . . . . . . . . . . . 113

Can I Change a Parameter?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

Keyword Parameters and Defaults . . . . . . . . . . . . . . . . . . . . . . . . . . 119

Collecting Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

Scoping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

Rebinding Global Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

Two Classics: Factorial and Power . . . . . . . . . . . . . . . . . . . . . . . . . . 130

Another Classic: Binary Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

Throwing Functions Around . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

reduce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

apply. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

■CHAPTER 7 More Abstraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

The Magic of Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

Inheritance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

Classes and Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

What Is a Class, Exactly? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

Making Your Own Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

Attributes, Functions, and Methods . . . . . . . . . . . . . . . . . . . . . . . . . 149

Throwing Methods Around. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

The Class Namespace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

Specifying a Superclass. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

Investigating Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

Multiple Superclasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

Interfaces and Introspection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

Some Thoughts on Object-Oriented Design . . . . . . . . . . . . . . . . . . . . . . 156

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

What Is an Exception? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

Making Things Go Wrong . . . Your Way . . . . . . . . . . . . . . . . . . . . . . . . . . 160

The raise Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

Custom Exception Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

Catching Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

Look, Ma, No Arguments! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

More Than One except Clause . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

Catching Two Exceptions with One Block . . . . . . . . . . . . . . . . . . . . . . . . 164

Catching the Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

A Real Catchall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

When All Is Well . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

And Finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

Exceptions and Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

The Zen of Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

Before We Begin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 Overriding the Constructor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

Calling the Unbound Superclass Constructor . . . . . . . . . . . . . . . . . 177

Using the super Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 Item Access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

The Basic Sequence and Mapping Protocol . . . . . . . . . . . . . . . . . . 180

Subclassing list, dict, and str . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 More Magic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 The property Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

__getattr__, __setattr__, and Friends. . . . . . . . . . . . . . . . . . . . . . 188

Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 The Iterator Protocol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 Making Sequences from Iterators. . . . . . . . . . . . . . . . . . . . . . . . . . . 191 Generators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 Making a Generator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 A Recursive Generator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192 Generators in General. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 Avoiding Generators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

The Eight Queens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195

Backtracking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

The Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

State Representation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

Finding Conflicts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

The Base Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

The Recursive Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198

Wrapping It Up . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201

New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202

■CHAPTER 10 Batteries Included . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203

Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 Modules Are Programs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203

Modules Are Used to Define Things . . . . . . . . . . . . . . . . . . . . . . . . . 205

Making Your Modules Available . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 Exploring Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 What’s in a Module?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 Getting Help with help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213 Use the Source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214

The Standard Library: A Few Favorites . . . . . . . . . . . . . . . . . . . . . . . . . . 215 sys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215 os . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 fileinput . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 Sets, Heaps, and Deques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221 time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226 random. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 shelve. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231 re . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

Other Interesting Standard Modules. . . . . . . . . . . . . . . . . . . . . . . . . 251

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253

Opening Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

The Mode Argument. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256

Buffering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257

The Basic File Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257

Reading and Writing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258

Reading and Writing Lines. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260

Closing Your Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261

Iterating Over File Contents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263

Doing It Byte by Byte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

One Line at a Time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

Reading Everything. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

Lazy Line Iteration with fileinput and xreadlines . . . . . . . . . . . . . . . 265

The New Kids on the Block: File Iterators . . . . . . . . . . . . . . . . . . . . 266

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268

An Example GUI Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269

A Plethora of Platforms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270

Downloading and Installing wxPython . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

Getting Started . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272

Creating Windows and Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273

Labels and Positions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274

More Intelligent Layout. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

Event Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

The Finished Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

But I’d Rather Use . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280

Using Tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281

Using Jython and Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282

Using Something Else. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

■CHAPTER 13 Database Support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285

The Python DB API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285

Global Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287

Connections and Cursors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287

Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289

Downloading and Installing pysqlite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290

Getting Started . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291

An Example Database Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291

Creating and Populating Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292

Searching and Dealing with Results. . . . . . . . . . . . . . . . . . . . . . . . . 294

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

A Handful of Networking Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

socket. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298

urllib and urllib2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

Other Modules. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301

SocketServer and Friends . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

More Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303

Multiple Connections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303

Forking and Threading with SocketServers. . . . . . . . . . . . . . . . . . . 305

Asynchronous I/O with select and poll . . . . . . . . . . . . . . . . . . . . . . . 305

Twisted . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308

Downloading and Installing Twisted. . . . . . . . . . . . . . . . . . . . . . . . . 308

Writing a Twisted Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311

New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312

■CHAPTER 15 Python and the Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313

Dynamic Web Pages with CGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

Step 1. Preparing the Web Server . . . . . . . . . . . . . . . . . . . . . . . . . . 321

Step 2. Adding the Pound Bang Line . . . . . . . . . . . . . . . . . . . . . . . . 321

Step 3. Setting the File Permissions. . . . . . . . . . . . . . . . . . . . . . . . . 322

CGI Security Risks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

A Simple CGI Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

Debugging with cgitb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

Using the cgi Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

A Simple Form. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327

One Step Up: mod_python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328

Installing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

CGI Handler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330

PSP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331

The Publisher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332

Web Services: Scraping Done Right . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335

RSS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335

XML-RPC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339

New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339

■CHAPTER 16 Testing, 1-2-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341

Test First, Code Later . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341

Precise Requirement Specification . . . . . . . . . . . . . . . . . . . . . . . . . . 342

Planning for Change . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 The 1-2-3 (and 4) of Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 Tools for Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 doctest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 unittest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 Beyond Unit Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350 PyChecker and PyLint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351 Profiling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353 A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355

■CHAPTER 17 Extending Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357

The Really Easy Way: Jython and IronPython . . . . . . . . . . . . . . . . . . . . . 358

Writing C Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360

A Swig of . . . SWIG. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361

Hacking It on Your Own . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370

New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371

Distutils Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373

Basic Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374

Wrapping Things Up . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376

Compiling Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378

Creating Executable Programs with py2exe . . . . . . . . . . . . . . . . . . . . . . 379

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380

New Functions in This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380

■CHAPTER 19 Playful Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381

Why Playful? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381

The Ju-Jitsu of Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381

Prototyping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382

Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383

Extracting Constants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383

Configuration Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384

Logging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385

If You Can’t Be Bothered . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387

Project Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388

A Quick Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389

What’s the Problem? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391

Specific Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392

Useful Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392

Preparations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392

First Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394

Adding Some Markup. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395

Second Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396

Handlers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397

A Handler Superclass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398

Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399

A Rule Superclass. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400

Filters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401

The Parser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401

Constructing the Rules and Filters . . . . . . . . . . . . . . . . . . . . . . . . . . 402

Putting It All Together. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

Further Exploration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409

What’s the Problem? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411

Specific Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412

Useful Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412

How Does It Work? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412

Preparations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412

First Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413

Drawing with ReportLab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413

Constructing Some PolyLines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415

The Prototype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416

Second Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

Getting the Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

Using the LinePlot Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418

Further Exploration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420

■C O N T E N T S xix

What’s the Problem? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421

Specific Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422

Useful Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422

Preparations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423

First Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424

Creating a Simple Content Handler. . . . . . . . . . . . . . . . . . . . . . . . . . 425

Creating HTML Pages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428

Second Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430

A Dispatcher Mix-In Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430

Factoring Out the Header, Footer, and Default Handling . . . . . . . . 432

Support for Directories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432

The Event Handlers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433

Further Exploration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437

■CHAPTER 23 Project 4: In the News . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439

What’s the Problem? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439

Specific Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440

Useful Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440

Preparations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440

First Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441

Second Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444

Further Exploration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452

What Now? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453

What’s the Problem? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455

Specific Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455

Useful Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456

What’s It For? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456

Preparations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456

First Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457

The ChatServer Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457

The ChatSession Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459

Putting It Together . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461