I’m wondering about the preferred way to import packages in a Python application. I have a package structure like this:
project.app1.models project.app1.views project.app2.models
project.app2.models. There are two ways to do this that come to mind.
With absolute imports:
import A.A import A.B.B
or with explicit relative imports, as introduced in Python 2.5 with PEP 328:
# explicit relative import ..A import .B
What is the most pythonic way to do this?
Absolute imports. From PEP 8:
Relative imports for intra-package imports are highly
Always use the absolute package path for all imports.
Even now that PEP 328  is fully implemented in Python 2.5,
its style of explicit relative imports is actively discouraged;
absolute imports are more portable and usually more readable.
Explicit relative imports are a nice language feature (I guess), but they’re not nearly as explicit as absolute imports. The more readable form is:
import A.A import A.B.B
especially if you import several different namespaces. If you look at some well written projects/tutorials that include imports from within packages, they usually follow this style.
The few extra keystrokes you take to be more explicit will save others (and perhaps you) plenty of time in the future when they’re trying to figure out your namespace (especially if you migrate to 3.x, in which some of the package names have changed).
Python relative imports are no longer strongly discouraged, but using absolute_import is strongly suggested in that case.
Please see this discussion citing Guido himself:
“Isn’t this mostly historical? Until the new relative-import syntax
was implemented there were various problems with relative imports. The
short-term solution was to recommend not using them. The long-term
solution was to implement an unambiguous syntax. Now it is time to
withdraw the anti-recommendation. Of course, without going overboard
— I still find them an acquired taste; but they have their place.”
The OP correctly links the PEP 328 that says:
Several use cases were presented, the most important of which is being
able to rearrange the structure of large packages without having to
edit sub-packages. In addition, a module inside a package can’t easily
import itself without relative imports.
Also see almost duplicate question When or why to use relative imports in Python
Of course it still stands as a matter of taste. While it’s easier to move code around with relative imports, that might also unexpectedly break things; and renaming the imports is not that difficult.
To force the new behaviour from PEP 328 use:
from __future__ import absolute_import
In this case, implicit relative import will no longer be possible (eg.
import localfile will not work anymore, only
from . import localfile). For clean and future proof behaviour, using absolute_import is advisable.
An important caveat is that because of PEP 338 and PEP 366, relative imports require the python file to be imported as a module – you cannot execute a file.py that has a relative import or you’ll get a
ValueError: Attempted relative import in non-package.
This limitation should be taken into account when evaluating the best approach. Guido is against running scripts from a module in any case:
I’m -1 on this and on any other proposed twiddlings of the __main__ machinery.
The only use case seems to be running scripts that happen to be living inside a module’s directory, which I’ve always seen as an antipattern.
To make me change my mind you’d have to convince me that it isn’t.
Exhaustive discussions on the matter can be found on SO; re. Python 3 this is quite comprehensive:
Relative imports not only leave you free to rename your package later without changing dozens of internal imports, but I have also had success with them in solving certain problems involving things like circular imports or namespace packages, because they do not send Python “back to the top” to start the search for the next module all over again from the top-level namespace.