What exactly does “import *” import?

by

The “advantage” of from xyz import * as opposed to other forms of import is that it imports everything (well, almost… [see (a) below] everything) from the designated module under the current module. This allows using the various objects (variables, classes, methods…) from the imported module without prefixing them with the module’s name. For example

>>> from math import *
>>>pi
3.141592653589793
>>>sin(pi/2)
>>>1.0

This practice (of importing * into the current namespace) is however discouraged because it

  • provides the opportunity for namespace collisions (say if you had a variable name pi prior to the import)
  • may be inefficient, if the number of objects imported is big
  • doesn’t explicitly document the origin of the variable/method/class (it is nice to have this “self documentation” of the program for future visit into the code)

Typically we therefore limit this import * practice to ad-hoc tests and the like. As pointed out by @Denilson-Sá-Maia, some libraries such as (e.g. pygame) have a sub-module where all the most commonly used constants and functions are defined and such sub-modules are effectively designed to be imported with import *. Other than with these special sub-modules, it is otherwise preferable to …:

explicitly import a few objects only

>>>from math import pi
>>>pi
>>>3.141592653589793
>>> sin(pi/2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'sin' is not defined

or import the module under its own namespace (or an alias thereof, in particular if this is a long name, and the program references its objects many times)

  >>>import math
  >>>math.pi
  >>>3.141592653589793
  etc..


  >>>import math as m  #bad example math being so short and standard...
  >>>m.pi
  >>>3.141592653589793
  etc..

See the Python documentation on this topic

(a) Specifically, what gets imported with from xyz import * ?
if xyz module defines an __all__ variable, it will import all the names defined in this sequence, otherwise it will import all names, except these which start with an underscore.

Note Many libraries have sub-modules. For example the standard library urllib includes sub-modules like urllib.request, urllib.errors, urllib.response etc. A common point of confusion is that

from urllib import *

would import all these sub-modules. That is NOT the case: one needs to explicitly imports these separately with, say, from urllib.request import * etc. This incidentally is not specific to import *, plain import will not import sub-modules either (but of course, the * which is often a shorthand for “everything” may mislead people in thinking that all sub-modules and everything else would be imported).

More Related Contents:

  1. Visibility of global variables in imported modules
  2. Python: Why should ‘from import *’ be prohibited?
  3. How do I unload (reload) a Python module?
  4. How can I import other Python files?
  5. Import a module from a relative path
  6. Sibling package imports
  7. How to load all modules in a folder?
  8. Circular import dependency in Python
  9. Why is Python running my module when I import it, and how do I stop it?
  10. How to mock an import
  11. Trying to import module with the same name as a built-in module causes an import error
  12. Callable modules
  13. List all the modules that are part of a python package?
  14. Importing modules: __main__ vs import as module
  15. ModuleNotFoundError: What does it mean __main__ is not a package?
  16. Django: “projects” vs “apps”
  17. Creating a class within a function and access a function defined in the containing function’s scope
  18. python packaging for relative imports
  19. What are Python namespaces all about
  20. Cyclic module dependencies and relative imports in Python
  21. Python Nose Import Error
  22. What does if __name__ == “__main__”: do in Python?
  23. Prevent Python from caching the imported modules
  24. Hide external modules when importing a module (e.g. regarding code-completion)
  25. Python: Name resolution; order of function def’s
  26. Python import error: cannot import name ‘six’ from ‘sklearn.externals’
  27. argparse subcommands with nested namespaces
  28. Importing module from string variable using “__import__” gives different results than a normal import statement
  29. Recursive version of ‘reload’
  30. How to add a Python import path using a .pth file

Leave a Comment