How can I perform `import *` from within a function?

Question

I have the following standard import procedure:

from ROOT import *

Because of the way ROOT handles command line options and arguments, something like the following is required in order to avoid screwing up the script's command line parsing:

argv_tmp = sys.argv
sys.argv = []
from ROOT import *
sys.argv = argv_tmp

I need to perform this operation in many scripts. This operation may change or there might turn out to be a better approach, so I want to centralise this procedure in a single function provided by some imported module, making it easy to change the procedure in future.

def import_ROOT():
    # magic

import os
import sys
import_ROOT()
import docopt

How can I import the ROOT module from within a function such that the result of the script's operation is the same as for the from ROOT import * procedure described above?

You shouldn't need to do that stuff. It sounds like you don't have a proper `main()` function and `if __name__ == '__main__':` `main()` in your ROOT.py. — PM 2Ring, Nov 02 '15 at 17:56
@PM2Ring Thanks for your comment. `ROOT.py` is a module, not a script. It doesn't feature a `main` function. Also, it is a Python bindings infrastructure for the [ROOT](https://root.cern.ch/) framework, so it is not something I can change readily. I need to focus on changes to the script, not to the module. — d3pd, Nov 02 '15 at 17:58
Ah, ok. Still, try to avoid [from import *](http://stackoverflow.com/questions/2386714/why-is-import-bad), if you can. — PM 2Ring, Nov 03 '15 at 11:55

score 2 · Accepted Answer · answered Nov 02 '15 at 19:45

Due to how local variables are implemented in python you cannot do this. And since you don't know all the variables that may be imported you can't declare them global.

As to why you can't import unknown locals in a function. This is because at compile time python establishes all the different possible locals that may exist (anything that is directly assigned to and hasn't been declared global or nonlocal). Space for these locals are made in an array associated with each call of the function. All locals are then referenced by their index in the array rather than their name. Thus, the interpreter is unable to make additional space for unknown locals nor know how to refer to them at runtime.

score 0 · Answer 2 · edited May 23 '17 at 12:30

0

I believe there's already a similiar question in here:

Python: how to make global imports from a function

example:

def example_function():
    global module
    import module

edited May 23 '17 at 12:30

Community

1
1

answered Nov 02 '15 at 17:52

Rui Lima

227
1
4
17

Thanks for your suggestion. I Think this approach is equivalent to `import ROOT as ROOT`, *not* `from ROOT import *`. – d3pd Nov 02 '15 at 17:59

score 0 · Answer 3 · answered Nov 02 '15 at 21:23

This probably misses all sorts of corner cases, but it's a start:

def import_ROOT():
    import ROOT
    globals().update(ROOT.__dict__)

Obligatory disclaimer: if you're importing *, you're probably doing it wrong. But I guess there could be situations where import * is the lesser evil.

How can I perform `import *` from within a function?

3 Answers3