Import a module from a directory (package) one level up

Question

What is the right way in Python to import a module from a directory one level up? The directory is a Python package with all these modules and I have a sub directory with code that needs these modules.

The following works just fine, but that is just a hack. I'd like a recommended / pythonic way.

import sys
sys.path.append("../")
from fruit import Fruit
print("OK")

The directory structure:

pkg1
   __init__.py  
   fruit.py  
   +sub_pkg
      __init__.py
      recipe.py

contents of fruit.py

class Fruit:
   def get_name(self):
       print("Fruit name")

contents of sub_pkg/recipe.py .. just a single import line:

from fruit import Fruit

When I run :

python recipe.py

it gives the following error.

Traceback (most recent call last):
  File "recipe.py", line 2, in <module>
    from fruit import Fruit
ImportError: No module named fruit

I also tried: from pkg1.fruit import Fruit , does not work. Also looked at other similar questions .. python -m recipe.py or python -m sub_pkg/recipe.py did not work.

Answer 1

In your main file recipe.py add pkg1 path to the PYTHONPATH

sys.path.append('/path/to/pkg1')

Or use a relative path

sys.path.append('../..')

This should allow importing pkg1 from any where in your program.

There is always the option of using relative imports as suggested here, I find using absolute imports more readable and less likely to lead to bugs. Also, in large projects using relative imports will have you constantly calculating path hierarchies while when using absolute imports, it's simple to know you always refer to one root directory.

About relative imports from PEP328 in Python 2.5:

Reading code which relies on relative imports is also less clear, because a reader may be confused about which module is intended to be used. Python users soon learned not to duplicate the names of standard library modules in the names of their packages’ submodules, but you can’t protect against having your submodule’s name being used for a new module added in a future version of Python.

Guido is suggesting using leading dots in relative imports to avoid ambiguous imports as described above, from PEP328 again:

Guido has Pronounced that relative imports will use leading dots. A single leading dot indicates a relative import, starting with the current package. Two or more leading dots give a relative import to the parent(s) of the current package, one level per dot after the first.