# Python pathlib: come funziona questo modulo e quali vantaggi offre?

Il modulo Python `pathlib` è un metodo molto efficace per interagire con i percorsi del file system in questo linguaggio di programmazione. In particolare, oltre alla maggiore facilità d’uso, un grande vantaggio di questo modulo è la maggiore concisione del codice.

## Che cos’è Python `pathlib`?

Nell’apprezzato [linguaggio di programmazione](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/quale-linguaggio-di-programmazione-imparare/) Python sono disponibili diversi metodi per lavorare con i percorsi del file system. A partire dalla versione 3.4, Python dispone di `pathlib`, un ulteriore strumento molto utile e completo per **interagire con i percorsi o “path” indipendentemente dal sistema operativo**.

Il modulo è particolarmente utile se non vuoi soltanto leggere o modificare i percorsi, ma anche eseguire ulteriori attività e fasi di lavoro. Tra le altre cose, esso consente anche di creare e copiare singoli file e parti di essi. Queste operazioni sono agevolate soprattutto dall’interfaccia generale di Python `pathlib`. Il modulo **fa parte della libreria standard** e sostituisce o combina numerosi altri metodi.

## Rappresentazione dei percorsi orientata agli oggetti

Uno dei grandi vantaggi del modulo Python `pathlib` è che consente agli utenti di rappresentare i percorsi non più sotto forma di stringhe, bensì in modo [orientato agli oggetti](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/programmazione-orientata-agli-oggetti-con-python/). Mentre l’approccio precedente risultava spesso scomodo e richiedeva di utilizzare più istruzioni anche per compiti semplici, la sintassi del nuovo modulo è stata **notevolmente semplificata**. Poiché di solito lavorerai con la classe `Path`, ti consigliamo di importarla prima di lavorare su un progetto. In questo modo potrai scrivere codice più compatto nelle fasi successive. Per l’importazione è sufficiente utilizzare il seguente comando:

```python
from pathlib import Path
```

Per creare un’istanza `Path` puoi utilizzare subito Python `pathlib`. A tal fine è utile il seguente codice, che contiene i due componenti “colori” e “blu.txt”. Con un semplice comando viene quindi creata una nuova istanza:

```python
from pathlib import Path
blu = Path("colori", "blu.txt")
print(blu)
```

Il risultato dovrebbe essere quindi simile a questo:

```python
colori/blu.txt
```

