Eliminare File e Directory in Python

Questo capitolo illustra ogni modo standard per eliminare file e directory in Python — dal classico modulo os alla moderna API pathlib e al modulo shutil per le directory non vuote. Imparerai anche i pattern sicuri per la gestione degli errori, in modo che il tuo codice si comporti in modo robusto anche quando un file è già stato rimosso o un'autorizzazione è negata.

Eliminare un Singolo File

Usare os.remove()

Il modulo os fa parte della libreria standard di Python e fornisce un'interfaccia portabile alle funzioni del sistema operativo. os.remove() elimina un singolo file. Solleva FileNotFoundError se il percorso non esiste e PermissionError se il processo non dispone delle autorizzazioni necessarie.

Eliminare un file con os.remove()

import os

os.remove("report.txt")

Racchiudi la chiamata in un blocco try/except in modo che il programma gestisca i file mancanti in modo robusto:

Eliminare un file con gestione degli errori

import os

try:
    os.remove("report.txt")
    print("File deleted.")
except FileNotFoundError:
    print("File not found — nothing to delete.")
except PermissionError:
    print("Permission denied.")

Usare pathlib.Path.unlink() (Python 3.4+)

pathlib fornisce un'interfaccia orientata agli oggetti per i percorsi del filesystem. Path.unlink() elimina il file a cui punta il percorso. A partire da Python 3.8 puoi passare missing_ok=True per sopprimere automaticamente FileNotFoundError.

Eliminare un file con pathlib

from pathlib import Path

# Raises FileNotFoundError if the file does not exist
Path("report.txt").unlink()

Eliminare un file silenziosamente se non esiste (Python 3.8+)

from pathlib import Path

Path("report.txt").unlink(missing_ok=True)
print("Done — file deleted or was already absent.")

missing_ok=True è l'alternativa idiomatica di Python 3.8+ al pattern controlla-poi-elimina. Preferiscilo ai controlli con os.path.exists() perché evita una race condition: un altro processo potrebbe eliminare il file tra il controllo e la chiamata di eliminazione.

Verificare l'esistenza prima di eliminare (pattern classico)

Prima che venisse aggiunto missing_ok, l'approccio standard era un controllo con os.path.exists():

Verificare l'esistenza prima di eliminare

import os

if os.path.exists("report.txt"):
    os.remove("report.txt")
else:
    print("File not found.")

Questo funziona bene per gli script dove le race condition non sono un problema, ma missing_ok=True è più elegante nel nuovo codice.

Eliminare una Directory Vuota

os.rmdir() rimuove una directory, ma solo se è vuota. Solleva OSError se la directory contiene file o sottodirectory.

Eliminare una directory vuota

import os

try:
    os.rmdir("empty_folder")
    print("Directory removed.")
except FileNotFoundError:
    print("Directory not found.")
except OSError:
    print("Directory is not empty or cannot be removed.")

Con pathlib, usa Path.rmdir():

from pathlib import Path

Path("empty_folder").rmdir()

Eliminare una Directory Non Vuota

Per rimuovere una directory e tutto ciò che contiene (file, sottodirectory e relativi contenuti), usa shutil.rmtree(). Questo equivale a rm -rf su Unix — è permanente e irreversibile.

Eliminare un albero di directory

import shutil

shutil.rmtree("old_project")
print("Directory and all its contents deleted.")

Aggiungi la gestione degli errori per i casi di errore più comuni:

Eliminare un albero di directory in modo sicuro

import shutil

try:
    shutil.rmtree("old_project")
    print("Deleted successfully.")
except FileNotFoundError:
    print("Directory not found.")
except PermissionError:
    print("Permission denied.")

Il parametro ignore_errors

Passa ignore_errors=True per sopprimere silenziosamente tutti gli errori. Usalo solo quando non ti importa davvero se l'eliminazione è riuscita:

import shutil

shutil.rmtree("old_project", ignore_errors=True)

Eliminare Più File che Corrispondono a un Pattern

Per eliminare tutti i file che corrispondono a un pattern glob, combina pathlib.Path.glob() con unlink():

Eliminare tutti i file .log in una directory

from pathlib import Path

deleted = 0
for log_file in Path(".").glob("*.log"):
    log_file.unlink()
    deleted += 1
print(f"{deleted} log file(s) deleted.")

Per cercare nelle sottodirectory in modo ricorsivo, usa rglob():

Eliminare tutti i file .tmp in un albero di directory

from pathlib import Path

for tmp_file in Path(".").rglob("*.tmp"):
    tmp_file.unlink(missing_ok=True)

L'equivalente con il modulo os usa os.listdir() e os.remove():

Eliminare tutti i file .txt usando os

import os

directory = "."
for filename in os.listdir(directory):
    if filename.endswith(".txt"):
        os.remove(os.path.join(directory, filename))

Verifica sempre quali file corrispondono prima di eseguire un'eliminazione in blocco. Una rapida passata con print() prima del ciclo di eliminazione è una buona abitudine.

Inviare File al Cestino (Eliminazione Reversibile)

os.remove() e Path.unlink() eliminano i file in modo permanente — non è possibile annullare l'operazione. Se hai bisogno di un'eliminazione recuperabile (spostare un file nel Cestino di sistema), installa il pacchetto di terze parti send2trash:

pip install send2trash

import send2trash

send2trash.send2trash("report.txt")
print("File moved to Trash.")

Questo è utile negli strumenti desktop o negli script dove un'eliminazione accidentale sarebbe catastrofica.

Confronto tra i Metodi di Eliminazione

Punti Chiave

• Usa Path.unlink(missing_ok=True) per eliminare un singolo file in Python moderno (3.8+).
• Usa os.rmdir() o Path.rmdir() solo per le directory vuote.
• Usa shutil.rmtree() per rimuovere una directory e tutti i suoi contenuti — verifica prima il percorso.
• Gestisci sempre FileNotFoundError e PermissionError per rendere gli script robusti.
• Preferisci send2trash quando un'eliminazione reversibile è importante.

Capitoli Correlati

• Gestione dei File in Python — apertura, modalità e l'istruzione with
• Leggere File in Python — lettura dei dati dai file
• Scrivere / Creare File in Python — scrittura e creazione di file
• Try Except in Python — gestione robusta delle eccezioni