Generators和Timeit ......我读错了结果吗？

Question

I'm using Python 2.7.10.

I was going through a tutorial on generators, and understand that xrange , when called, returns a generator, so I am expecting it to be faster when calculating a sum.

I am confused about the whole 1 loop vs 10 loops and what 1 loop, best of 3 means considering there was only 1 loop?

How does timeit know how many loops to do, or is that a function of the code I'm applying timeit to?

I do not know how to interpret the results here.... Advice?

Answer 1

The time given by %timeit magic command of IPython is the time taken for the statement.

In case of xrange it only took 68.2 milliseconds, whereas range took 243 milliseconds , hence xrange really is faster than range as you are expecting.

Answer 2

The result printing might seem a little weird unless you read the docs carefully.

The basic operation of timeit (or %timeit which uses the former) is:

\-- repeat timer loop n times (return best of t_i / m)
  \-- timed run (time t_i is measured)
    \-- statement loop
          (unless specified, m = 1, 10, 100, ..., until t_i > 0.2s
            t_i = sum(t_s)
          )
      \-- statement (t_s, time per statement)

What is displayed is max(t_i) .

1. First number ( n loops ) is the number of loops per timer run.
2. Second number ( best of m ) is the number of timer runs.
3. Third number is the time per statement execution of the best run from (2).

By default timeit runs the statement once for each timed loop and it runs three timed loops. The corresponding switch to change the number of timed loops is -r .

However, if the running time of a timer loop is less than 0.2 seconds, it repeats the timed statement inside a timer loop. First it goes up to 10 times, then 100 times, and so on. This is the first number. The corresponding switch to fix this number is -n .

So range() ran once for a single timer loop, because it took more than 0.2 seconds. A single xrange() sum, however, took less 0.2 seconds, so it was repeated 10 times, which was enough to push it over the boundary (ten runs took 0.682 seconds).

The resulting running time still is the running time of a single statement. The rest is typical benchmark smoothing stuff.