Come controllare le dimensioni di file e cartelle in Python?

In questo articolo imparerai a controllare la dimensione di un file o di una cartella in Python

Python è uno dei linguaggi di programmazione più versatili. Con esso, sarai in grado di creare da un piccolo programma CLI (interfaccia a riga di comando) a una complessa applicazione web.

Tuttavia, una delle sue caratteristiche più sottovalutate è la capacità di interagire con i sistemi operativi. La gestione delle operazioni del sistema operativo con Python può farti risparmiare un sacco di tempo durante la creazione di processi di automazione.

Vediamo come Python interagisce con il sistema operativo.

In che modo Python interagisce con il sistema operativo?

Nessuno può vivere isolato dal proprio ambiente. Questo vale anche in Python, dove a volte è fondamentale interagire con il sistema operativo per fare le cose.

Python ha diversi moduli che ci permettono di interagire con il sistema operativo. I più usati sono os, sys, pathlib e subprocess.

Poiché sono moduli integrati, non sarà necessario installarli con PIP. Puoi importarli tutti con la seguente dichiarazione:

 import os import sys import pathlib import subprocess

L'elenco seguente indica la funzionalità principale di ciascuna di queste importazioni:

• Os: modo portatile di utilizzare funzionalità specifiche del sistema (a seconda del sistema operativo). È la scelta giusta nella maggior parte dei casi, a meno che tu non abbia bisogno di qualcosa di più avanzato
• Sys: parametri e funzioni specifici del sistema. Questo modulo fornisce l'accesso alle variabili e alle funzioni dell'interprete. Il modulo os interagisce con il sistema operativo e sys interagisce con l'interprete Python
• Pathlib: utilizzo avanzato del percorso. Consente di rappresentare i filesystem come oggetti, con la semantica pertinente per ciascun sistema operativo.
• Sottoprocesso: Esecuzione e gestione dei sottoprocessi direttamente da Python. Ciò implica lavorare con i codici stdin , stdout e di ritorno. Puoi saperne di più leggendo la nostra guida ai sottoprocessi Python.

Esistono librerie di alto livello che includono funzionalità ancora più specifiche a seconda delle tue esigenze. Tuttavia, la maggior parte delle volte sei a posto con i moduli di cui sopra.

Nota: la maggior parte delle funzioni fornite da questi moduli avrà un output diverso a seconda del sistema operativo. Ricorda che di solito la migliore corrispondenza è UNIX e Python.

Ora che hai una rapida comprensione di come Python interagisce con il sistema operativo, passiamo ai metodi di controllo delle dimensioni di file e cartelle. Tutte le seguenti soluzioni sono disponibili in Dimensioni file e cartelle nel repository GitHub di Python

Utilizzo di os.stat().st_size

In questo metodo, useremo la funzione stat() dal modulo os. Restituisce molte informazioni su un percorso specifico.

Nota: anche la funzione os.path.getsize() fa il lavoro. Il vantaggio di usare os.stat(). st_size è che non segue i simlink.

Prima di continuare, creiamo un file di test chiamato lorem.txt , in cui incolleremo del testo stupido . Possiamo visitare un generatore di testo Lorem Ipsum e incollare il testo nel file lorem.txt .

Nella stessa directory, crea un file con il nome method1.py e incolla il codice qui sotto:

 import os size = os.stat('lorem.txt').st_size print(size)

Analizziamo cosa stiamo facendo con questo codice:

• Nella prima riga, stiamo importando il modulo os
• La variabile size contiene la dimensione del file lorem.txt
  • La funzione os.stat() restituisce una serie di informazioni relative al file
  • L'attributo st_size rappresenta la dimensione del file
• Stampiamo la variabile dimensione

Prova a eseguire lo script Python. Otterrai un risultato diverso a seconda del contenuto del tuo file lorem.txt .

Produzione:

 20064

L'output è rappresentato in byte. Questo non è affatto leggibile, quindi umanizziamolo in modo da poter avere una prospettiva migliore della dimensione del file.

Innanzitutto, installa il pacchetto humanize, eseguendo il seguente comando nella tua shell:

 pip install humanize

Quindi puoi utilizzare la funzione naturalsize() che converte un valore in byte in una dimensione del file leggibile, ad esempio KB, MB, GB o TB.

 import os from humanize import naturalsize size = os.stat('lorem.txt').st_size print(size) print(naturalsize(size))

All'inizio, il codice sopra stampa la dimensione del file in byte, quindi stampa il risultato in una dimensione leggibile.

Produzione:

 20064 20.1 kB

Utilizzo di Pathlib

Sebbene pathlib sia progettato per funzionare esclusivamente con percorsi, incorpora alcune funzioni utili da altri moduli come metodi di oggetti Path (classe Istanze della Path).

Crea un file method2.py e importa la classe Path.

 from pathlib import Path

Quindi creare un oggetto Path passando il percorso al file lorem.txt come argomento.

 file_ = Path('lorem.txt')

Ora puoi accedere al metodo stat() della classe Path. Funziona allo stesso modo della funzione os.stat() , quindi sarai in grado di stampare la dimensione del file.

 print(file_.stat().st_size)

Produzione:

 20064

Come puoi vedere, abbiamo ottenuto lo stesso risultato del primo metodo che abbiamo usato. Anche il risultato sopra viene stampato in formato byte, quindi possiamo usare il modulo umanizza per renderlo leggibile.

 from pathlib import Path from humanize import naturalsize size = Path('lorem.txt').stat().st_size print(naturalsize(size))

