Python: Optimizing imports

Question

Does it matter where modules are loaded in a code? Or should they all be declared at the top, since during load time the external modules will have to be loaded regardless of where they are declared in the code...?

Example:

from os import popen

try:
    popen('echo hi')
    doSomethingIllegal;
except:
    import logging                   #Module called only when needed?
    logging.exception("Record to logger)

or is this optimized by the compiler the same way as:

from os import popen
import logging                      #Module will always loaded regardless

try:
    popen('echo hi')
    doSomethingIllegal;
except:
    logging.exception("Record to logger)

score 11 · Accepted Answer · edited May 23 '17 at 12:24

11

This indicates it may make a difference:

"import statements can be executed just about anywhere. It's often useful to place them inside functions to restrict their visibility and/or reduce initial startup time. Although Python's interpreter is optimized to not import the same module multiple times, repeatedly executing an import statement can seriously affect performance in some circumstances."

These two OS questions, local import statements? and import always at top of module? discuss this at length.

Finally, if you are curious about your specific case you could profile/benchmark your two alternatives in your environment.

I prefer to put all of my import statements at the top of the source file, following stylistic conventions and for consistency (also it would make changes easier later w/o having to hunt through the source file looking for import statements scattered throughout)

edited May 23 '17 at 12:24

Community

1
1

answered May 20 '12 at 10:42

Levon

138,105
33
200
191

Still a little confused. Wont the loader HAVE to load the external module anyway, just in case an exception is called? The only overhead I can see is just one extra line of code in the exception. – tetris11 May 20 '12 at 10:47
1

Just be clear in your code, do your imports at the top of the file. – Jakob Bowyer May 20 '12 at 10:49
@JakobBowyer But what's the difference, performance-wise is what Im really asking – tetris11 May 20 '12 at 10:50
@tetris11 The two SO questions links above discuss this issue at length – Levon May 20 '12 at 10:51
@Levon - Ah sorry, just read them. Yes I see now - it allows for lazy imports that may not exist, but otherwise theres not real overhead in the 1st otherthan a lookup. – tetris11 May 20 '12 at 10:56

score 2 · Answer 2 · answered May 20 '12 at 18:26

The general rule of thumb is that imports should be at the top of the file, as that makes code easier to follow, and that makes it easier to figure out what a module will need without having to go through all the code.

The Python style guide covers some basic guidelines for how imports should look: http://www.python.org/dev/peps/pep-0008/#imports

In practice, though, there are times when it makes sense to import from within a particular function. This comes up with imports that would be circular:

# Module 1
from module2 import B

class A(object):
    def do_something(self):
        my_b = B()
        ...

# Module 2
from module1 import A

class B(object):
    def do_something(self):
        my_a = A()
        ...

That won't work as is, but you could get around the circularity by moving the import:

# Module 1
from module2 import B

class A(object):
    def do_something(self):
        my_b = B()
        ...

# Module 2
class B(object):
    def do_something(self):
        from module1 import A
        my_a = A()
        ...

Ideally, you would design the classes such that this would never come up, and maybe even include them in the same module. In that toy example, having each import the other really doesn't make sense. However, in practice, there are some cases where it makes more sense to include an import for one method within the method itself, rather than throwing everything into the same module, or extracting the method in question out to some other object.

But, unless you have good reason to deviate, I say go with the top-of-the-module convention.

Python: Optimizing imports

2 Answers2