Gestire i percorsi dei file in Python con pathlib

Introduzione

Quando si parla di gestione dei file in Python, spesso si pensa subito a apertura, lettura e scrittura. In realtà, un aspetto altrettanto importante è la gestione dei percorsi dei file: costruire path in modo corretto, verificare l’esistenza di un file o di una cartella, navigare tra directory, rinominare, spostare e cancellare risorse in maniera sicura.

Per questo compito, la libreria pathlib è oggi la scelta migliore. Introdotta per rendere il codice più leggibile e portabile, permette di lavorare con i percorsi come oggetti, invece di manipolare stringhe manualmente. Questo riduce errori comuni come separatori sbagliati, path concatenati male o incompatibilità tra sistemi operativi.

In questo tutorial vedremo un sotto-argomento molto utile e pratico: gestione dei percorsi e delle operazioni base sui file con pathlib. È un tema fondamentale in progetti reali, ad esempio quando devi organizzare file di configurazione, esportare report, elaborare immagini o spostare documenti tra cartelle.

Codice completo

from pathlib import Path
import shutil

def main():
    # 1) Creiamo un percorso base relativo alla cartella corrente
    base_dir = Path("progetto_demo")
    input_dir = base_dir / "input"
    output_dir = base_dir / "output"

    # 2) Creiamo le cartelle se non esistono
    input_dir.mkdir(parents=True, exist_ok=True)
    output_dir.mkdir(parents=True, exist_ok=True)

    # 3) Creiamo un file di esempio nella cartella input
    file_input = input_dir / "dati.txt"
    contenuto = "Riga 1nRiga 2nRiga 3n"
    file_input.write_text(contenuto, encoding="utf-8")

    # 4) Verifichiamo alcune proprietà del file
    print("File creato:", file_input)
    print("Esiste?", file_input.exists())
    print("È un file?", file_input.is_file())
    print("Dimensione in byte:", file_input.stat().st_size)

    # 5) Leggiamo il contenuto
    testo = file_input.read_text(encoding="utf-8")
    print("nContenuto letto:")
    print(testo)

    # 6) Creiamo un nuovo file elaborato nella cartella output
    file_output = output_dir / "dati_elaborati.txt"
    righe = testo.splitlines()

    # Esempio di trasformazione: numeriamo le righe
    righe_formattate = [f"{i + 1}. {riga}" for i, riga in enumerate(righe)]
    file_output.write_text("n".join(righe_formattate) + "n", encoding="utf-8")

    print("File elaborato creato:", file_output)

    # 7) Rinominare un file
    file_rinominato = output_dir / "dati_finali.txt"
    file_output.rename(file_rinominato)
    print("File rinominato in:", file_rinominato)

    # 8) Copiare il file in un´altra posizione
    copia_dir = base_dir / "backup"
    copia_dir.mkdir(exist_ok=True)
    copia_file = copia_dir / file_rinominato.name
    shutil.copy2(file_rinominato, copia_file)
    print("Copia creata in:", copia_file)

    # 9) Navigare nel path
    print("nInformazioni sul percorso:")
    print("Nome file:", file_rinominato.name)
    print("Estensione:", file_rinominato.suffix)
    print("Nome senza estensione:", file_rinominato.stem)
    print("Cartella padre:", file_rinominato.parent)

    # 10) Pulizia opzionale: cancelliamo i file creati
    # Commenta queste righe se vuoi ispezionare i file manualmente
    # file_input.unlink()
    # file_rinominato.unlink()
    # copia_file.unlink()
    # input_dir.rmdir()
    # output_dir.rmdir()
    # copia_dir.rmdir()
    # base_dir.rmdir()

if __name__ == "__main__":
    main()

Spiegazione

Il cuore dell’esempio è la classe Path del modulo pathlib. Un oggetto Path rappresenta un percorso su disco e offre metodi comodi per lavorare con file e cartelle.

1. Creazione dei percorsi

Nel codice, partiamo da base_dir = Path("progetto_demo"). Questo crea un percorso relativo alla directory corrente. Poi usiamo l’operatore / per costruire sottocartelle:

base_dir / "input"
base_dir / "output"

