Absolute vs. explicit relative import of Python module

Question

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.app1.views imports project.app1.models and 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 from .. import A from . import B 

What is the most pythonic way to do this?

Answer 1

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 in Python 3