How to delete the contents of a folder?

python

file-system

pathlib

shutil

byNikita Barsukov·Dec 19, 2024

The fastest way to clear a directory in Python is using the shutil.rmtree function. It deletes the directory and everything inside it. You can then recreate the empty directory with os.mkdir. Here's this method in Python code:

import os, shutil

def obliterate_folder(path):
    # Gone with the wind... 💨
    shutil.rmtree(path)  
    os.makedirs(path)  # A Phoenix from the ashes 🐦

obliterate_folder('/path/to/my_stuff')

By calling obliterate_folder, you can erase and regenerate /path/to/my_stuff in one swift move!

Safety first: permissions and checks

Before we shutil.rmtree things into oblivion, let's put on our safety goggles 🥽 and earmuffs 🎧. We're going to confirm that the folder exists, check our write permissions, and ensure we're not deleting crucial data. Here's a more cautious approach:

import os, shutil, pathlib

def cautious_folder_purge(folder_path):
    if not os.path.isdir(folder_path):
        raise ValueError("Hold up, that's no folder!")  
    if not os.access(folder_path, os.W_OK):
        raise PermissionError("Hal 9000 says: 'I'm sorry Dave, I can't let you do that.'")
    for kid in os.scandir(folder_path): 
        if kid.is_file() or kid.is_symlink():
            kid.unlink()   # Bye bye, file!
        else:
            shutil.rmtree(kid, onerror=oops_handle) 

def oops_handle(func, path, exc_info):
    print(f'Error burning {path}: {exc_info[1]}')

Advanced cleanup techniques using standard libraries

Now that we're wearing our safety gear, let's get into some advanced techniques and troubleshooting tricks. We'll be using standard libraries to ensure cross-platform compatibility.

Deep folder cleanup

You've got a folder that's deeper than the Mariana Trench 🌊. For deep folder cleanup, we can use the os.walk function, set topdown=False, and start from the bottom, Drake style 🎵.

import os, shutil

def deep_clean_folder(folder_path):
    for root, dirs, files in os.walk(folder_path, topdown=False):
        for name in files:
            target_file = os.path.join(root, name)
            os.unlink(target_file)  # Got 'em 🎯
        for name in dirs:
            target_dir = os.path.join(root, name)
            shutil.rmtree(target_dir)  # Get out of my swamp! 🏊

deep_clean_folder('/path/to/closet_of_secrets')

Using patterns to clean up

You don't want to nuke the entire folder, just the .tmp files? Try file pattern matching with glob.glob:

import glob, os, shutil

def pattern_clean_folder(folder_path, pattern="*"):
    for path_object in glob.glob(os.path.join(folder_path, pattern)):
        if os.path.isfile(path_object) or os.path.islink(path_object): 
            os.unlink(path_object)  # Fly, you file! 🦜
        else:
            shutil.rmtree(path_object)  # I said LEAVE! 👟

pattern_clean_folder('/path/to/cluttered_cupboard', "*.tmp")

Clean-up using pathlib

A modern, object-oriented way of dealing with the file system in Python is pathlib. Let's use it:

from pathlib import Path

def clean_folder_pathlib(folder_path):
    folder = Path(folder_path)
    for item in folder.iterdir():
        if item.is_file() or item.is_symlink():
            item.unlink()  # Begone, foul file or pretender symlink🧛‍♀️!
        else:
            shutil.rmtree(item)  # You have outstayed your welcome, directory 🏰.

clean_folder_pathlib('/path/to/my_Coursera_courses')

Beyond the basics: practical solutions for common pitfalls

When embarking on the deletion journey, keep these practical solutions in mind for troubleshooting common pitfalls.

The stubborn files

Every family has its black sheep 🐏. So does every file family. When files refuse to be deleted due to open handles or permission issues, retry the deletion or consider sending them to trash instead of permanently erasing them.

Deleting large directories

Deleting a really large directory can be like waiting for paint to dry 🎨💤. With the help of progress bars or asynchronous deletion, your users don't have to twiddle their thumbs.

Preserving Directory Structure

If you need to maintain the integrity of your directory structure, empty out the subdirectories, instead of deleting them. Here's a recursive approach:

import os, shutil

def preserve_structure_folder_clean(folder_path):
    for root, dirs, files in os.walk(folder_path):
        for file in files:
            target_file = os.path.join(root, file)
            os.unlink(target_file)  # Keep the joy, lose the files 📦
        for dir in dirs:
            target_dir = os.path.join(root, dir)
            for item in os.listdir(target_dir):
                item_path = os.path.join(target_dir, item)
                if os.path.isdir(item_path):
                    shutil.rmtree(item_path)  # Empty out, but keep the shell 🐢
                else:
                    os.unlink(item_path)  

preserve_structure_folder_clean('/path/to/closet_of_dreams')