How to Delete a File or Folder in Python

By the end of this page, you will understand how Python deletes files and directories, when to use os.remove(), os.rmdir(), shutil.rmtree(), and modern pathlib methods, plus how to avoid common deletion mistakes.

Deleting something in Python depends on what kind of path you are deleting.

• A file is deleted differently from a directory.
• An empty directory is deleted differently from a non-empty directory.
• Python provides multiple tools for this, mainly from:
  • os
  • shutil
  • pathlib

The core idea is simple:

• Use file deletion functions for files.
• Use directory deletion functions for folders.
• Use recursive deletion only when you want to remove a folder and everything inside it.

This matters because deleting the wrong path the wrong way causes errors such as:

• FileNotFoundError
• IsADirectoryError
• NotADirectoryError
• OSError when trying to remove a non-empty directory

In real programming, deletion is common when:

• cleaning up temporary files
• removing generated reports
• clearing upload folders
• resetting test environments
• deleting cache directories

Because deletion is destructive, good Python code usually includes checks, clear intent, and error handling.

Think of your filesystem like a house:

• A file is like a single item, such as a book.
• An empty folder is like an empty box.
• A folder with contents is like a box full of smaller boxes and items.

Now imagine three different actions:

• os.remove() or Path.unlink() = throw away one item
• os.rmdir() or Path.rmdir() = throw away an empty box
• shutil.rmtree() = throw away the entire box and everything inside it

If you try to throw away a full box using the "empty box" action, Python stops you. That safety rule prevents accidental data loss.

Core syntax

import os
import shutil
from pathlib import Path

Delete a file

Using os:

import os

os.remove("notes.txt")

Using pathlib:

from pathlib import Path

Path("notes.txt").unlink()

Delete an empty folder

Using os:

import os

os.rmdir("empty_folder")

Using pathlib:

from pathlib import Path

Path("empty_folder").rmdir()

Delete a folder and everything inside it

Example

from pathlib import Path

file_path = Path("report.txt")

if file_path.exists():
    file_path.unlink()
    print("File deleted")
else:
    print("File not found")

Step-by-step

1. from pathlib import Path

   • Imports the Path class for working with filesystem paths.

2. file_path = Path("report.txt")

   • Creates a path object pointing to report.txt.
   • This does not delete anything yet.

3. if file_path.exists():

   • Checks whether the file actually exists.
   • If it does not exist, the else block will run.

4. file_path.unlink()

   • Deletes the file.
   • If report.txt is a normal file, it is removed from the filesystem.

Common practical uses

Cleaning up temporary files

Scripts often create temporary CSV, log, or export files that should be removed after processing.

import os

if os.path.exists("temp.csv"):
    os.remove("temp.csv")

Resetting a cache directory

Applications may clear a generated cache folder before rebuilding it.

import shutil

shutil.rmtree("cache", ignore_errors=True)

Removing uploaded files

A web app may delete old uploads when a user replaces a profile picture.

Cleaning test data

Automated tests often create files and directories, then delete them during teardown.

Deleting generated build output

Development tools may remove folders like dist/, build/, or temporary artifacts before a new run.

In real projects, developers usually do more than call a delete function directly.

Common patterns

Guard clauses

Check the path type before deleting.

from pathlib import Path
import shutil

path = Path("data")

if not path.exists():
    print("Nothing to delete")
elif path.is_file():
    path.unlink()
elif path.is_dir():
    shutil.rmtree(path)

Validation before destructive actions

Programs often make sure the target is inside an expected directory to avoid deleting the wrong location.

from pathlib import Path

base = Path("/safe/workspace").resolve()
target = (base / "old_logs").resolve()

if base in target.parents:
    print("Target is inside workspace")

Error handling

Deletion can fail because of permissions, file locks, or missing paths.

from pathlib import Path

try:
    Path("locked_file.txt").unlink()
 FileNotFoundError:
    ()
 PermissionError:
    ()

1. Using os.remove() on a folder

Broken code:

import os

os.remove("my_folder")

Why it fails:

• os.remove() is for files, not directories.

Use this instead:

import os

os.rmdir("my_folder")

Or, if the folder is not empty:

import shutil

shutil.rmtree("my_folder")

2. Trying to remove a non-empty directory with os.rmdir()

Broken code:

import os

os.rmdir("project")

Why it fails:

• os.rmdir() only removes empty directories.

Fix:

import shutil

shutil.rmtree("project")

Deletion methods in Python

os vs

# Delete a file
import os
os.remove("file.txt")

from pathlib import Path
Path("file.txt").unlink()

# Delete an empty folder
os.rmdir("empty_folder")
Path("empty_folder").rmdir()

# Delete a folder with contents
import shutil
shutil.rmtree("folder_name")

Rules

• os.remove() and Path.unlink() are for files
• os.rmdir() and Path.rmdir() are for empty directories only
• shutil.rmtree() is for directories and all contents
• Deletion can raise exceptions if the path is missing, locked, or protected

Useful checks

path.exists()
path.is_file()
path.is_dir()

Common exceptions

• FileNotFoundError — path does not exist
• PermissionError — not allowed to delete it
• OSError — often happens when directory is not empty or system-level deletion fails

How do I delete a file in Python?

Use os.remove("file.txt") or Path("file.txt").unlink().

How do I delete an empty folder in Python?

Use os.rmdir("folder") or Path("folder").rmdir().

How do I delete a non-empty folder in Python?

Use shutil.rmtree("folder") to remove the folder and everything inside it.

What is the difference between os.remove() and os.rmdir()?

os.remove() deletes files. os.rmdir() deletes empty directories.

Is shutil.rmtree() dangerous?

Yes. It recursively deletes everything inside the target directory, so you should validate the path carefully before using it.

Should I use os or pathlib for deletion?

Both work. pathlib is often easier to read, especially for beginners.

What happens if the file does not exist?

Python usually raises unless you check first or handle the exception.

• pathlib — modern path handling in Python, often used before deleting files or folders
• os module — provides low-level filesystem operations such as file and directory removal
• shutil module — includes recursive directory deletion with rmtree()
• exception handling — important because delete operations can fail for many reasons
• file paths — helps you understand relative vs absolute paths before deleting
• file I/O — related because files are often created, read, and then deleted
• temporary files — common scenario where deletion is part of cleanup logic