Should import statements always be at the top of a module?
Module importing is quite fast, but not instant. This means that:
- Putting the imports at the top of the module is fine, because it's a trivial cost that's only paid once.
- Putting the imports within a function will cause calls to that function to take longer.
So if you care about efficiency, put the imports at the top. Only move them into a function if your profiling shows that would help (you did profile to see where best to improve performance, right??)
The best reasons I've seen to perform lazy imports are:
- Optional library support. If your code has multiple paths that use different libraries, don't break if an optional library is not installed.
- In the
__init__.pyof a plugin, which might be imported but not actually used. Examples are Bazaar plugins, which use
bzrlib's lazy-loading framework.
Putting the import statement inside of a function can prevent circular dependencies.For example, if you have 2 modules, X.py and Y.py, and they both need to import each other, this will cause a circular dependency when you import one of the modules causing an infinite loop. If you move the import statement in one of the modules then it won't try to import the other module till the function is called, and that module will already be imported, so no infinite loop. Read here for more - effbot.org/zone/import-confusion.htm
I have adopted the practice of putting all imports in the functions that use them, rather than at the top of the module.
The benefit I get is the ability to refactor more reliably. When I move a function from one module to another, I know that the function will continue to work with all of its legacy of testing intact. If I have my imports at the top of the module, when I move a function, I find that I end up spending a lot of time getting the new module's imports complete and minimal. A refactoring IDE might make this irrelevant.
There is a speed penalty as mentioned elsewhere. I have measured this in my application and found it to be insignificant for my purposes.
It is also nice to be able to see all module dependencies up front without resorting to search (e.g. grep). However, the reason I care about module dependencies is generally because I'm installing, refactoring, or moving an entire system comprising multiple files, not just a single module. In that case, I'm going to perform a global search anyway to make sure I have the system-level dependencies. So I have not found global imports to aid my understanding of a system in practice.
I usually put the import of
sys inside the
if __name__=='__main__' check and then pass arguments (like
sys.argv[1:]) to a
main() function. This allows me to use
main in a context where
sys has not been imported.