Wsrtjtyk

You can make the imports global within a function like this:

def my_imports(module_name):

    globals()[module_name] = __import__(module_name)

You could have this function return the names of the modules you want to import, and then use

mod == __import__(module_name)

You can use the built-in function __import__ to conditionally import a module with global scope.

To import a top level module (think: import foo):

def cond_import():

  global foo

  foo = __import__('foo', globals(), locals()) 

Import from a hierarchy (think: import foo.bar):

def cond_import():

  global foo

  foo = __import__('foo.bar', globals(), locals()) 

Import from a hierarchy and alias (think: import foo.bar as bar):

def cond_import():

  global bar

  foo = __import__('foo.bar', globals(), locals()) 

  bar = foo.bar

I like @badzil approach.

def global_imports(modulename,shortname = None, asfunction = False):

    if shortname is None: 

        shortname = modulename

    if asfunction is False:

        globals()[shortname] = __import__(modulename)

    else:        

        globals()[shortname] = eval(modulename + "." + shortname)

So something that is traditionally in a class module:

import numpy as np



import rpy2

import rpy2.robjects as robjects

import rpy2.robjects.packages as rpackages

from rpy2.robjects.packages import importr

Can be transformed into a global scope:

global_imports("numpy","np")



global_imports("rpy2")

global_imports("rpy2.robjects","robjects")

global_imports("rpy2.robjects.packages","rpackages")

global_imports("rpy2.robjects.packages","importr",True)

May have some bugs, which I will verify and update. The last example could also have an alias which would be another "shortname" or a hack like "importr|aliasimportr"

I've just had the similar problem, here is my solution:

class GlobalImport:



    def __enter__(self):

        return self



    def __call__(self):

        import inspect

        self.collector = inspect.getargvalues(inspect.getouterframes(inspect.currentframe())[1].frame).locals



    def __exit__(self, *args):

        globals().update(self.collector)

then, anywhere in the code:

with GlobalImport() as gi:

    import os, signal, atexit, threading, _thread

    # whatever you want it won't remain local

    # if only 

    gi()

    # is called before the end of this block



# there you go: use os, signal, ... from whatever place of the module

I like @rafał grabie approach. As it even support importing all.
i.e.
from os import *

(Despite it being bad practice XD )

Not allowed to comment, but here is a python 2.7 version.

Also removed the need to call the function at the end.

class GlobalImport:

    def __enter__(self):

        return self

    def __exit__(self, *args):

        import inspect

        collector = inspect.getargvalues(inspect.getouterframes(inspect.currentframe())[1][0]).locals

        globals().update(collector)



def test():

    with GlobalImport() as gi:

        ## will fire a warning as its bad practice for python. 

        from os import *



test()

print path.exists(__file__)