Cum se verifică dimensiunea fișierului și a folderului în Python?

În acest articol, veți învăța să verificați dimensiunea unui fișier sau folder în Python

Python este unul dintre cele mai versatile limbaje de programare. Cu acesta, veți putea construi dintr-un mic program CLI (interfață linie de comandă) la o aplicație web complexă.

Cu toate acestea, una dintre caracteristicile sale cele mai subestimate este capacitatea de a interacționa cu sistemele operative. Gestionarea operațiunilor sistemului de operare cu Python vă poate economisi o mulțime de timp atunci când creați procese de automatizare.

Să vedem cum interacționează Python cu sistemul de operare.

Cum interacționează Python cu sistemul de operare?

Nimeni nu poate trăi izolat de mediul său. Acest lucru se aplică și în Python, unde uneori este fundamental să interacționați cu sistemul de operare pentru a finaliza lucrurile.

Python are mai multe module care ne permit să interacționăm cu sistemul de operare. Cele mai utilizate sunt os, sys, pathlib și subprocess.

Deoarece sunt module încorporate, nu va trebui să le instalați cu PIP. Le puteți importa pe toate cu următoarea instrucțiune:

import os
import sys
import pathlib
import subprocess

Lista de mai jos indică funcționalitatea principală a fiecăruia dintre aceste importuri:

• Os: mod portabil de utilizare a funcționalității specifice sistemului (în funcție de sistemul de operare). Este alegerea potrivită în majoritatea cazurilor, cu excepția cazului în care aveți nevoie de ceva mai avansat
• Sys: Parametri și funcții specifici sistemului. Acest modul oferă acces la variabilele și funcțiile interpretului. Modulul os interacționează cu sistemul de operare și sys interacționează cu interpretul Python
• Pathlib: Utilizare avansată a căii. Vă permite să reprezentați sistemele de fișiere ca obiecte, cu semantica relevantă pentru fiecare sistem de operare.
• Subproces: Execuție și gestionarea subproceselor direct din Python. Aceasta implică lucrul cu codurile stdin, stdout și returnare. Puteți afla mai multe despre acesta citind ghidul nostru de subprocese Python.

Există biblioteci de nivel înalt care includ și mai multe funcționalități specifice, în funcție de nevoile dvs. Cu toate acestea, de cele mai multe ori ești bine să mergi cu modulele de mai sus.

Notă: Majoritatea funcțiilor furnizate de aceste module vor avea o ieșire diferită în funcție de sistemul de operare. Amintiți-vă că, de obicei, cea mai bună potrivire este UNIX și Python.

Acum aveți o înțelegere rapidă a modului în care Python interacționează cu sistemul de operare, să trecem la metodele de verificare a dimensiunii fișierului și a folderului. Toate următoarele soluții sunt disponibile în Dimensiunea fișierului și a folderului în Python Depozitul GitHub

Folosind os.stat().st_size

În această metodă, vom folosi stat() funcția din modulul os. Returnează o mulțime de informații despre o anumită cale.

Notă: Funcția os.path.getsize() termină, de asemenea, treaba. Avantajul utilizării os.stat().st_size este că nu urmează simlink-uri.

Înainte de a continua, să creăm un fișier de testare numit lorem.txt, în care vom lipi un text prost. Putem vizita o Generator de text Lorem Ipsum și lipiți textul în fișierul lorem.txt.

În același director, creați un fișier cu numele method1.py și lipiți codul de mai jos:

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

Să detaliem ce facem cu acest cod:

• În prima linie, importăm modulul os
• Variabila dimensiune conține dimensiunea fișierului lorem.txt
  • Funcția os.stat() returnează o mulțime de informații legate de fișier
  • Atributul st_size reprezintă dimensiunea fișierului
• Tipărim variabila dimensiune

Încercați să rulați scriptul Python. Veți obține un rezultat diferit în funcție de conținutul fișierului dvs. lorem.txt.

Ieșire:

20064

Ieșirea este reprezentată în octeți. Acest lucru nu este deloc lizibil, așa că haideți să-l umanizăm astfel încât să putem avea o perspectivă mai bună asupra dimensiunii fișierului.

Mai întâi, instalați umaniza pachet, rulând următoarea comandă în shell:

pip install humanize

Apoi puteți utiliza funcția naturalsize() care convertește o valoare în octeți în dimensiunea fișierului care poate fi citită, de exemplu, KB, MB, GB sau TB.

import os
from humanize import naturalsize

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

print(size)
print(naturalsize(size))

La început, codul de mai sus tipărește dimensiunea fișierului în octeți, apoi tipărește rezultatul într-o dimensiune care poate fi citită.

Ieșire:

20064
20.1 kB

Folosind Pathlib

Cu toate că calea lib este conceput pentru a lucra exclusiv cu căi, încorporează unele funcții utile din alte module ca metode ale obiectelor Path (Instanțe ale clasei Path).

Creați un fișier method2.py și importați fișierul Clasa de cale.

from pathlib import Path

Apoi creați un obiect Path care trece calea către fișierul lorem.txt ca argument.

file_ = Path('lorem.txt')

Acum, puteți accesa metoda stat() a clasei Path. Funcționează la fel ca și funcția os.stat(), prin urmare veți putea tipări dimensiunea fișierului.

print(file_.stat().st_size)

Ieșire:

20064

