I don’t understand the following from pep-0404
In Python 3, implicit relative imports within packages are no longer
available – only absolute imports and explicit relative imports are
supported. In addition, star imports (e.g. from x import *) are only
permitted in module level code.
What is a relative import?
In what other places star import was allowed in python2?
Please explain with examples.
For relative imports see the documentation. A relative import is when you import from a module relative to that module’s location, instead of absolutely from
import *, Python 2 allowed star imports within functions, for instance:
>>> def f(): ... from math import * ... print sqrt
A warning is issued for this in Python 2 (at least recent versions). In Python 3 it is no longer allowed and you can only do star imports at the top level of a module (not inside functions or classes).
Relative import happens whenever you are importing a package relative to the current script/package.
Consider the following tree for example:
mypkg ├── base.py └── derived.py
derived.py requires something from
base.py. In Python 2, you could do it like this (in
from base import BaseThing
Python 3 no longer supports that since it’s not explicit whether you want the ‘relative’ or ‘absolute’
base. In other words, if there was a Python package named
base installed in the system, you’d get the wrong one.
Instead it requires you to use explicit imports which explicitly specify location of a module on a path-alike basis. Your
derived.py would look like:
from .base import BaseThing
. says ‘import
base from module directory’; in other words,
.base maps to
Similarly, there is
.. prefix which goes up the directory hierarchy like
..mod mapping to
../mod.py), and then
... which goes two levels up (
../../mod.py) and so on.
Please however note that the relative paths listed above were relative to directory where current module (
derived.py) resides in, not the current working directory.
@BrenBarn has already explained the star import case. For completeness, I will have to say the same ;).
For example, you need to use a few
math functions but you use them only in a single function. In Python 2 you were permitted to be semi-lazy:
def sin_degrees(x): from math import * return sin(degrees(x))
Note that it already triggers a warning in Python 2:
a.py:1: SyntaxWarning: import * only allowed at module level def sin_degrees(x):
In modern Python 2 code you should and in Python 3 you have to do either:
def sin_degrees(x): from math import sin, degrees return sin(degrees(x))
from math import * def sin_degrees(x): return sin(degrees(x))
To support both Python 2 and Python 3, use explicit relative imports as below. They are relative to the current module. They have been supported starting from 2.5.
from .sister import foo from . import brother from ..aunt import bar from .. import uncle
Added another case to Michał Górny’s answer:
Note that relative imports are based on the name of the current module. Since the name of the main module is always “
__main__“, modules intended for use as the main module of a Python application must always use absolute imports.