I'd like to suggest a different approach than the one taken in rev. 
54348 to improve timeit's scripting interface: allow passing it a 
namespace. Reasons:

- It has smaller overhead for functions that take an argument:
>>> def f(a): pass
...
# trunk
>>> min(ht.Timer(lambda f=f: f(42)).repeat())
0.54068493843078613
# my patch
>>> min(mt.Timer("f(42)", ns=dict(f=f)).repeat())
0.29009604454040527

- it is more flexible. Example:
# working code, requires matplotlib
from timeit import Timer
from time import sleep

def linear(i):
    sleep(.05*i)
def quadratic(i):
    sleep(.01*i**2)

x = range(10)
y = []
for a in x:
    y.append([min(Timer("f(a)", ns=dict(f=f, a=a)).repeat(1, 1))
              for f in linear, quadratic])

from pylab import plot, show
plot(x, y)
show()

The above code works unaltered inside a function, unlike the hacks 
using "from __main__ import ...".

- the implementation is simpler and should be easy to maintain.

The provided patch is against 2.5.1. If it has a chance of being 
accepted I'm willing to jump through the necessary hoops: 
documentation, tests, etc.

A more general approach would be to add both 'locals' and 'globals' to
be used by exec.  At least, I would change 'ns' to 'locals'.

On the second thought, I actually wanted Timer to mimic eval without
realizing that eval uses positional rather than keywords arguments. 
'locals' is obviously a bad choice for the keyword parameter because it
masks locals() builtin.  Maybe 'local_namespace'?

Generally, when I use timeit from the interpreter prompt, I use "from
__main__ import *" as the setup code string. Then I can use all
currently defined global symbols directly :)

Alexander, I'm fine with a more specific argument name. ns was what 
the Timer already used internally.

Antoine, from __main__ import name1, ..., nameN works fine on the 
command line, but inside a function you'd have to declare the names 
you want to pass to the Timer as globals which I find a bit clumsy. 
Apart from giving a syntax warning a star-import affects the generated 
bytecode and produces the (slower) LOAD_NAME instead of LOAD_FAST.

On Wed, Apr 2, 2008 at 2:42 AM, Peter Otten <report@bugs.python.org> wrote:

>  Alexander, I'm fine with a more specific argument name. ns was what
>  the Timer already used internally.
>

Maybe it should be "locals" after all.  It does not look like the
conflict with builtin locals() is an issue.  Note that this is what
__import__ uses.  I still recommend adding globals argument as well
for completeness and more accurate timings when timed code uses
globals.

This note is simply a reminder that Antoine's 'from __main__ import *' 
solution fails in python3.  Also, resolution of this issue probably 
could incorporate Issue1397474.


>>> import timeit
>>> timeit.timeit('None','from __main__ import *')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python3.0/timeit.py", line 227, in timeit
    return Timer(stmt, setup, timer).timeit(number)
  File "/usr/local/lib/python3.0/timeit.py", line 135, in __init__
    code = compile(src, dummy_src_name, "exec")
  File "<timeit-src>", line 2
SyntaxError: import * only allowed at module level

Georg, why did you reassign this?

I'm sorry, this should have been another issue. Reassigning to you.

See related discussion in issue 5441 and issue 1397474.

Would still be nice to have something like this. The timeit module API is still crippled, especially now that "from __main__ import *" doesn't work in a function anymore.

Attached is a patch that adds a 'global' kwarg to the Timeit constructor, which does pretty much what it says on the tin: specifies a global namespace that exec() will use.

I originally had a 'locals' arg as well (to mirror the signature of eval/exec), but realized that the local vars I was passing to exec were not available to the inner function.  Reason: the timeit module compiles/execs a *closure*, and closed-over variables and exec() simply do not play nicely.  Possible workarounds were to munge locals() into the globals() dict, or to somehow inject the variables in the locals dict into the closure.  I found neither of these options superior to simply not including a locals argument, for reasons of Least Surprise and maintainability.

Patch includes some basic tests and documentation.  I am particularly uncomfortable with writing docs so those very likely need some polish.

Correction, the name of the argument is 'globals', not 'global'.

Ben, thanks for the patch. Have you signed a contributor's agreement? You can find it at https://www.python.org/psf/contrib/contrib-form/

I did sign one right after I submitted the patch.  Takes a few days for the asterisks to propagate I guess :)

Ah, good. The patch looks fine to me, except that you should add "versionchanged" tags in the documentation for the added parameter.

Ah yes.

New patch improves the docs.

New changeset e0f681f4ade3 by Antoine Pitrou in branch 'default':
Issue #2527: Add a *globals* argument to timeit functions, in order to override the globals namespace in which the timed code is executed.
http://hg.python.org/cpython/rev/e0f681f4ade3

Thank you, Ben! Your patch is now pushed to the default branch.

Thanks Antoine.  Cheers :-)