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