How To Import the Parent Directory to Python Path

As a Python programmer, being able to conveniently import modules and packages is essential. Often, you need to import code from the parent directory of your current working directory. However, the parent directory is not in the default Python path, so import statements will fail.

In this comprehensive guide, I will demonstrate how to import the parent directory in Python using code examples. You will learn techniques like:

  • Manipulating the Python sys.path
  • Using relative imports
  • Creating an empty file
  • Setting the PYTHONPATH environment variable
  • Using a .pth file

With the skills this guide provides, you will be able to seamlessly import parent directory code into your Python projects and scripts. Let’s get started!

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  

Now modules in the parent directory can be imported normally:

# Parent directory contains
import module1


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
from .. import module  


This will import 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
  • 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 in Parent Directory

Adding an empty 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:



# From child_dir/ 

import parent_dir.module

By making the parent a “package” with, 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
  • File structure needs to remain consistent
  • Other scripts in parent won’t recognize it as package

Adding 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:


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 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.


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 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.

Leave a Comment