How To Import the Parent Directory to Python Path

Overview of Importing in Python

Before diving into parent directory imports, let’s review some Python import basics:

• The sys.path contains the list of directories Python searches when importing
• By default, it includes the current working directory and the Python install directories
• The import statement is used to import modules and packages
• To import a module in the current directory, just use import module_name
• For a package, import submodules with from package import submodule
• The parent directory is not in sys.path, so imports from it will fail by default

When you attempt to import a module that is not in sys.path, you will get an error like:

ModuleNotFoundError: No module named 'module_name'

To access the parent directory, we need to modify sys.path or use relative imports.

Method 1: Add Parent Directory to sys.path

The most straightforward way to import the parent is to append it to the sys.path.

First, we need to get the full path of the parent directory. We can use the os.path.dirname function to go up one level:

import os
parent_dir = os.path.dirname(os.getcwd())

Then, add this path to sys.path:

import sys  
sys.path.append(parent_dir)

Now modules in the parent directory can be imported normally:

# Parent directory contains module1.py
import module1

print(module1.foo())

This is a simple and explicit method to make the parent directory importable.

However, hard coding the parent path has downsides:

• The code may break if file structure changes
• It needs to be added to every script that needs parent imports

Next, we’ll look at solutions that avoid hardcoded directory paths.

Method 2: Relative Imports

Relative imports allow importing modules in relation to the current location without using absolute paths.

To do a relative import, use dot notation:

from . import module

• . refers to the current directory
• .. indicates the parent directory

For example:

# Current dir is child_dir, parent contains module.py
from .. import module  

module.func()

This will import module.py from the parent directory.

Some things to note with relative imports:

• They only work within packages, not standalone scripts
• The file using relative imports needs a name like __init__.py
• Absolute imports are recommended over relative

While relative imports avoid hardcoded paths, they have limited use cases. Next we’ll look at a technique that works in any file.

Method 3: Create init.py in Parent Directory

Adding an empty init.py file to a directory makes it recognizable as a Python package.

We can take advantage of this to import the parent without path modifications:

# File structure:

parent_dir/
   |-- __init__.py
   |-- module.py

child_dir/
   |-- script.py  

# From child_dir/script.py: 

import parent_dir.module

By making the parent a “package” with init.py, it can be imported like a submodule.

This allows imports from any working directory, without relative imports or sys.path changes.

Some disadvantages to note:

• Clutters parent directory with init.py
• File structure needs to remain consistent
• Other scripts in parent won’t recognize it as package

Adding init.py provides a clean way to access the parent from anywhere. But it has downsides to consider.

Method 4: Set PYTHONPATH Environment Variable

The PYTHONPATH variable contains additional directories to search for imports, like sys.path.

To use it for parent imports:

1. Define PYTHONPATH environment variable

On Linux/Mac:

export PYTHONPATH="/path/to/parent:$PYTHONPATH"

On Windows:

set PYTHONPATH=C:\path\to\parent;%PYTHONPATH%

2. Now parent packages/modules can be imported from any script

# Runs from any working directory
import parent.module

Advantages of using PYTHONPATH:

• Available to all scripts without code changes
• Avoids tampering with sys.path
• Works on any operating system

Some disadvantages:

• Parent path needs to be hardcoded
• Python startup is slower with a large PYTHONPATH
• Environment needs to be configured on each system

Overall, PYTHONPATH provides a robust way to permanently access the parent directory if you don’t mind defining environment variables.

Method 5: Create .pth File in Site Packages Directory

A .pth file is a way to add custom paths to the import search like PYTHONPATH, isolated to a specific Python install.

1. Create a .pth file in the site-packages directory

The site-packages folder can be found within your Python installation. Create a file like parent.pth containing the parent path:

/Users/name/parent_dir

2. Modules can now be imported from the parent

import parent.module

With this .pth approach:

• The parent path is defined only once in .pth
• No environment variable configuration required
• Works the same across operating systems
• Changes are confined to the specific Python install

The main downside is that the custom .pth file will be deleted if you remove or reinstall that Python version. Otherwise, it provides a streamlined way to permanent access the parent directory.

Best Practices When Importing Parent Directory

Based on the techniques discussed, here are some best practices to follow:

• Avoid relative imports when possible – use absolute imports instead
• Minimize tampering with Python path variables like sys.path
• Prefer .pth files or PYTHONPATH over editing sys.path
• Avoid hardcoding file paths – use init.py instead
• Ensure the code works if file structure changes
• Only use parent imports when necessary, not as default
• Import specific parent submodules rather than everything

And some pitfalls to watch out for:

• Don’t overcomplicate things – keep the imports simple
• Beware of circular dependencies between child and parent
• Watch out for name clashes if parent modules have the same names
• Avoid hitting the max recursion depth with nested imports
• Handle exceptions properly when imports fail

Following Python best practices will ensure your parent directory imports are robust and sustainable.

Conclusion

This guide covered several techniques for importing modules and packages from a Python script’s parent directory, including:

• Modifying sys.path to contain the parent
• Using relative imports with dot notation
• Adding init.py to make the parent a package
• Setting PYTHONPATH environment variable
• Creating a .pth file in site-packages

Carefully manage your imports using absolute paths when possible and minimize dependence on relative or parent imports. But when needed, these methods provide ways to reliably access code outside the working directory.

With the ability to import from parent directories, you can better organize code across files and packages while maintaining access between them. Your Python code will be more modular, reusable, and robust.