Python Check If a File Exists: os.path, pathlib, and try/except

The Short Answer

To check whether a file exists, use os.path.isfile() from the standard library. It returns True when the path names an existing regular file and False otherwise. It never raises an error for a missing path.

import os

# Create one file so the example has something to find.
with open("notes.txt", "w") as f:
    f.write("hello\n")

print(os.path.isfile("notes.txt"))    # True
print(os.path.isfile("missing.txt"))  # False

Paths are relative to the folder the program runs in (the current working directory), unless you pass an absolute path such as /home/ada/notes.txt or C:\Users\Ada\notes.txt.

The rest of this page covers the other ways to ask the question, how they differ, and the case where you should not ask it at all.

os.path.exists vs isfile vs isdir

The os.path module has three related checks, and they answer slightly different questions:

The difference shows up as soon as a directory is involved:

import os

os.makedirs("reports", exist_ok=True)
with open("reports/summary.txt", "w") as f:
    f.write("all good\n")

for path in ["reports", "reports/summary.txt", "reports/old.txt"]:
    print(path, os.path.exists(path), os.path.isfile(path), os.path.isdir(path))

Output:

reports True False True
reports/summary.txt True True False
reports/old.txt False False False

os.path.exists("reports") is True even though reports is a folder. If your code is about to read the path as a file, exists is the wrong check: a directory would pass it, and open("reports") would then fail (with IsADirectoryError on Linux and macOS, PermissionError on Windows). Pick isfile when you mean a file and isdir when you mean a folder.

Two more details about these three os.path functions:

• A symlink is followed. A link that points to a real file counts as a file; a broken link (its target is gone) returns False from all three.
• If Python is not allowed to look inside a folder, the check returns False rather than raising PermissionError. False means "not found or not reachable", not strictly "does not exist".

Checking With pathlib

pathlib is the object-oriented path API in the standard library, and most new code uses it. A Path object has the same three checks as methods:

from pathlib import Path

folder = Path("reports")
folder.mkdir(exist_ok=True)

summary = folder / "summary.txt"
summary.write_text("all good\n")

print(summary.exists())    # True
print(summary.is_file())   # True
print(summary.is_dir())    # False
print(folder.is_dir())     # True
print((folder / "old.txt").exists())  # False

Path.exists(), Path.is_file() and Path.is_dir() behave like os.path.exists, isfile and isdir. The / operator joins path parts with the right separator for the operating system, so folder / "summary.txt" works on Windows, macOS and Linux alike. See file handling for reading and writing through Path objects.

Which one should you use? If the rest of your code already passes Path objects around, stay with pathlib. If you are working with plain strings and os functions, os.path.isfile is just as correct. They give the same answers.

Why Checking First Can Be the Wrong Move

The most common reason to check whether a file exists is to open it afterwards:

import os

if os.path.isfile("config.txt"):
    with open("config.txt") as f:      # the file might be gone by now
        settings = f.read()
else:
    settings = ""

This has a gap. Between the isfile() call and the open() call, another program, another thread, or the user can delete or rename the file. The check said True, the open still fails, and your program crashes with FileNotFoundError anyway. The gap is called a race condition, or "time of check to time of use". It is rare on your own laptop and much less rare on a busy server where several processes share a folder.

The fix is to skip the separate check and let open() be the check. Python raises FileNotFoundError when the file is missing, and you handle that in except:

def read_settings(path):
    try:
        with open(path) as f:
            return f.read().strip()
    except FileNotFoundError:
        return "(no settings file, using defaults)"

with open("config.txt", "w") as f:
    f.write("theme=dark\n")

print(read_settings("config.txt"))
print(read_settings("other.txt"))

Output:

theme=dark
(no settings file, using defaults)

Now there is one operation instead of two, so there is nothing to race against. This style has a name in the Python community: EAFP, "easier to ask forgiveness than permission". The opposite style, checking first, is LBYL, "look before you leap". Python leans towards EAFP for file work because the operating system is the only thing that knows the answer at the moment you open the file.

FileNotFoundError is not the only thing that can go wrong. A path that is a directory raises IsADirectoryError (PermissionError on Windows), and a file you cannot read raises PermissionError. All three are subclasses of OSError, so except OSError: catches every "could not open it" case at once. The exceptions page covers how to choose between catching one specific error and catching a family.

When a Plain Check Is Fine

Checking first is not wrong in every case. It is the right tool when you only need the answer and are not about to act on the file in the next line:

• choosing which message to show ("Found 3 saved games")
• validating a path the user typed before starting a long job
• skipping work that was already done, where a stale answer only costs a repeat

The rule of thumb: if you are going to open, read, write or delete the file, do that inside try. If you only want to know, isfile() or Path.is_file() is fine.

Creating a File Only If It Does Not Exist

The reverse question comes up too: "write this file, but never overwrite an existing one". The obvious version has the same race as before:

if not os.path.exists("report.txt"):
    with open("report.txt", "w") as f:   # another process may create it first
        f.write("new report\n")

Mode "x" (exclusive creation) does both steps in one. It creates the file, or raises FileExistsError if the name is taken:

import os

if os.path.exists("report.txt"):
    os.remove("report.txt")   # start from a clean folder for the demo

for attempt in [1, 2]:
    try:
        with open("report.txt", "x") as f:
            f.write("first version\n")
        print(f"attempt {attempt}: created report.txt")
    except FileExistsError:
        print(f"attempt {attempt}: report.txt already exists, left it alone")

Output:

attempt 1: created report.txt
attempt 2: report.txt already exists, left it alone

For folders, os.makedirs(path, exist_ok=True) and Path(path).mkdir(parents=True, exist_ok=True) create the directory and any missing parents, and do nothing if it is already there. There is no need to call isdir() first.

Common Mistakes

• Using exists() when you mean a file. A directory with the same name passes the check. Use isfile() or Path.is_file().
• Forgetting where relative paths start. "data.txt" is looked up in the current working directory, which is where you launched the program, not necessarily the folder that holds the script. To find a file next to the script, build the path from Path(__file__).parent.
• Checking, then opening. The file can change in between. Open inside try and handle FileNotFoundError.
• Catching every exception. except Exception: around open() also hides typos and bugs in the code that reads the file. Catch FileNotFoundError or OSError.