După cum puteți vedea, am obținut același rezultat ca și cu prima metodă pe care am folosit-o. Rezultatul de mai sus este, de asemenea, tipărit în format octet, așa că putem folosi modulul humanize pentru a-l face lizibil.

from pathlib import Path
from humanize import naturalsize

size = Path('lorem.txt').stat().st_size

print(naturalsize(size))

Acest cod produce următoarea ieșire:

20.1 kB

Folosind comenzi Unix cu subproces:

Modulul subproces, ne permite să apelăm și să gestionăm subprocesul din Python. Prin urmare, putem rula orice comandă și putem trata rezultatul acesteia direct în Python.

Notă: această metodă funcționează numai dacă rulați un sistem de operare Unix (Linux, Mac)

Deschideți un fișier method3.py și inserați codul de mai jos:

from subprocess import run

process = run(['du', 'lorem.txt'], capture_output=True, text=True)

print(process.stdout)

Scufundarea în această bucată de cod:

• Importăm funcția de rulare din modulul de subproces
• Procesul variabil conține rezultatul rulării comenzii du lorem.txt
  • du este un utilitar Linux care ne permite să obținem spațiul pe disc al unui fișier
  • capture_output ne oferă acces la atributul standout (ieșire standard).
  • text înseamnă că stocăm rezultatul ca șir de caractere în loc de octeți
• Tipărim rezultatul standard al procesului

Dacă rulați codul de mai sus, veți obține următorul rezultat:

20      lorem.txt

După cum puteți vedea, ne dă dimensiunea și numele fișierului. Dacă doriți doar să obțineți dimensiunea fișierului, va trebui să împărțiți rezultatul (rețineți că este un șir) și să imprimați primul element.

from subprocess import run

process = run(['du', 'lorem.txt'], capture_output=True, text=True)

size = process.stdout.split()[0]

print(size)

Ieșire:

20

Această ieșire nu este deloc lizibilă. Putem deduce că unitatea de măsură folosită este KB (din cauza metodelor anterioare), dar nimeni altcineva nu a putut ghici dimensiunea fișierului.

Pentru a rezolva această problemă, putem folosi indicatorul -h (lizibil de om).

Notă: Puteți obține un manual al acestei comenzi rulând man du sau du –help.

from subprocess import run

process = run(['du', '-h', 'lorem.txt'], capture_output=True, text=True)

size = process.stdout.split()[0]

print(size)

Acum rezultatul acestui script va fi mult mai lizibil:

20K

Dacă doriți să aflați mai multe despre modulul subproceselor și aplicațiile posibile, consultați ghidul nostru de subprocese Python.

Obțineți dimensiunea unui folder în mod recursiv

Dacă doriți să obțineți dimensiunea unui folder, va trebui să repetați fiecare fișier prezent în director și subdirectoarele acestuia. O vom face cu două metode:

• Iterarea peste o cale cu pathlib
• Folosind comanda du cu subproces

Următorul cod va folosi o cale către un director de testare din dosarul meu de acasă. Va trebui să înlocuiți calea fișierului respectiv pentru directorul pentru care doriți să obțineți dimensiunea.

Iterarea peste o cale cu pathlib

Să vedem cum puteți obține dimensiunea unui director iterând peste dimensiunile fișierelor.

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))

Această bucată de cod pare puțin înfricoșătoare, să dezvăluim ceea ce face fiecare parte.

• Importați clasa Path și funcția naturalsize().
• Definiți funcția get_size() cu o cale a parametrului, care indică implicit directorul curent.
• Variabila dimensiune este doar un substituent în care vom adăuga dimensiunea fiecărui fișier
• Iterați peste fiecare fișier al căii
• Obțineți dimensiunea fiecărui fișier și adăugați-l la variabila dimensiune
• Returnează variabila dimensiune într-un mod care poate fi citit de om

Desigur, testez funcția cu un director disponibil numai în mașina mea. Nu uitați să schimbați calea către un folder care există pe computer.

În cazul meu, primesc următoarea ieșire:

403.4 MB

Folosind comanda du cu subproces

Această abordare are câteva avantaje:

• Rezultatul este un pic mai precis
• Este mult mai rapid

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)

Folosim aceeași abordare ca metoda 3, dar de data aceasta obținem dimensiunea unui director în loc de fișier.

Ieșire:

481M

După cum puteți vedea, aceste două moduri de a obține dimensiunea unui folder, returnează un rezultat ușor diferit. Cu cât directorul este mai mare, cu atât veți obține mai multă diferență.

Depinde de tine să alegi între abordările pathlib sau subprocesul. Dacă știți că veți folosi Linux de fiecare dată când utilizați subprocesul, altfel puteți utiliza soluția pathlib.

În concluzie

Python are rezultate extrem de util atunci când interacționați cu sistemul de operare. Puteți automatiza procesele și puteți economisi mult timp cu Python. Principalele module care interacționează cu sistemul de operare sunt os, sys, cale și subproces.

În acest tutorial ați învățat:

• Cum interacționează Python cu sistemul de operare
• Utilizarea modulelor încorporate pentru a efectua operațiuni cu sistemul de operare
• Cum să utilizați modulul humanize pentru a imprima lizibil de către om
• Pentru a calcula dimensiunea unui fișier cu 3 abordări
• Pentru a calcula dimensiunea unui director recursiv sau cu comanda du