Should I use
from foo import bar
import foo.bar as bar
when importing a module and and there is no need/wish for changing the name (
Are there any differences? Does it matter?
bar is a module or package in
foo, there is no difference*, it doesn’t matter. The two statements have exactly the same result:
import os.path as path path <module 'posixpath' from '/Users/mj/Development/venvs/stackoverflow-2.7/lib/python2.7/posixpath.pyc'> from os import path path <module 'posixpath' from '/Users/mj/Development/venvs/stackoverflow-2.7/lib/python2.7/posixpath.pyc'>
bar is not a module or package, the second form will not work; a traceback is thrown instead:
import os.walk as walk Traceback (most recent call last): File "<stdin>", line 1, in <module> ImportError: No module named walk
* In Python 3.6 and before, there was a bug with the initialization ordering of packages containing other modules, where in the loading stage of the package using
import contained.module.something as alias in a submodule would fail where
from contained.module import something as alias would not. See Imports in __init__.py and `import as` statement for a very illustrative example of that problem, as well as Python issues #23203 and #30024.
This is a late answer, arising from what is the difference between ‘import a.b as b’ and ‘from a import b’ in python
This question has been flagged as a duplicate, but there is an important difference between the two mechanisms that has not been addressed by others.
from foo import bar imports any object called
bar from namespace
foo into the current namespace.
import foo.bar as bar imports an importable object (package/module/namespace) called
foo.bar and gives it the alias
What’s the difference?
Take a directory (package) called
foo which has an
# foo.__init__.py class myclass: def __init__(self, var): self.__var = var def __str__(self): return str(self.__var) bar = myclass(42)
Meanwhile, there is also a module in
from foo import bar print(bar)
import foo.bar as bar print(bar)
<module 'foo.bar' from '/Users//..../foo/bar.py'>
So it can be seen that
import foo.bar as bar is safer.
You can use as to rename modules suppose you have two apps that have views and you want to import them
from app1 import views as views1 from app2 import views as views2
if you want multiple import use comma separation
from datetime import date as d, time as t d <type 'datetime.date'> t <type 'datetime.time'>
Both are technically different:
import torch.nn as nnwill only import a module/package
from torch import nncan and will prefer to import an attribute
torchmodule/package. Importing a module/package
torch.nnis a fall.back.
In practice, it is bad style to have the same fully qualified name refer to two separate things. As such,
torch.nn should only refer to a module/package. In this common case, both import statements are functionally equivalent: The same object is imported and bound to the same name.
Which one to choose comes down to preference if the target always is a module. There are practical differences when refactoring:
import torch.nn as nnguarantees
.nnis a module/package. It protects against accidentally shadowing with an attribute.
from torch import nndoes not care what
.nnis. It allows to transparently change the implementation.
The basic import statement (no from clause) is executed in two steps:
- find a module, loading and initializing it if necessary
- define a name or names in the local namespace for the
scope where the import statement occurs.
The from form uses a slightly more complex process:
find the module specified in the from clause, loading and initializing it if necessary;
for each of the identifiers specified in the import clauses:
- check if the imported module has an attribute by that name
- if not, attempt to import a submodule with that name and then check the imported module again for that attribute
The only thing I can see for the second option is that you will need as many lines as things you want to import. For example :
import foo.bar as bar import foo.tar as tar import foo.zar as zar
Instead of simply doing :
from foo import bar, tar, zar
The difference between
import module and
from module import is mainly subjective. Pick the one you like best and be consistent in your use of it. Here are some advantage of both to help you decide.
advantage of import
- Less maintenance of your import statements.
- Don’t need to add any additional imports to start using another item from the module
advantage of from torch import nn
- Less typing to use the nn
- More control over which items of a module can be accessed