One piece of Python optimization lore is that access to localvariables is very fast, so if you repeatedly refer to something in aloop in a function you can optimize it by copying it to a localvariable first (this often comes up when you are repeatedly calling afunction). This fast access comes about because of some implementationdetails in CPython.

The CPython interpreter doesn't run Python code directly, but firstcompiles it to bytecode for a relatively simple stack-based virtualmachine. You can see the actual

Joel Spolsky likes to talk about leaky abstractions ,how the lower level details underneath abstractions inevitably leakthrough and affect your work with those abstractions. High levellanguages like Python are no exception, because how their abstractionsare implemented has significant effects on how fast different sorts ofcode will run.

For instance, let's take lists and tuples, both of which CPythonimplements as arrays of objects. This has a number of consequences:

• indexing a list element is cheap, and all list elements are equallycheap to access.

DNS-based host name lookups can be what I'll call 'relative', whichlook for the host name inside some domain, or 'absolute', whichassumes that the host name is fully qualified and starts right fromthe root DNS. (For clarity, absolute names are often written with atrailing '.'; this can often be used to make resolver libraries treatthem as absolute.)

Once upon a time, we had an interesting mail explosion. The campuswide mail servers started sending our

One of the things I write in Python is network daemons. Because it worksso nicely, network daemons usually take input as text lines that startwith a command word and have whitespace separated arguments. There'sa certain amount of eye-rolling tedium in writing code to check thatthe command word is valid and has the right number of arguments. WhenI wrote a program that does a lot of this, the tedium finally got tome and I sort of snapped and automated all of the validation throughPython'