Skip to content
Tutorial Reference

How to Check if a Directory is Empty in Python

Learn efficient Python methods to check if a directory is empty, including performance-optimized approaches like os.scandir() and pathlib.Path.iterdir() for large or network directories.

Detecting whether a folder contains files is a common automation task. While simple, performance matters significantly when the directory resides on a network drive or contains millions of files.

The Fastest Way: os.scandir()

Use os.scandir() (Python 3.5+). It returns an iterator rather than a list.

  • Performance: Stops scanning as soon as it finds one entry
  • Memory: O(1) space complexity (doesn't load all filenames)
import os

def is_dir_empty(path):
    with os.scandir(path) as it:
        return not any(it)

print(is_dir_empty("my_folder"))

Using pathlib for Readability

pathlib offers a more readable interface while wrapping the underlying OS calls.

from pathlib import Path

def is_empty_pathlib(path):
    p = Path(path)
    try:
        return not any(p.iterdir())
    except FileNotFoundError:
        return True  # Or raise depending on requirements

print(is_empty_pathlib("my_folder"))

The Slow Way: os.listdir()

Avoid this method for large directories. os.listdir() builds a complete list of every filename in memory before you can check its length.

import os

if len(os.listdir("huge_folder")) == 0:
    print("Empty")

Handling Hidden Files

Standard methods count hidden files (like .DS_Store or .gitignore) as content. To treat a folder as empty when it contains only hidden files, filter by filename.

import os

def is_effectively_empty(path):
    with os.scandir(path) as it:
        for entry in it:
            if not entry.name.startswith('.'):
                return False  # Found a visible file
    return True

print(is_effectively_empty("my_folder"))

Checking with Error Handling

Production code should handle common edge cases gracefully.

from pathlib import Path

def check_directory_empty(path):
    directory = Path(path)
    
    if not directory.exists():
        raise FileNotFoundError(f"Directory not found: {path}")
    
    if not directory.is_dir():
        raise NotADirectoryError(f"Path is not a directory: {path}")
    
    try:
        return not any(directory.iterdir())
    except PermissionError:
        raise PermissionError(f"Cannot access directory: {path}")

try:
    if check_directory_empty("/var/log/myapp"):
        print("No log files found")
    else:
        print("Log files present")
except (FileNotFoundError, NotADirectoryError, PermissionError) as e:
    print(f"Error: {e}")

Counting Files Without Loading All Names

When you need the count but want to avoid memory issues, use a generator expression.

from pathlib import Path

def count_items(path, max_count=None):
    """Count items, optionally stopping at max_count."""
    directory = Path(path)
    count = 0
    
    for _ in directory.iterdir():
        count += 1
        if max_count and count >= max_count:
            break
    
    return count

item_count = count_items("downloads", max_count=101)
if item_count > 100:
    print("Directory has more than 100 items")
else:
    print("Directory has NOT more than 100 items")

Performance Comparison

Method Speed Memory Recommendation
os.scandir() Fast Low Best for performance-critical code
pathlib.iterdir() Fast Low Best for readability
os.listdir() Slow High Avoid for large directories

Summary

Use pathlib.Path(p).iterdir() for general scripts where readability matters. Reserve os.scandir() for performance-critical applications or when working with extremely large directories. Always avoid os.listdir() when you only need to check emptiness, as it unnecessarily loads all filenames into memory.

Navigation