How to remove hidden files and folders using Python?

Managing hidden files and folders in a directory is an essential part of building cleanup scripts or automation tools. On Windows, hidden files are not prefixed with a dot but instead they are marked using specific file attributes. In this article, we will explore how to remove those hidden files and directories programmatically using Python.

Filtering by Dot Prefix (Unix/Linux/macOS)

On Unix-based systems, the files or folders starting with a dot "." are considered hidden. We can use this naming pattern to filter and remove hidden files ?

import os
import shutil

def remove_hidden_unix(path):
    for filename in os.listdir(path):
        if filename.startswith('.') and filename not in ['.', '..']:
            filepath = os.path.join(path, filename)
            try:
                if os.path.isfile(filepath):
                    os.remove(filepath)
                    print(f"Removed hidden file: {filepath}")
                elif os.path.isdir(filepath):
                    shutil.rmtree(filepath)
                    print(f"Removed hidden directory: {filepath}")
            except PermissionError:
                print(f"Permission denied: {filepath}")

# Create demo files for testing
demo_path = "/tmp/demo"
os.makedirs(demo_path, exist_ok=True)

# Create some hidden files
with open(os.path.join(demo_path, ".hidden_file.txt"), "w") as f:
    f.write("This is a hidden file")

print("Before removal:")
print(os.listdir(demo_path))

remove_hidden_unix(demo_path)

print("After removal:")
print(os.listdir(demo_path))

Before removal:
['.hidden_file.txt']
Removed hidden file: /tmp/demo/.hidden_file.txt
After removal:
[]

Note: This method only works where hidden files follow the dot notation convention.

Using Windows API (ctypes) to Detect Hidden Attributes

In Windows, hidden files are marked using file attributes. We can use the ctypes library to interface with the Windows API and remove hidden items ?

import os
import ctypes
import shutil
import platform

FILE_ATTRIBUTE_HIDDEN = 0x2

def is_hidden_windows(filepath):
    """Check if file is hidden on Windows using ctypes"""
    if platform.system() != "Windows":
        return False
    try:
        attrs = ctypes.windll.kernel32.GetFileAttributesW(str(filepath))
        return attrs != -1 and attrs & FILE_ATTRIBUTE_HIDDEN
    except:
        return False

def remove_hidden_windows(path):
    """Remove hidden files and folders on Windows"""
    for root, dirs, files in os.walk(path, topdown=False):
        # Remove hidden files
        for f in files:
            file_path = os.path.join(root, f)
            if is_hidden_windows(file_path):
                try:
                    os.remove(file_path)
                    print(f"Removed hidden file: {file_path}")
                except PermissionError:
                    print(f"Permission denied: {file_path}")
        
        # Remove hidden directories
        for d in dirs:
            dir_path = os.path.join(root, d)
            if is_hidden_windows(dir_path):
                try:
                    shutil.rmtree(dir_path)
                    print(f"Removed hidden folder: {dir_path}")
                except PermissionError:
                    print(f"Permission denied: {dir_path}")

# Note: This example requires Windows to run properly
if platform.system() == "Windows":
    remove_hidden_windows("C:\temp\demo")
else:
    print("This method is Windows-specific")

This method is Windows-specific

Cross-Platform Solution Using pathlib

The pathlib module provides a modern object-oriented approach. We can combine both methods for cross-platform compatibility ?

from pathlib import Path
import platform
import shutil
import os

def is_hidden_file(path):
    """Check if file is hidden (cross-platform)"""
    path = Path(path)
    
    # Unix/Linux/macOS: check for dot prefix
    if path.name.startswith('.') and path.name not in ['.', '..']:
        return True
    
    # Windows: check file attributes (if on Windows)
    if platform.system() == "Windows":
        try:
            import ctypes
            attrs = ctypes.windll.kernel32.GetFileAttributesW(str(path))
            return attrs != -1 and attrs & 0x2
        except:
            return False
    
    return False

def remove_hidden_cross_platform(path):
    """Remove hidden files and folders (cross-platform)"""
    path = Path(path)
    
    for item in path.rglob('*'):
        if is_hidden_file(item):
            try:
                if item.is_file():
                    item.unlink()
                    print(f"Removed hidden file: {item}")
                elif item.is_dir():
                    shutil.rmtree(item)
                    print(f"Removed hidden folder: {item}")
            except PermissionError:
                print(f"Permission denied: {item}")

# Demo setup
demo_path = Path("/tmp/cross_platform_demo")
demo_path.mkdir(exist_ok=True)

# Create a hidden file for demonstration
hidden_file = demo_path / ".config_file"
hidden_file.write_text("Hidden configuration")

print(f"Current platform: {platform.system()}")
print(f"Files before removal: {[f.name for f in demo_path.iterdir()]}")

remove_hidden_cross_platform(demo_path)

print(f"Files after removal: {[f.name for f in demo_path.iterdir()]}")

Current platform: Linux
Files before removal: ['.config_file']
Removed hidden file: /tmp/cross_platform_demo/.config_file
Files after removal: []

Comparison

Conclusion

Use the cross-platform approach with pathlib for maximum compatibility. For Unix systems, filtering by dot-prefix is sufficient. For Windows systems, use ctypes to access file attributes for proper hidden file detection.