FileNotFoundError in Python No such file Fix: Causes and Fixes

Python FileNotFoundError

FileNotFoundError is Python's response when a path cannot be resolved to an existing file or directory at the moment the program tries to open it. It is usually a path problem, a working-directory problem, or a timing problem after a file was moved or deleted.

This topic should explain why checking existence first is not always enough, how relative paths depend on the current working directory, and why pathlib makes path handling easier to reason about.

A good page should show both the failing open call and the corrected path strategy, so the reader sees how the error disappears once the location is built deliberately.

What FileNotFoundError Means

FileNotFoundError is raised when an operation resolves a path that does not exist. It is an OSError subtype. Diagnose the exact path, current working directory, relative-path base, filename case, and platform separators before adding fallback behavior.

File Paths

Typo in the file name or path
File was deleted, moved, or renamed
Using a relative path when the working directory is different from expected
Wrong directory separator (backslash vs forward slash on Windows)
File extension mismatch (e.g., data.txt vs data.csv)

Fix File Path

Check the File Path First

# Missing file: data.txt may not exist in this folder
with open("data.txt") as f:  # FileNotFoundError if file doesn't exist
    content = f.read()

# Check the file path before opening
import os

file_path = "data.txt"
if os.path.exists(file_path):
    with open(file_path) as f:
        content = f.read()
else:
    print(f"File not found: {file_path}")

FileNotFoundError Cases

The most common cause is a simple typo in the file name or path. Python is case-sensitive on Linux/macOS, so Data.txt and data.txt are different files. Always verify the exact file name and path.

If a file is deleted, moved, or renamed between when you check for it and when you open it, you get a FileNotFoundError. Use try/except to handle this gracefully in production code.

Relative paths are resolved from the current working directory, which may not be the directory containing your script. This is a common issue when running scripts from a different directory or in automated environments.

When running scripts from an IDE, the working directory may be set to the project root rather than the script's directory. Use pathlib.Path(__file__).parent to always resolve paths relative to the script file itself.

Filename Case Does Not Match

with open("Data.txt") as f:   # FileNotFoundError (file is actually 'data.txt')
    content = f.read()

with open("config.json") as f:  # FileNotFoundError (file is 'config.JSON')

Inspect the Directory Names

import os

#  List files in directory to find exact name
print(os.listdir("."))  # Shows all files in current directory

#  Use the correct case-sensitive name
with open("data.txt") as f:
    content = f.read()

Parent Directory Is Missing

log_file = "/var/log/app.log"
with open(log_file) as f:  # FileNotFoundError if log was rotated/deleted
    data = f.read()

Create the Directory Before Writing

log_file = "/var/log/app.log"

try:
    with open(log_file) as f:
        data = f.read()
except FileNotFoundError:
    print(f"Log file not found: {log_file}")
    data = ""
except PermissionError:
    print(f"No permission to read: {log_file}")
    data = ""

Relative Path Depends on Working Directory

# Script is at /home/user/project/script.py
# data.txt is at /home/user/project/data.txt
# But script is run from /home/user/

with open("data.txt") as f:  # FileNotFoundError - CWD is /home/user/, not /project/

Build the Path from the Script Location

import os
from pathlib import Path

#  Build path relative to the script's location
script_dir = Path(__file__).parent
data_file = script_dir / "data.txt"

with open(data_file) as f:
    content = f.read()

#  Debug: print current working directory
print(f"CWD: {os.getcwd()}")

IDE Runs from a Different Folder

# Works in terminal from project root, fails in IDE or CI
with open("src/config/settings.json") as f:
    config = json.load(f)  # FileNotFoundError in some environments

Resolve the Data File Deliberately

import json
from pathlib import Path

#  Always resolve from the script's location
BASE_DIR = Path(__file__).resolve().parent.parent  # project root
config_path = BASE_DIR / "src" / "config" / "settings.json"

with open(config_path) as f:
    config = json.load(f)

Prevent FileNotFoundError

Use pathlib.Path - The pathlib module provides cross-platform path handling and is the modern way to work with file paths in Python 3.
Use Path(__file__).parent - Build paths relative to the script file to avoid working directory issues.
Always use try/except for file operations - File operations can fail for many reasons (not found, permission denied, disk full). Always handle exceptions.
Use os.path.exists() to check before opening - Verify the file exists before attempting to open it, especially for optional files.
Use forward slashes or pathlib - Forward slashes work on all platforms in Python. Use pathlib.Path for the most portable code.
Print the resolved path when debugging - Use print(Path("data.txt").resolve()) to see the absolute path Python is looking for.
Use open(file, "w") to create files - Opening with mode "w" creates the file if it does not exist, avoiding FileNotFoundError for write operations.

Debug FileNotFoundError

Print the absolute path Python is trying to open.
Check the current working directory and the file name letter case.
Build paths with pathlib when the file is relative to the script.
Create parent folders before writing a new file inside them.

FileNotFoundError checkpoint

Can You Find the File Python Needs?

5 checks

A FileNotFoundError occurs in Python when you try to open, read, or access a file that does not exist at the specified path.
It is the OSError subtype for a missing file or directory path.
This error is common when working with file paths, especially when the working directory or path separators differ between operating systems.
The most common cause is a simple typo in the file name or path.
Python is case-sensitive on Linux/macOS, so Data.txt and data.txt are different files.

Questions About FileNotFoundError

FileNotFoundError is the OSError subtype for a path that does not exist. OSError is broader and covers other operating-system I/O failures such as permission, invalid path, or resource errors.

Use os.path.exists(path) or Path(path).exists() from pathlib. However, for production code, prefer try/except FileNotFoundError since the file could be deleted between the check and the open call.

Open the file with mode "w" (write) or "a" (append): open("file.txt", "w"). This creates the file if it does not exist. For creating parent directories too, use Path("dir/file.txt").parent.mkdir(parents=True, exist_ok=True).

Previous Next