Questo approccio è molto più pulito rispetto alla concatenazione manuale di stringhe, ad esempio "progetto_demo/input". Inoltre funziona correttamente su Windows, Linux e macOS.

2. Creazione delle cartelle

Il metodo mkdir() permette di creare directory. Nel nostro esempio usiamo:

parents=True per creare anche le cartelle intermedie, se necessarie
exist_ok=True per evitare errori se la cartella esiste già

Questa è una best practice fondamentale nei progetti reali, perché rende lo script più robusto e ripetibile.

3. Scrittura e lettura di un file

Con write_text() scriviamo direttamente una stringa in un file. Con read_text() leggiamo tutto il contenuto come testo. Entrambi i metodi accettano il parametro encoding="utf-8", che è una scelta consigliata per gestire correttamente caratteri accentati e simboli internazionali.

Nel nostro esempio creiamo un file dati.txt, lo leggiamo e poi trasformiamo il contenuto numerando le righe.

4. Controllo dello stato del file

Pathlib offre metodi molto utili per verificare lo stato di un file:

exists(): verifica se il percorso esiste
is_file(): controlla se il percorso è un file
is_dir(): controlla se il percorso è una directory
stat(): restituisce informazioni tecniche, come dimensione e tempi di modifica

Questi controlli sono importanti per evitare eccezioni e gestire casi limite in modo chiaro.

5. Rinominare e copiare file

Il metodo rename() sposta o rinomina un file. Nel nostro esempio, dati_elaborati.txt diventa dati_finali.txt.

Per copiare il file usiamo invece shutil.copy2(). Qui è utile distinguere:

rename(): cambia nome o posizione del file
copy2(): crea una copia mantenendo più metadati possibili

Questa differenza è molto importante quando lavori con backup, archivi o pipeline di elaborazione.

6. Analisi del percorso

Un oggetto Path permette anche di estrarre informazioni utili dal nome del file:

name: nome completo del file
suffix: estensione, ad esempio .txt
stem: nome senza estensione
parent: cartella contenitore

Queste proprietà sono molto comode quando devi classificare file, filtrare estensioni o generare nuovi nomi in modo automatico.

Best practice

Usa pathlib invece delle stringhe per costruire i percorsi: il codice sarà più leggibile e portabile.
Specifica sempre l’encoding quando leggi o scrivi file di testo, preferibilmente utf-8.
Controlla l’esistenza di file e directory prima di operazioni delicate, soprattutto in script che girano in produzione.
Usa mkdir(parents=True, exist_ok=True) per creare cartelle in modo sicuro e idempotente.
Separa chiaramente i file di input, output e backup per evitare sovrascritture accidentali.
Preferisci metodi specifici come read_text() e write_text() per operazioni semplici; usa open() solo quando ti servono controlli più avanzati.
Attenzione a rename(): non crea una copia, ma sposta o rinomina il file.
Pulisci le risorse temporanee solo se sei sicuro che non servano più, soprattutto in ambienti di test o automazione.

Riepilogo

La gestione dei percorsi con pathlib è uno dei modi più eleganti e sicuri per lavorare con i file in Python. Ti consente di creare directory, leggere e scrivere file, verificare lo stato delle risorse e manipolare nomi e percorsi senza complicazioni inutili.

In questo tutorial abbiamo visto un flusso pratico completo:

creazione di cartelle
scrittura di un file di testo
lettura del contenuto
trasformazione dei dati
rinomina e copia del file
analisi delle proprietà del percorso

Se stai sviluppando script, tool di automazione o applicazioni che gestiscono documenti, imparare a usare bene pathlib ti farà risparmiare tempo e bug.

Approfondisci con risorse ufficiali

Documentazione ufficiale di pathlib: https://docs.python.org/3/library/pathlib.html
Documentazione ufficiale di shutil: https://docs.python.org/3/library/shutil.html
Documentazione ufficiale di os: https://docs.python.org/3/library/os.html
Documentazione ufficiale di builtins open(): https://docs.python.org/3/library/functions.html#open

Se vuoi, posso anche scrivere un secondo tutorial su un argomento complementare, ad esempio gestione delle eccezioni nei file oppure lettura e scrittura binaria con Python.

Add as preferred source on Google