How to Import from Parent Directory in Python?

When working on Python projects, it’s common to organize code into multiple files across folders. But what happens if you need to import a file from a parent directory?

By default, Python does not include parent directories in its search path. If you try import utilities from a subfolder and utilities.py is in the parent folder, you’ll likely see this error:

ModuleNotFoundError: No module named 'utilities'

In this guide, we’ll show how to import from a parent directory in Python using the best methods. You’ll learn clear solutions with examples, plus when to use each one.

Why Import from Parent Directory in Python?

Here’s a common folder structure:

project/
├── utilities.py
└── subfolder/
    └── script.py

You want to use functions from utilities.py inside script.py.

Problem?
Python doesn’t automatically search the parent directory of script.py. That’s why you need special methods to import the file.

How Python Imports Work (Quickly)

When you write import module_name, Python searches for that module in:

• The current script’s directory.
• The directories listed in sys.path.
• Installed packages (like ones from pip).

Parent directories are not included unless you manually add them or structure your project as a package.

Methods to Import from Parent Directory in Python

Below are the most common and beginner-friendly ways to import from a parent directory. Let’s go step by step.

Method 1: Add Parent Directory to sys.path

One quick way to make Python recognize a parent directory is to modify the sys.path. The sys.path list determines where Python looks for modules. By adding the parent directory to this list at runtime, you can import the module as if it were in the current folder.

How to do it: In your script, before the import, append the parent directory path to sys.path. For example:

Example:

import sys
import os

# Get the parent directory
parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))

# Add parent directory to sys.path
sys.path.append(parent_dir)

import utilities

Why use it:

• Quick and works in any script.
• Great for small projects.

Drawbacks:

• Temporary. Only affects the running script.
• Can get messy in large projects.

Method 2: Use pathlib (Modern and Clean)

Instead of hardcoding '..', you can use Python’s pathlib library to handle paths more elegantly. The pathlib.Path class provides an object-oriented way to work with file system paths and can easily get the parent directory of the current file.

How to do it: Use Path(__file__).parent.parent to get the parent directory of the current file, then convert it to a string and append/insert to sys.path:

pythonCopyEdit

Example:

import sys
from pathlib import Path

# Get the parent directory
parent_dir = Path(__file__).resolve().parent.parent

# Add parent directory to sys.path
sys.path.append(str(parent_dir))

import utilities

Why use it:

• More readable.
• Works across different operating systems.
• Safer than hardcoding paths.

Method 3: Use sys.path.insert()

Another approach is similar to the above, but using sys.path.insert(). The difference is that insert() lets you specify the position in the search path where the new directory is added.

How to do it: Use index 0 to insert the parent directory at the beginning of the search path:

Example:

import sys
from pathlib import Path

parent_dir = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(parent_dir))

import utilities

Why use it:

• Ensures Python checks your parent directory first.
• Helpful if there are conflicting module names.

Method 4: Use PYTHONPATH Environment Variable

Another way to tell Python where to find modules is by setting the PYTHONPATH environment variable. This is a system-level approach: you add the parent directory to an environment variable, and Python will include that directory in sys.path every time it runs.

How to do it: Set the PYTHONPATH variable to include the path to your parent directory. You can do this in your operating system’s terminal or environment settings. For example:

Example (Linux/macOS):

export PYTHONPATH="/full/path/to/project:$PYTHONPATH"
python subfolder/script.py

Example (Windows):

set PYTHONPATH=C:\full\path\to\project;%PYTHONPATH%
python subfolder\script.py

Why use it:

• No need to modify your code.
• Useful for development setups.

Drawbacks:

• Others running your code must set PYTHONPATH too.
• Can be forgotten easily.

Method 5: Use Packages and __init__.py

Instead of modifying paths in code, you can structure your project in a way that Python can naturally understand the relationships between modules. This involves using an __init__.py file to make directories into packages and then using package imports (including relative imports).

If your parent directory is meant to be a package (or part of one), adding an empty __init__.py file in that directory will tell Python it’s a package. Likewise, ensure there’s an __init__.py in the child directory if you want it to be a sub-package. Then you can use normal import statements.

How to do it: Given our example structure, make sure project/ (the parent directory) contains an __init__.py (it can be empty). Then in subfolder/script.py, do either an absolute or relative import:

Steps:

1. Add an empty __init__.py file in the project/ folder.
2. Make sure you run the script as part of the package.

Example structure:

project/
├── __init__.py
├── utilities.py
└── subfolder/
    ├── __init__.py
    └── script.py

Example import (in script.py):

from .. import utilities

How to run:

python -m project.subfolder.script

Why use it:

• Best for clean, scalable projects.
• Works well for distribution and testing.

Drawbacks:

• You must run scripts as part of the package.
• Requires good project structure.

Method 6: Use importlib (Dynamic Imports)

Python’s importlib library allows you to import a module programmatically from a given file path, which can be useful in certain cases. This method is more advanced and usually not the first choice for simple tasks, but it’s a powerful option. You don’t need to modify sys.path or environment variables; instead, you load the module directly.

How to do it: Use importlib.util.spec_from_file_location to create a module spec from the file, then execute it:

Example:

import importlib.util
from pathlib import Path

module_name = "utilities"
module_path = Path(__file__).resolve().parent.parent / f"{module_name}.py"

spec = importlib.util.spec_from_file_location(module_name, module_path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)

result = module.some_function()

Why use it:

• Works without modifying sys.path.
• Good for dynamic or plugin-based systems.

Drawbacks:

• More complex.
• Less readable for beginners.

Common Import Errors and Fixes

Best Practices

• ✅ Use sys.path hacks for small scripts and quick fixes.
• ✅ Use pathlib for cleaner path handling.
• ✅ Use packages (__init__.py) for large, organized projects.
• ✅ Document if PYTHONPATH needs to be set.
• ❌ Avoid mixing too many methods in one project.
• ❌ Don’t forget about naming conflicts. Avoid module names like random.py or os.py.

Final Thoughts

Importing from a parent directory in Python is a common need. Luckily, Python gives us several ways to solve this:

• Modify sys.path.
• Use pathlib or os.path.
• Set up a package.
• Configure PYTHONPATH.
• Dynamically load with importlib.

For beginners, the easiest solution is modifying sys.path. As your projects grow, packages and environment variables become cleaner and more scalable solutions.

Choose the method that fits your project, and keep your imports clean and clear!