cProfile is the classic profiling tool. The basic way to use it is like so:

python -m cProfile myscript.py

Here I've called it on the test routine of a reference implementation of the mersenne twister that I wrote.

me@mine $ python -m cProfile mersenne.twister.py 
True
True
1000000
         1003236 function calls in 2.163 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    2.163    2.163 <string>:1(<module>)
        1    0.001    0.001    2.162    2.162 mersenne.twister.py:1(<module>)
        3    0.001    0.000    0.001    0.000 mersenne.twister.py:10(init_gen)
  1000014    1.039    0.000    1.821    0.000 mersenne.twister.py:19(extract_number)
        1    0.000    0.000    0.000    0.000 mersenne.twister.py:3(Twister)
     1603    0.766    0.000    0.782    0.000 mersenne.twister.py:33(generate_numbers)
        1    0.000    0.000    0.000    0.000 mersenne.twister.py:4(__init__)
        1    0.317    0.317    2.161    2.161 mersenne.twister.py:42(_test)
        1    0.001    0.001    2.163    2.163 {execfile}
        1    0.000    0.000    0.000    0.000 {len}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
     1608    0.038    0.000    0.038    0.000 {range}

ncalls is the number of times a function was called. tottime is the total time spent in a function, excluding the time spent in sub-function calls. percall is tottime / ncalls. cumtime is the time spent in the function including the time spent in sub-function calls. And the remaining data is as follows: filename:lineno(func_name).

In most cases, look at ncalls and tottime first. In the above data, you can see that the large majority of the time spent by this program happens in extract_number. Furthermore, we can see that extract_number is called many (1000014) times. So anything I can do to speed up extract_number will significantly speed up the execution of this test code. If it gains me a microsecond, then the gain will be multiplied by 1000014, resulting in a full second gain.

Then I should work on generate_numbers. Gains there won't matter as much, but they may still be significant, and since that function burns another .7 seconds, there's some benefit to be had.

That should give you the general idea. Note, however, that the tottime number can sometimes be deceptive, in cases of recursion, for example.

Check out funkload - it's a way of running your unit tests as either functional or load tests to gauge how well your site is performing.

Another interesting project which can be used in conjunction with funkload is codespeed. This is an internal dashboard that measures the "speed" of your codebase for every commit you make to your code, presenting graphs with trends over time. This assumes you have a number of automatic benchmarks you can run - but it could be a useful way to have an authoritative account of performance over time. The best use of codespeed I've seen so far is the speed.pypy.org site.

As to your requirement for determinism - perhaps the best approach to that is to use statistics to your advantage? Automatically run the test N times, produce the min, max, average and standard deviation of all your runs? Check out this article on benchmarking for some pointers on this.

You can use time.time() or time.clock() before and after the block you want to time.

import time

t0 = time.time()
code_block
t1 = time.time()

total = t1-t0

This method is not as exact as timeit (it does not average several runs) but it is straightforward.

time.time() (in Windows and Linux) and time.clock() (in Linux) are not precise enough for fast functions because they return the time in an integer number of seconds (you'll get total = 0 for short durations). In this case or if you want to average the time elapsed by several runs, you have to manually call the function multiple times (As I think you already do in you example code and timeit does this automatically when you set its number argument)

import time

def myfast():
   code

n = 10000
t0 = time.time()
for i in range(n): myfast()
t1 = time.time()

total_n = t1-t0

In Windows, time.clock() has higher precision because it returns the time in microseconds whereas time.time() returns the time in seconds. So choose whichever makes sense for your situation.