Solving problem is about exposing yourself to as many situations as possible like Changes in import statement python3 and practice these strategies over and over. With time, it becomes second nature and a natural way you approach any problems in general. Big or small, always start with a plan, use other strategies mentioned here till you are confident and ready to code the solution.
In this post, my aim is to share an overview the topic about Changes in import statement python3, which can be followed any time. Take easy to follow this discuss.
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.
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))
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).
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.