Skip to main content

How to Check Directory Existence Safely in Python

When performing file system operations in Python, verifying that a target directory exists is a fundamental step. However, a simple check can be misleading: a path might exist but point to a file instead of a directory, or permissions might prevent access.

This guide explores how to robustly check for directory existence using the modern pathlib module and the traditional os module, while also handling potential errors like permissions and race conditions.

Understanding the Check: Exists vs. Is Directory​

A common mistake is checking only if a path exists. In Linux and Windows, a path can refer to a file, a directory, or a symbolic link. To be "safe," you must verify two things:

  1. Does the path exist?
  2. Is the path actually a directory?

Introduced in Python 3.4, pathlib offers an object-oriented approach to filesystem paths. It is generally preferred over os.path for modern Python code.

Using Path.is_dir()​

The .is_dir() method is the most robust check. It returns True only if the path exists and is a directory.

from pathlib import Path

# Define the path
folder_path = Path("data_backup")

# ✅ Correct: Checks existence AND ensures it is a directory
if folder_path.is_dir():
    print(f"Success: '{folder_path}' exists and is a directory.")
else:
    print(f"Check failed: '{folder_path}' does not exist or is not a directory.")

The Pitfall of .exists()​

Using .exists() alone is insufficient if your code relies on the path being a folder.

from pathlib import Path

# Assume 'report.txt' is a file that exists
path_to_file = Path("report.txt")

# ⛔️ Risky: This returns True even though it is a file, not a directory
if path_to_file.exists():
    print("Path exists (but might crash if treated as a folder).")

# ✅ Safe: This returns False because it is not a directory
if path_to_file.is_dir():
    print("This will not print.")
tip

pathlib is cross-platform. It handles operating system differences (like forward slashes vs. backslashes) automatically.

Method 2: Using os.path (Legacy)​

If you are maintaining older codebases or prefer the procedural style, the os module provides similar functionality.

Using os.path.isdir()​

Like pathlib, os.path.isdir() checks both existence and type.

import os

path = "data_backup"

# ✅ Correct: Checks if path exists and is a directory
if os.path.isdir(path):
    print(f"Directory '{path}' found.")
else:
    print(f"Directory '{path}' not found.")
note

os.path.exists(path) returns True for both files and directories. Always prefer os.path.isdir(path) when you specifically need a folder.

Handling Permissions and Race Conditions​

Checking for existence is often a precursor to performing an action (like creating a file or reading a directory). In these cases, simply checking if exists: is not enough due to Race Conditions (the state might change between the check and the action) or Permissions.

The "Easier to Ask Forgiveness than Permission" (EAFP) Principle​

Instead of checking if a directory exists before creating it, it is often safer to try creating it and handle the error if it already exists.

import os

path = "new_secure_folder"

try:
    # ✅ Safe: Tries to create the directory
    # exist_ok=False raises FileExistsError if it exists (default behavior)
    os.makedirs(path, exist_ok=False)
    print("Directory created successfully.")

except FileExistsError:
    print("Directory already exists.")

except PermissionError:
    print("Error: You do not have permission to create this directory.")

except OSError as e:
    print(f"System error occurred: {e}")

Checking Read Permissions​

If you need to verify you can actually read the directory, use os.access.

import os

path = "/root/secret_folder" # Example protected path

if os.path.isdir(path):
    # ✅ Check for Read permissions
    if os.access(path, os.R_OK):
        print("Directory exists and is readable.")
    else:
        print("Directory exists, but READ permission is denied.")
else:
    print("Directory does not exist.")
warning

Be careful with Race Conditions. Just because os.access returns True doesn't guarantee the file won't be deleted or locked by another process a millisecond later. Exception handling (try...except) is always the safest final guard.

Conclusion​

To check directory existence safely in Python:

  1. Prefer pathlib.Path.is_dir() for modern, readable code.
  2. Use os.path.isdir() for legacy scripts.
  3. Avoid exists() unless you truly don't care if the target is a file or a directory.
  4. Use try...except blocks when performing operations to handle permissions and race conditions gracefully.

Table of Contents