Python inserisce quindi il separatore del sistema operativo tra le due parti del risultato. Nel nostro esempio si tratta di una barra obliqua rivolta verso destra come “/”, ma l’output su un computer Windows potrebbe invece presentare una barra rovesciata o backslash come “\\”. [Linux](https://www.ionos.it/digitalguide/server/know-how/linux-lalternativa-conveniente-a-windows/) e macOS utilizzano invece la barra obliqua normale.

## Apertura di cartelle con Python `pathlib`

Dopo aver importato `Path`, è possibile utilizzare i diversi metodi della classe per mezzo di Python `pathlib`. Tra questi vi è anche l’accesso a cartelle specifiche. Ad esempio, eseguendo il codice seguente puoi richiamare la tua **attuale cartella di lavoro**:

```python
from pathlib import Path
Path.cwd()
```

Questa possibilità è importante, ad esempio, quando desideri aprire un file nella stessa cartella in cui è in esecuzione lo script corrente.

Inoltre, con Python `pathlib` puoi accedere anche alla **cartella principale** dell’utente corrente. È consigliabile scegliere questa cartella come punto di partenza per poter poi lavorare con i percorsi corrispondenti anche su computer diversi, se necessario. Il codice per farlo è questo:

```python
from pathlib import Path
Path.home()
```

## Accesso per mezzo di una stringa

Invece di iniziare dalla cartella di lavoro o dalla cartella principale, anche con Python `pathlib` puoi comunque continuare a **utilizzare una stringa per gestire** un file o una cartella. Ad esempio, in questo caso il codice si presenterebbe così:

```python
from pathlib import Path
Path(r"C:\Utenti\nome\cartella\file.txt")
```

La stringa viene convertita in un percorso e può essere quindi utilizzata più facilmente. La piccola `r` davanti alla stringa la contraddistingue come una cosiddetta “stringa letterale grezza”. In questo modo si garantisce che la barra rovesciata sia utilizzata effettivamente come tale. In caso contrario è possibile utilizzare la backslash anche per identificare una variabile non stampabile.

## Collegamento di percorsi o stringhe

Un altro metodo per creare un nuovo percorso con Python `pathlib` è collegare i singoli percorsi o le singole stringhe. Per farlo hai due soluzioni.

La prima è utilizzare una singola barra obliqua per collegare due elementi e creare un nuovo percorso. Ad esempio, il codice potrebbe essere questo:

```python
from pathlib import Path
for file_path in Path.cwd().glob("*.txt"):
	nuovo_percorso = Path("esempio") / file_path.name
	file_path.rename(nuovo_percorso)
```

In alternativa puoi utilizzare il metodo `joinpath()` e ottenere lo stesso risultato:

```python
from pathlib import Path
Path.home().joinpath("esempio", "sottocartella", "file.py")
```

## Utilizzo di singoli componenti

Python `pathlib` ti offre anche lo strumento adatto per scomporre un percorso nei suoi componenti e usarli. Il codice seguente riporta alcuni esempi per farlo:

```python
from pathlib import Path
path = Path(r"C:\Utenti\nome\cartella\file.txt")
path
path.anchor
path.name
path.parent
path.parent.parent
path.stem
path.suffix
```

- `.anchor`: tiene conto della parte che precede le cartelle vere e proprie, che può anche variare a seconda del sistema operativo
- `.name`: tiene conto solo del nome del file senza alcun riferimento alla cartella
- `.parent`: tiene conto della cartella in cui si trova un file e, se il percorso stesso è una cartella, viene utilizzata la cartella principale
- `.stem`: tiene conto solo del nome del file senza considerare l’estensione
- `.suffix`: tiene conto solo dell’estensione del file

Il risultati corrispondenti sarebbero quindi i seguenti:

```python
'C:\\'
'file.txt'
WindowsPath('C:/Utenti/nome/cartella')
WindowsPath('C:/Utenti/nome/')
'file'
'.txt'
```

## Lettura o scrittura di file

Sebbene sia possibile scrivere o leggere file anche in altro modo, Python `pathlib` ti permette di semplificare notevolmente il codice. Per illustrare meglio come funziona, creiamo una semplice lista di animali e piante. Ad esempio:

```text
<!-- lista.md ->
# Lista
## Animali
* Cane
* Gatto
* Topo
## Piante
* Rosa
* Margherita
```

Ora sfruttiamo la funzione standard `open()` con Python `pathlib` per filtrare e visualizzare tutti gli animali e le piante della lista. Il relativo codice si presenta così:

```python
from pathlib import Path
path = Path.cwd() / "lista.md"
with path.open(mode="r", encoding="utf-8") as md_file:
	content = md_file.read()
	risultato = [line for line in content.splitlines() if line.startswith("*")
```

## Modifica dei nomi dei file

Per cambiare i nomi dei file con Python `pathlib` sono sufficienti poche righe di codice. Il modulo utilizza il metodo `.with_name()`, che permette di modificare il nome e l’estensione di un file. Il codice da usare segue questo schema:

```python
from pathlib import Path
md_path = Path("/Utenti/nome/cartella/blu.md")
txt_path = md_path.with_name("rosso.txt")
md_path.replace(txt_path)
```

## Copia di file con Python `pathlib`

Anche se path non dispone di un metodo per la copia, è possibile utilizzare `.with_stem()` per duplicare un file. A tal fine viene creato un nuovo nome di file senza modificarne l’estensione. Quello che segue è un esempio di codice per farlo:

```python
from pathlib import Path
source = Path("lista.md")
destination = source.with_stem("nuovo_esempio")
destination.write_bytes(source.read_bytes())
```

## Spostamento di file

È possibile spostare o eliminare file con Python `pathlib`, ma devi ricordare che il sistema non presenterà ulteriori domande di sicurezza. Per questo motivo devi fare attenzione a non perdere informazioni importanti. Per spostare un file, utilizza `.replace()`. Se nel percorso di destinazione è già presente un file con lo stesso nome, quest’ultimo verrà sovrascritto. Anche in questo caso devi assicurarti di aver fatto la scelta giusta. Esiste comunque la possibilità di verificare in anticipo il rischio di perdere informazioni. In generale, il codice da usare è questo:

```python
from pathlib import Path
source = Path("blu.py")
destination = Path("rosso.py")
if not destination.exists():
	source.replace(destination)
```

## Creazione di file vuoti

Utilizza questo codice per creare un **file vuoto** con Python `pathlib`:

```python
from pathlib import Path
filename = Path("nuovo.txt")
filename.exists()
filename.touch()
filename.exists()
filename.touch()
```

Consiglio Dritto alla meta con GitHub: [Deploy Now](https://www.ionos.it/hosting/deploy-now "Deploy Now di IONOS") di IONOS ti permette di utilizzare i deployment automatici in soli tre passaggi. Grazie al principio “push, build and deploy” puoi apportare le modifiche in modo ancora più veloce. Non esitare a contattarci per saperne di più sui nostri diversi piani tariffari.


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/python-pathlib/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/python-pathlib/) for AI/LLM consumption.