Questo codice produce il seguente output:

 20.1 kB

Utilizzo dei comandi Unix con Subprocess:

Il modulo subprocess, ci permette di chiamare e gestire subprocess da Python. Pertanto possiamo eseguire qualsiasi comando e trattare il suo output direttamente in Python.

Nota: questo metodo funziona solo se stai utilizzando un sistema operativo Unix (Linux, Mac)

Apri un file method3.py e incolla il codice qui sotto:

 from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) print(process.stdout)

Immergendosi in questo pezzo di codice:

• Importiamo la funzione run dal modulo subprocess
• Il processo variabile contiene il risultato dell'esecuzione del comando du lorem.txt
  • du è un'utilità Linux che ci permette di ottenere lo spazio su disco di un file
  • cattura_output ci dà accesso all'attributo standout (output standard)
  • testo significa che stiamo memorizzando l'output come stringa anziché byte
• Stampiamo lo standard output del processo

Se esegui il codice sopra, otterrai il seguente output:

 20 lorem.txt

Come puoi vedere ci sta dando la dimensione e il nome del file. Se vuoi solo ottenere la dimensione del file, dovrai dividere l'output (ricorda che è una stringa) e stampare il primo elemento.

 from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) size = process.stdout.split()[0] print(size)

Produzione:

 20

Questo output non è affatto leggibile. Possiamo dedurre che l'unità di misura utilizzata è KB (a causa dei metodi precedenti), ma nessun altro potrebbe indovinare la dimensione del file.

Per risolvere questo problema, possiamo utilizzare il flag -h (leggibile dall'uomo).

Nota: è possibile ottenere un manuale di questo comando eseguendo man du o du –help .

 from subprocess import run process = run(['du', '-h', 'lorem.txt'], capture_output=True, text=True) size = process.stdout.split()[0] print(size)

Ora l'output di questo script sarà molto più leggibile:

 20K

Se vuoi saperne di più sul modulo dei sottoprocessi e sulle possibili applicazioni, dai un'occhiata alla nostra guida ai sottoprocessi Python.

Ottieni la dimensione di una cartella in modo ricorsivo

Se vuoi ottenere la dimensione di una cartella, dovrai iterare su ogni file presente nella directory e nelle sue sottodirectory. Lo faremo con due metodi:

• Iterazione su un percorso con pathlib
• Utilizzo del comando du con subprocess

Il codice seguente utilizzerà un percorso a una directory di test all'interno della mia cartella home. Dovrai sostituire il percorso di quel file con la directory di cui vuoi ottenere la dimensione.

Iterazione su un percorso con pathlib

Vediamo come è possibile ottenere la dimensione di una directory iterando sulle dimensioni dei file.

 from pathlib import Path from humanize import naturalsize def get_size(path = '.'): size = 0 for file_ in Path(path).rglob('*'): size += file_.stat().st_size return naturalsize(size) test_path = Path.home() / 'Documents/tests/' print(get_size(test_path))

Questo pezzo di codice sembra un po' spaventoso, analizziamo cosa sta facendo ogni parte.

• Importa la classe Path e la funzione naturalsize()
• Definire la funzione get_size() con un parametro path , che punta alla directory corrente per impostazione predefinita.
• La variabile dimensione è solo un segnaposto in cui aggiungeremo la dimensione di ogni file
• Itera su ogni file del percorso
  • Il metodo rglob() restituisce in modo ricorsivo i file che corrispondono al modello
  • rglob('*') , significa che stiamo ottenendo tutti i file all'interno della directory
• Ottieni la dimensione di ogni file e aggiungilo alla variabile dimensione
• Restituisce la variabile dimensione in modo leggibile dall'uomo

Ovviamente sto testando la funzione con una directory disponibile solo nella mia macchina. Non dimenticare di modificare il percorso di una cartella esistente sul tuo computer.

Nel mio caso, ottengo il seguente output:

 403.4 MB

Utilizzo del comando du con Subprocess

Questo approccio presenta alcuni vantaggi:

• Il risultato è un po' più accurato
• È molto più veloce

 from subprocess import run from pathlib import Path test_path = Path.home() / 'Documents/tests/' process = run(['du', '-sh', test_path], capture_output=True, text=True) size = process.stdout.split()[0] print(size)

Utilizziamo lo stesso approccio del metodo 3, ma questa volta otteniamo la dimensione di una directory anziché di un file.

Produzione:

 481M

Come puoi vedere questi due modi per ottenere la dimensione di una cartella, restituisce un risultato leggermente diverso. Più grande è la directory, maggiore sarà la differenza.

Sta a te scegliere tra l' approccio pathlib o il sottoprocesso . Se sai che utilizzerai Linux ogni volta, usa subprocess , altrimenti puoi usare la soluzione pathlib.

Per riassumere

Python risulta estremamente utile quando si interagisce con il sistema operativo. Puoi automatizzare i processi e risparmiare molto tempo con Python. I moduli principali per interagire con il sistema operativo sono os, sys, path e sottoprocesso.

In questo tutorial hai imparato:

• Come Python interagisce con il sistema operativo
• L'utilizzo di moduli integrati per eseguire operazioni sul sistema operativo
• Come utilizzare il modulo umanizza per stampare leggibili dall'uomo
• Per calcolare la dimensione di un file con 3 approcci
• Per calcolare la dimensione di una directory in modo ricorsivo o con il comando du