How to Check if a File Exists in Python Without Exceptions

By the end of this page, you will understand how to test whether a file exists in Python using os.path.exists(), os.path.isfile(), and pathlib.Path.exists(). You will also learn when each option is appropriate, what pitfalls to avoid, and how this check is used in real programs.

In Python, checking whether a file exists is a common filesystem task. You might want to read a file only if it is present, create a file only if it does not already exist, or validate user input before processing it.

A simple way to do this without try/except is to use built-in filesystem utilities:

• os.path.exists(path) checks whether a path exists at all
• os.path.isfile(path) checks whether the path exists and is a file
• pathlib.Path.exists() checks whether a path exists using the modern object-oriented API
• pathlib.Path.is_file() checks whether the path exists and is a regular file

This matters because a path can exist but still not be a file. For example:

• it could be a directory
• it could be a symbolic link
• it could be a special system path

So if your goal is specifically to check for a file, isfile() or is_file() is often a better choice than exists().

One important note: checking first and then using the file is convenient, but in some real situations the file can change between the check and the actual operation. That is why many production programs still use exception handling when opening files. But if your goal is simply to test existence without try, these functions are the standard approach.

Think of a file path like a street address.

• exists() asks: Does anything exist at this address?
• is_file() asks: Is the thing at this address a file?
• is_dir() asks: Is the thing at this address a folder?

So if you only care whether the address is occupied, use exists(). If you care whether it is specifically a file, use is_file().

Using os.path

import os

path = "report.txt"

if os.path.exists(path):
    print("The path exists")
else:
    print("The path does not exist")

This checks whether report.txt exists, but it does not guarantee that it is a file.

Checking specifically for a file

import os

path = "report.txt"

if os.path.isfile(path):
    print("The file exists")
else:
    print("The file does not exist, or it is not a regular file")

This is often the better choice when you expect a normal file.

Using pathlib

from pathlib import Path

path = Path("report.txt")

if path.exists():
    print("The path exists")
else:
    print("The path does not exist")

Checking specifically for a file with pathlib

from pathlib import Path

path = Path("report.txt")

if path.is_file():
    print("The file exists")
else:
    print("The file does not exist, or it is not a regular file")

pathlib is often easier to read and is commonly preferred in modern Python code.

Consider this example:

from pathlib import Path

path = Path("data.csv")

if path.is_file():
    print("Ready to process the file")
else:
    print("File not found")

Step by step:

1. from pathlib import Path

   • Imports the Path class for working with filesystem paths.

2. path = Path("data.csv")

   • Creates a Path object representing the file name data.csv.
   • This does not open the file.

3. if path.is_file():

   • Python checks the filesystem.
   • If data.csv exists and is a regular file, the condition is True.
   • If it does not exist, or if it is a directory, the condition is False.

4. print("Ready to process the file")

   • Runs only when the file exists as a file.

5. print("File not found")

   • Runs when the file is missing or not a regular file.

Example outcomes:

• If data.csv exists as a file → Ready to process the file
• If data.csv does not exist → File not found
• If data.csv is a folder → File not found

Checking whether a file exists is useful in many practical situations:

• Configuration loading: load config.json only if it is present
• Data import scripts: verify that customers.csv exists before parsing it
• Log processing: skip a step if the log file for a given date has not been created yet
• Backup tools: avoid overwriting an existing backup file by checking first
• CLI programs: validate a filename passed by the user
• Batch jobs: process only files that are available in an input folder

Example in a script:

from pathlib import Path

config_file = Path("config.json")

if config_file.is_file():
    print("Loading configuration...")
else:
    print("Using default settings...")

In real codebases, developers usually use file existence checks in a few common patterns.

Validation before processing

from pathlib import Path

input_file = Path("users.csv")

if not input_file.is_file():
    print("Input file is missing")
else:
    print("Process the file here")

This is a simple validation step before doing work.

Guard clauses

A guard clause exits early when a required file is missing.

from pathlib import Path

def load_data(filename):
    path = Path(filename)

    if not path.is_file():
        return None

    return path.read_text()

Configuration fallback

from pathlib import Path
import json

config_path = Path("config.json")

if config_path.is_file():
    config = json.loads(config_path.read_text())
else:
    config = {"debug": False}

Important production note

Even though existence checks are useful, many developers still use try/except when actually opening the file, because a file may be deleted, renamed, or locked after the check. So a common real pattern is:

• check first for user-friendly logic
• still handle errors when performing the real file operation

1. Using exists() when you really need a file

Broken example:

from pathlib import Path

path = Path("my_folder")

if path.exists():
    print("This must be a file")

Problem:

• exists() returns True for both files and directories.

Better:

if path.is_file():
    print("This is a file")

2. Forgetting to import the module

Broken example:

if os.path.exists("report.txt"):
    print("Found it")

Problem:

• os was never imported.

Fix:

import os

3. Assuming the file will still exist later

Broken idea:

from pathlib import Path

path = Path("data.txt")

if path.is_file():
    content = path.read_text()

Problem:

• The file may disappear between the check and the read.

Safer real-world approach:

from pathlib import Path

path = Path("data.txt")

try:
    content = path.read_text()
except FileNotFoundError:
    content = ""

Even if your original goal is to avoid exceptions for checking, it is important to know this limitation.

4. Confusing relative and absolute paths

If you check "report.txt", Python looks in the current working directory, not necessarily the folder where your script is saved.

Helpful debugging:

from pathlib import Path

path = Path("report.txt")
print(path.resolve())

5. Using string methods instead of filesystem methods

Broken example:

filename = "report.txt"
if ".txt" in filename:
    print("The file exists")

Problem:

• This only checks the text of the name, not the filesystem.

Use exists() or is_file() instead.

os.path vs pathlib

Checking first vs just opening the file

import os
os.path.exists(path)      # True if path exists
os.path.isfile(path)      # True if path exists and is a file

from pathlib import Path
p = Path(path)
p.exists()                # True if path exists
p.is_file()               # True if path exists and is a file
p.is_dir()                # True if path exists and is a directory

Quick rules

• Use exists() when you care whether anything is there.
• Use is_file() when you need a regular file.
• exists() can return True for directories.
• Relative paths are checked from the current working directory.
• pathlib is a modern and readable choice.
• In production code, file checks do not fully replace error handling during actual file access.

How do I check if a file exists in Python?

Use os.path.isfile(path) or Path(path).is_file() if you specifically want to know whether a file exists.

Can I check file existence without try and except?

Yes. Use os.path.exists(), os.path.isfile(), Path.exists(), or Path.is_file().

What is the difference between exists() and is_file() in Python?

exists() checks whether any path exists. is_file() checks whether the path exists and is a regular file.

Is pathlib better than os.path?

For many beginners and modern codebases, pathlib is easier to read and write. Both are valid.

Does exists() return True for folders?

Yes. If a directory exists at that path, exists() returns True.

Why do some programs still use try/except when working with files?

Because a file can change after you check it. Exception handling is still the safest way to handle actual file operations.

How do I check if a directory exists instead of a file?

Use os.path.isdir(path) or Path(path).is_dir().

• pathlib — Modern Python path handling with methods like exists() and is_file().
• os.path — Traditional Python module for checking paths, files, and directories.
• File I/O — Reading from and writing to files after validating their paths.
• Exceptions — Important for safely handling file access errors in real programs.
• Relative vs absolute paths — Helps explain why a file may not be found.
• Directories and folders — Useful because a path may exist but not be a file.