What's going on here is that the module random is being imported as a local variable in test. Try this

def test():
    exec code
    print globals()
    print locals()
    f()

will print

{'code': '\nimport random\ndef f():\n    print random.randint(0,9)\n', '__builtins__': <module '__builtin__' (built-in)>, '__package__': None, 'test': <function test at 0x02958BF0>, '__name__': '__main__', '__doc__': None}
{'random': <module 'random' from 'C:\Python27\lib\random.pyc'>, 'f': <function f at 0x0295A070>}

The reason f can't see random is that f is not a nested function inside of test--if you did this:

def test():
    import random
    def f():
        print random.randint(0,9)
    f()

it would work. However, nested functions require that the outer function contains the definition of the inner function when the outer function is compiled--this is because you need to set up cell variables to hold variables that are shared between the two (outer and inner) functions.

To get random into the global namespace, you would just do something like this

exec code in globals(),globals()

The arguments to exec after the in keyword are the global and local namespaces in which the code is executed (and thus, where name's defined in the exec'd code are stored).

Another difference: execfile gets a context dictionary; the global context by default or a specified dictionary. This could allow some strange things

dont_do_this.py:

# Probably not a good thing to do
z=x+1  # an expression that involves an un-defined field

Obviously,

from dont_do_this import *

fails.

However,

d={'x':1}
execfile( 'dont_do_this.py', d )

is OK and results in d=={'x':1, 'z':2}

Note that

x=1
execfile( 'dont_do_this.py' )

is OK and results in the variable z being added to the globals.

You might want to try something like this:

_globals = {}
code = """import math;"""
code += """import numpy;"""
code = compile(code, '<string>', 'exec')
exec code in _globals

It's safer than just doing an exec, and it should import correctly inside a function's local scope.

You can then update globals() with whatever modules (or functions) you import.

When using exec for functions, you can get a handle to globals with g = globals(), then do an update on g. For modules, you should do another step... you will want to also update the modules in sys.modules as well.

UPDATE: to be explicit:

>>> def foo(import_string):
...   _globals = {}
...   code = compile(import_string, '<string>', 'exec')
...   exec code in _globals
...   import sys
...   g = globals()
...   g.update(_globals)
...   sys.modules.update(_globals)
... 
>>> foo('import numpy as np')
>>> np.linspace
<function linspace at 0x1009fc848>

Somehow, I think you must be calling

test('c:\python27\test1.py')

instead of

test('c:/python27/test1.py')

The backslash in front of the t is being interpreted as a tab character. Thus the error

import:c:\python27 est1.py

Notice the missing t.

Secondly, the import command expects a module name, not a path. For importing, use __import__ not exec or execfile. execfile has been removed from Python3, so for future compatibilty, you may not want to use it in Python2. exec can be used instead, but there are problems with using exec.

Assuming c:\python27 is in your PYTHONPATH, you could do something like this:

def test(jobname):
    print jobname
    __import__(jobname)

if __name__ == '__main__':
    test('test1')

You are just supposed to read the file and exec the code yourself. 2to3 currently replaces this:

execfile("somefile.py", global_vars, local_vars)

With this:

with open("somefile.py") as f:
    code = compile(f.read(), "somefile.py", 'exec')
    exec(code, global_vars, local_vars)

(The compile call isn't strictly needed, but it associates the filename with the code object, making debugging a little easier).

See Python's docs for:

• execfile
• compile
• exec

When you say

get_doc(sys)

python will not be able to recognize sys. The actual way to do what you are trying to do would be to

1. pass the module name as a string parameter

2. use __import__ function to load the module, like this

   def get_doc(module):
       mod = __import__(module)
       print mod.__doc__
   
   get_doc("sys")
   

Note: I am not in favor of executing dynamic code in programs, but if you must use exec to solve this problem read this and have a basic understanding about the security implications and then look at aIKid's solution.