Why does Python’s __import__ require fromlist?

by

In fact, the behaviour of __import__() is entirely because of the implementation of the import statement, which calls __import__(). There’s basically five slightly different ways __import__() can be called by import (with two main categories):

import pkg
import pkg.mod
from pkg import mod, mod2
from pkg.mod import func, func2
from pkg.mod import submod

In the first and the second case, the import statement should assign the “left-most” module object to the “left-most” name: pkg. After import pkg.mod you can do pkg.mod.func() because the import statement introduced the local name pkg, which is a module object that has a mod attribute. So, the __import__() function has to return the “left-most” module object so it can be assigned to pkg. Those two import statements thus translate into:

pkg = __import__('pkg')
pkg = __import__('pkg.mod')

In the third, fourth and fifth case, the import statement has to do more work: it has to assign to (potentially) multiple names, which it has to get from the module object. The __import__() function can only return one object, and there’s no real reason to make it retrieve each of those names from the module object (and it would make the implementation a lot more complicated.) So the simple approach would be something like (for the third case):

tmp = __import__('pkg')
mod = tmp.mod
mod2 = tmp.mod2

However, that won’t work if pkg is a package and mod or mod2 are modules in that package that are not already imported, as they are in the third and fifth case. The __import__() function needs to know that mod and mod2 are names that the import statement will want to have accessible, so that it can see if they are modules and try to import them too. So the call is closer to:

tmp = __import__('pkg', fromlist=['mod', 'mod2'])
mod = tmp.mod
mod2 = tmp.mod2

which causes __import__() to try and load pkg.mod and pkg.mod2 as well as pkg (but if mod or mod2 don’t exist, it’s not an error in the __import__() call; producing an error is left to the import statement.) But that still isn’t the right thing for the fourth and fifth example, because if the call were so:

tmp = __import__('pkg.mod', fromlist=['submod'])
submod = tmp.submod

then tmp would end up being pkg, as before, and not the pkg.mod module you want to get the submod attribute from. The implementation could have decided to make it so the import statement does extra work, splitting the package name on . like the __import__() function already does and traversing the names, but this would have meant duplicating some of the effort. So, instead, the implementation made __import__() return the right-most module instead of the left-most one if and only if fromlist is passed and not empty.

(The import pkg as p and from pkg import mod as m syntax doesn’t change anything about this story except which local names get assigned to — the __import__() function sees nothing different when as is used, it all remains in the import statement implementation.)

More Related Contents:

  1. How do I unload (reload) a Python module?
  2. How can I import other Python files?
  3. Import a module from a relative path
  4. Sibling package imports
  5. How to load all modules in a folder?
  6. ImportError: No module named requests
  7. Circular import dependency in Python
  8. Why is Python running my module when I import it, and how do I stop it?
  9. How to mock an import
  10. Trying to import module with the same name as a built-in module causes an import error
  11. Callable modules
  12. List all the modules that are part of a python package?
  13. Importing modules: __main__ vs import as module
  14. ModuleNotFoundError: What does it mean __main__ is not a package?
  15. How can I check if a module has been imported?
  16. Dynamic loading of python modules
  17. python packaging for relative imports
  18. Cyclic module dependencies and relative imports in Python
  19. Python Nose Import Error
  20. Prevent Python from caching the imported modules
  21. Python: Why should ‘from import *’ be prohibited?
  22. What happens when using mutual or circular (cyclic) imports?
  23. Pillow installed, but getting “no module named pillow” when importing
  24. how to “reimport” module to python then code be changed after import
  25. Hide external modules when importing a module (e.g. regarding code-completion)
  26. Importing a library from (or near) a script with the same name raises “AttributeError: module has no attribute” or an ImportError or NameError
  27. How can I do relative imports in Python?
  28. bash: Python import – Command not found for pandas
  29. Import statement works on PyCharm but not from terminal
  30. How to add a Python import path using a .pth file

Leave a Comment