Introduction

The usual Python tool for deleting a folder and everything inside it is shutil.rmtree. It removes files and subdirectories recursively, which makes it convenient but also dangerous if you do not validate the path first.

The Standard Way: shutil.rmtree

For most cases, this is the correct solution:

1import shutil
2
3target = "/tmp/example-folder"
4shutil.rmtree(target)

That deletes the directory and all nested contents. It is the recursive equivalent of "remove this tree entirely."

If you prefer pathlib, the deletion call is still done through shutil:

1from pathlib import Path
2import shutil
3
4target = Path("/tmp/example-folder")
5shutil.rmtree(target)

Add Safety Checks Before Deleting

Recursive deletion deserves guard rails. In production scripts, validate the path before removing it.

1from pathlib import Path
2import shutil
3
4target = Path("/tmp/example-folder")
5
6if target.exists() and target.is_dir():
7    shutil.rmtree(target)

That avoids obvious failures such as trying to delete a missing path or accidentally targeting a file.

In more sensitive code, you may want stronger checks, such as confirming that the target is inside a known working directory.

Handle Errors Cleanly

Sometimes deletion fails because of permissions, open files, or read-only content. Wrap the call if the script needs to recover gracefully.

1import shutil
2
3try:
4    shutil.rmtree("/tmp/example-folder")
5except FileNotFoundError:
6    print("Folder already gone")
7except PermissionError as exc:
8    print(f"Permission problem: {exc}")

This is often better than manually walking the directory tree unless you truly need custom deletion logic.

Consider a Dry-Run Step for Destructive Scripts

If the target path comes from user input or from an automated job, printing what would be deleted before calling rmtree is often worth the extra line of code.

1from pathlib import Path
2
3target = Path("/tmp/example-folder")
4print(f"About to delete: {target}")

That is not a replacement for safety checks, but it can prevent accidental deletion when the path is wrong or unexpectedly broad.

When You Might Need Custom Recursion

Manual recursion is still useful when you need selective cleanup instead of full removal. For example, you might want to delete only cache files or skip a protected subdirectory. In that case, os.walk() or Path.rglob() gives you more control than shutil.rmtree.

That is a different problem from "delete this whole folder tree," and it is worth keeping those two jobs mentally separate. Choosing the wrong tool there is a common source of needless complexity. It is also a common source of accidental bugs. Simple deletion code is usually the safest deletion code. That is especially true in maintenance scripts.

Why Manual Recursion Is Rarely Necessary

You can write your own recursive deletion with os.walk() or pathlib.iterdir(), but the standard library already solved the core problem. Manual recursion is usually only worth it when you need custom logging, selective deletion, or special handling for certain file types.

For ordinary "remove this directory tree" work, shutil.rmtree is the simplest and clearest answer.

Common Pitfalls

• 'shutil.rmtree is destructive, so validate the target path before calling it.'
• Deleting the wrong directory is the real risk, not the recursion itself.
• Permission errors and read-only files can still stop the removal.
• 'os.rmdir() removes only empty directories, so it is not a replacement for recursive deletion.'

Summary

• Use shutil.rmtree to delete folders recursively in Python.
• Add existence and type checks if the path may be invalid or user-provided.
• Catch exceptions when the script needs to handle missing folders or permission failures.
• Avoid manual recursion unless you need custom deletion behavior.