How to delete a file or folder in Python?
Python provides several methods to delete files and folders using the os, shutil, and pathlib modules. The most common approaches include os.remove() for files, os.rmdir() for empty directories, shutil.rmtree() for non-empty directories, and the more modern pathlib.Path.unlink() and pathlib.Path.rmdir() methods for object-oriented file operations.
Contents
- Deleting Files in Python
- Deleting Directories in Python
- Error Handling and Best Practices
- Advanced Deletion Techniques
- Comparing Different Methods
Deleting Files in Python
Using os.remove()
The os.remove() function is the standard way to delete files in Python. It takes a file path as an argument and permanently removes the file.
import os
# Delete a single file
file_path = '/path/to/your/file.txt'
os.remove(file_path)
# Delete multiple files in a directory
directory = '/path/to/directory'
for filename in os.listdir(directory):
file_path = os.path.join(directory, filename)
if os.path.isfile(file_path):
os.remove(file_path)
Important: os.remove() can only delete files, not directories. Attempting to delete a directory will result in a PermissionError or IsADirectoryError.
Using pathlib.Path.unlink()
The pathlib module provides a more modern, object-oriented approach to file operations. The unlink() method is equivalent to os.remove().
from pathlib import Path
# Delete a single file
file_path = Path('/path/to/your/file.txt')
file_path.unlink()
# Delete multiple files using pathlib
directory = Path('/path/to/directory')
for file_path in directory.glob('*'):
if file_path.is_file():
file_path.unlink()
The pathlib approach is generally preferred in modern Python code as it provides better path handling and cross-platform compatibility.
Deleting Directories in Python
Removing Empty Directories
For empty directories, you can use either os.rmdir() or pathlib.Path.rmdir().
# Using os.rmdir()
import os
dir_path = '/path/to/empty/directory'
os.rmdir(dir_path)
# Using pathlib.Path.rmdir()
from pathlib import Path
dir_path = Path('/path/to/empty/directory')
dir_path.rmdir()
Warning: Both methods will fail if the directory is not empty, raising an OSError with the message “Directory not empty”.
Removing Non-Empty Directories
To delete directories that contain files and subdirectories, you need to use shutil.rmtree().
import shutil
# Delete a non-empty directory
dir_path = '/path/to/non-empty/directory'
shutil.rmtree(dir_path)
# Delete with error handling
try:
shutil.rmtree(dir_path)
except OSError as e:
print(f"Error deleting directory: {e}")
The shutil.rmtree() function recursively removes all files and subdirectories within the specified directory, making it powerful but potentially dangerous if used carelessly.
Error Handling and Best Practices
Basic Error Handling
Always implement proper error handling when performing file operations:
import os
from pathlib import Path
# Using try-except with os.remove()
try:
os.remove('/path/to/file.txt')
except FileNotFoundError:
print("File not found")
except PermissionError:
print("Permission denied")
except OSError as e:
print(f"Error: {e}")
# Using pathlib with error handling
file_path = Path('/path/to/file.txt')
try:
file_path.unlink()
except FileNotFoundError:
print("File not found")
except PermissionError:
print("Permission denied")
Advanced Error Handling with Custom Handlers
For more complex scenarios, such as handling locked files or permission issues during recursive deletion, you can use custom error handlers:
import shutil
import os
import stat
def handle_readonly(func, path, exc_info):
"""Handle read-only files by changing permissions"""
os.chmod(path, stat.S_IWRITE)
func(path)
# Delete directory with custom error handling
try:
shutil.rmtree('/path/to/directory', onerror=handle_readonly)
except Exception as e:
print(f"Failed to delete directory: {e}")
Safety Checks
Always verify paths before deletion:
import os
def safe_delete(path):
"""Safely delete a file or directory after verification"""
if not os.path.exists(path):
print(f"Path does not exist: {path}")
return False
if os.path.isfile(path):
try:
os.remove(path)
print(f"File deleted: {path}")
return True
except Exception as e:
print(f"Failed to delete file {path}: {e}")
return False
elif os.path.isdir(path):
try:
shutil.rmtree(path)
print(f"Directory deleted: {path}")
return True
except Exception as e:
print(f"Failed to delete directory {path}: {e}")
return False
else:
print(f"Path is neither file nor directory: {path}")
return False
Advanced Deletion Techniques
Bulk File Operations
Delete multiple files matching a pattern:
import glob
import os
# Delete all .txt files in a directory
directory = '/path/to/directory'
txt_files = glob.glob(os.path.join(directory, '*.txt'))
for file_path in txt_files:
try:
os.remove(file_path)
print(f"Deleted: {file_path}")
except Exception as e:
print(f"Failed to delete {file_path}: {e}")
# Using pathlib for pattern matching
from pathlib import Path
directory = Path('/path/to/directory')
for file_path in directory.glob('*.txt'):
try:
file_path.unlink()
print(f"Deleted: {file_path}")
except Exception as e:
print(f"Failed to delete {file_path}: {e}")
Conditional Deletion
Delete files based on certain conditions:
import os
from pathlib import Path
import time
# Delete files older than 7 days
directory = Path('/path/to/directory'
cutoff_time = time.time() - (7 * 24 * 60 * 60) # 7 days ago
for file_path in directory.glob('*'):
if file_path.is_file():
file_mtime = file_path.stat().st_mtime
if file_mtime < cutoff_time:
try:
file_path.unlink()
print(f"Deleted old file: {file_path}")
except Exception as e:
print(f"Failed to delete {file_path}: {e}")
Interactive Deletion
Prompt user before deletion:
import shutil
from pathlib import Path
def interactive_delete(path):
"""Prompt user before deleting"""
path_obj = Path(path)
if not path_obj.exists():
print(f"Path does not exist: {path}")
return
if path_obj.is_file():
response = input(f"Delete file {path}? (y/N): ")
if response.lower() == 'y':
try:
path_obj.unlink()
print(f"File deleted: {path}")
except Exception as e:
print(f"Failed to delete file: {e}")
else:
response = input(f"Delete directory {path} and all its contents? (y/N): ")
if response.lower() == 'y':
try:
shutil.rmtree(path)
print(f"Directory deleted: {path}")
except Exception as e:
print(f"Failed to delete directory: {e}")
# Example usage
interactive_delete('/path/to/file_or_directory')
Comparing Different Methods
Here’s a comparison of the main deletion methods:
| Method | Module | Purpose | Handles Empty Directories | Handles Non-Empty Directories | Error Handling |
|---|---|---|---|---|---|
os.remove() |
os |
Delete files | ❌ | ❌ | Basic |
os.rmdir() |
os |
Delete empty directories | ✅ | ❌ | Basic |
shutil.rmtree() |
shutil |
Delete non-empty directories | ✅ | ✅ | Advanced |
pathlib.Path.unlink() |
pathlib |
Delete files | ❌ | ❌ | Basic |
pathlib.Path.rmdir() |
pathlib |
Delete empty directories | ✅ | ❌ | Basic |
When to Use Each Method
os.remove()orpathlib.Path.unlink(): Use for simple file deletion in scripts that don’t need advanced path handling.os.rmdir()orpathlib.Path.rmdir(): Use when you know directories are empty and want to fail fast if they’re not.shutil.rmtree(): Use for complete directory removal when you need to delete everything recursively.pathlibmethods: Preferred in modern Python code for better readability, cross-platform compatibility, and object-oriented approach.
Performance Considerations
For performance-critical applications, consider the following:
import time
import os
from pathlib import Path
# Performance test for different methods
def test_performance():
test_file = 'test_file.txt'
# Create test file
with open(test_file, 'w') as f:
f.write('test content')
# Test os.remove()
start = time.time()
os.remove(test_file)
os_time = time.time() - start
# Create test file again
with open(test_file, 'w') as f:
f.write('test content')
# Test pathlib.unlink()
start = time.time()
Path(test_file).unlink()
pathlib_time = time.time() - start
print(f"os.remove(): {os_time:.6f}s")
print(f"pathlib.unlink(): {pathlib_time:.6f}s")
test_performance()
Sources
- How can I delete a file or folder in Python? - Stack Overflow
- How to delete files and folders in Python - Python Engineer
- Delete (Remove) Files and Directories in Python - Pynative
- Delete a directory or file using Python - GeeksforGeeks
- Python Delete File – How to Remove Files and Folders - freeCodeCamp
- How to Delete (Remove) Files and Directories in Python - Linuxize
- How can I delete a file or folder in Python? - SourceBae
- Python Delete a File or Directory: A Complete Guide • datagy
- Delete File or Folder in Python? - Spark By Examples
- Delete Files from Python: 6 Easy Methods Explained – Master Data Skills + AI
Conclusion
In summary, Python offers multiple approaches to delete files and directories, each with specific use cases and advantages. For file deletion, both os.remove() and pathlib.Path.unlink() work well, with the latter being more modern and readable. For directory deletion, use os.rmdir() or pathlib.Path.rmdir() for empty directories and shutil.rmtree() for non-empty ones. Always implement proper error handling and consider using the pathlib module for better cross-platform compatibility and code readability. Remember to verify paths before deletion and implement appropriate safety measures to prevent accidental data loss.