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 oferite 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 din depozitul Python GitHub

Folosind os.stat().st_size

În această metodă, vom folosi funcția stat() 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 un generator de text Lorem Ipsum și lipim 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 pachetul humanize, 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

Deși pathlib este proiectat să funcționeze exclusiv cu căi, acesta încorporează câteva 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 clasa Path.

 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 subprocesului ș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 principal. 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
  • Metoda rglob() returnează recursiv fișierele care se potrivesc cu modelul
  • rglob('*') , înseamnă că primim toate fișierele din director
• 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 subprocess , 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. Modulele principale pentru a interacționa 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