Hvordan sjekke fil- og mappestørrelse i Python?

by
Tweet
Share
Share
Pin
0 Shares

I denne artikkelen lærer du å sjekke størrelsen på en fil eller mappe i Python

Python er et av de mest allsidige programmeringsspråkene. Med den vil du kunne bygge fra et lite CLI-program (kommandolinjegrensesnitt) til en kompleks nettapplikasjon.

En av de mest undervurderte funksjonene er imidlertid muligheten til å samhandle med operativsystemer. Å administrere OS-operasjoner med Python kan spare deg for tonnevis av tid når du oppretter automatiseringsprosesser.

La oss se hvordan Python samhandler med operativsystemet.

Hvordan samhandler Python med operativsystemet?

Ingen kan leve isolert fra sine omgivelser. Det gjelder også i Python, der noen ganger er grunnleggende å samhandle med operativsystemet for å få ting gjort.

Python har flere moduler som lar oss samhandle med OS. De mest brukte er os, sys, pathlib og subprocess.

Siden de er innebygde moduler, trenger du ikke å installere dem med PIP. Du kan importere dem alle med følgende setning:

import os
import sys
import pathlib
import subprocess

Listen nedenfor angir hovedfunksjonaliteten til hver av disse importene:

  • OS: Bærbar måte å bruke systemspesifikk (Avhengig av OS) funksjonalitet på. Det er det riktige valget i de fleste tilfeller med mindre du trenger noe mer avansert
  • Sys: Systemspesifikke parametere og funksjoner. Denne modulen gir tilgang til tolkvariabler og funksjoner. OS-modulen samhandler med operativsystemet og sys samhandler med Python-tolken
  • Pathlib: Avansert banebruk. Lar deg representere filsystemer som objekter, med den relevante semantikken for hvert OS.
  • Underprosess: Utførelse og underprosessbehandling direkte fra Python. Det innebærer å jobbe med stdin, stdout og returkoder. Du kan lære mer om det ved å lese vår Python-underprosessguide.

Det finnes biblioteker på høyt nivå som inkluderer enda mer spesifikk funksjonalitet avhengig av dine behov. Men mesteparten av tiden er du flink til å gå med modulene ovenfor.

Merk: De fleste funksjonene som tilbys av disse modulene vil ha en annen utgang avhengig av operativsystemet ditt. Husk at vanligvis er den beste matchen UNIX og Python.

  Kan du ta Pottermore House Test på nytt?

Nå har du et raskt grep om hvordan Python samhandler med operativsystemet, la oss hoppe inn i metodene for å sjekke fil- og mappestørrelse. Alle de følgende løsningene er tilgjengelige i Fil- og mappestørrelse i Python GitHub-depot

Bruker os.stat().st_size

I denne metoden skal vi bruke stat() funksjon fra os-modulen. Den returnerer mye informasjon om en bestemt sti.

Merk: os.path.getsize()-funksjonen får også jobben gjort. Fordelen med å bruke os.stat().st_size er at den ikke følger simlinks.

Før vi fortsetter, la oss lage en testfil kalt lorem.txt, der vi skal lime inn litt dum tekst. Vi kan besøke a Lorem Ipsum tekstgenerator og lim inn teksten i lorem.txt-filen.

I samme katalog oppretter du en fil med navnet method1.py og limer inn koden nedenfor:

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

La oss bryte ned hva vi gjør med denne koden:

  • I den første linjen importerer vi OS-modulen
  • Størrelsesvariabelen inneholder størrelsen på filen lorem.txt
    • os.stat()-funksjonen returnerer en haug med informasjon relatert til filen
    • St_size-attributtet representerer størrelsen på filen
  • Vi skriver ut størrelsesvariabelen

Prøv å kjøre Python-skriptet. Du vil få et annet resultat avhengig av innholdet i lorem.txt-filen.

Produksjon:

20064

Utgangen er representert i byte. Dette er ikke lesbart i det hele tatt, så la oss humanisere det slik at vi kan få et bedre perspektiv på størrelsen på filen.

Installer først menneskeliggjøre pakken, ved å kjøre følgende kommando i skallet ditt:

pip install humanize

Deretter kan du bruke naturalsize()-funksjonen som konverterer en verdi i byte til lesbar filstørrelse, for eksempel KB, MB, GB eller TB.

import os
from humanize import naturalsize

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

print(size)
print(naturalsize(size))

Først skriver koden ovenfor ut størrelsen på filen i byte og skriver deretter ut resultatet i en lesbar størrelse.

Produksjon:

20064
20.1 kB

Bruker Pathlib

Selv om stilib er designet for å fungere utelukkende med baner, den inneholder noen nyttige funksjoner fra andre moduler som metoder for Path-objekter (Forekomster av Path-klassen).

Opprett en fil method2.py og importer Baneklasse.

from pathlib import Path

Deretter oppretter du et Path-objekt som sender banen til lorem.txt-filen som et argument.

file_ = Path('lorem.txt')

Nå kan du få tilgang til stat()-metoden til Path-klassen. Den fungerer på samme måte som os.stat()-funksjonen, derfor vil du kunne skrive ut størrelsen på filen.

print(file_.stat().st_size)

Produksjon:

20064

Som du ser fikk vi samme resultat som med den første metoden vi brukte. Resultatet ovenfor er også skrevet ut i byte-format, så vi kan bruke humanize-modulen for å gjøre det lesbart.

from pathlib import Path
from humanize import naturalsize

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

print(naturalsize(size))

Denne koden produserer følgende utdata:

20.1 kB

Bruke Unix-kommandoer med underprosess:

Delprosessmodulen lar oss ringe og administrere delprosesser fra Python. Derfor kan vi kjøre hvilken som helst kommando og behandle utdataene direkte i Python.

  Hvordan fjernstyre enhver IR-enhet med HTC One

Merk: Denne metoden fungerer bare hvis du kjører et Unix OS (Linux, Mac)

Åpne en fil method3.py og lim inn koden nedenfor:

from subprocess import run

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

print(process.stdout)

Dykker ned i denne kodebiten:

  • Vi importerer kjøre funksjon fra delprosessmodulen
  • Variabelprosessen inneholder resultatet av å kjøre kommandoen du lorem.txt
    • du er et Linux-verktøy som lar oss få diskplass til en fil
    • capture_output gir oss tilgang til standout (standard output)-attributtet
    • tekst betyr at vi lagrer utdataene som en streng i stedet for byte
  • Vi skriver ut standard utdata av prosessen

Hvis du kjører koden ovenfor, får du følgende utdata:

20      lorem.txt

Som du kan se, gir den oss størrelsen og navnet på filen. Hvis du bare vil ha størrelsen på filen, må du dele utdataene (husk at det er en streng) og skrive ut det første elementet.

from subprocess import run

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

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

print(size)

Produksjon:

20

Denne utgangen er ikke lesbar i det hele tatt. Vi kan utlede at måleenheten som brukes er KB (på grunn av de tidligere metodene), men ingen andre kunne gjette størrelsen på filen.

For å løse dette problemet kan vi bruke flagget -h (lesbare mennesker).

Merk: Du kan få en manual for denne kommandoen ved å kjøre man du, eller du –help.

from subprocess import run

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

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

print(size)

Nå vil utdataene til dette skriptet være mye mer lesbare:

20K

Hvis du vil vite mer om delprosessmodulen og mulige applikasjoner, sjekk ut vår Python-delprosessguide.

Få størrelsen på en mappe rekursivt

Hvis du vil ha størrelsen på en mappe, må du iterere over hver fil som finnes i katalogen og dens underkataloger. Vi gjør det på to måter:

  • Iterering over en sti med pathlib
  • Bruke du-kommandoen med underprosess
  7 gode ressurser for å lære engelsk tegnspråk

Følgende kode vil bruke en bane til en testkatalog inne i hjemmemappen min. Du må erstatte banen til den filen for katalogen du vil ha størrelsen på.

Iterering over en sti med pathlib

La oss se hvordan du kan få størrelsen på en katalog ved å iterere over størrelsene på filene.

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

Denne kodebiten virker litt skummel, la oss bryte ned hva hver del gjør.

  • Importer Path-klassen og naturalsize()-funksjonen
  • Definer get_size()-funksjonen med en parameterbane, som peker til gjeldende katalog som standard.
  • Størrelsesvariabelen er bare en plassholder der vi legger til størrelsen på hver fil
  • Iterer over hver fil i banen
  • Få størrelsen på hver fil og legg den til størrelsesvariabelen
  • Returnerer størrelsesvariabelen på en måte som kan leses av mennesker

Selvfølgelig tester jeg ut funksjonen med en katalog som kun er tilgjengelig på maskinen min. Ikke glem å endre banen til en mappe som finnes på datamaskinen din.

I mitt tilfelle får jeg følgende utgang:

403.4 MB

Bruke du-kommandoen med underprosess

Denne tilnærmingen har noen fordeler:

  • Resultatet er litt mer nøyaktig
  • Det er mye raskere
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)

Vi bruker samme tilnærming som metode 3, men denne gangen får vi størrelsen på en katalog i stedet for en fil.

Produksjon:

481M

Som du kan se disse to måtene å få størrelsen på en mappe på, gir et litt annerledes resultat. Jo større katalogen er, desto større forskjell får du.

Det er opp til deg å velge mellom pathlib eller underprosess tilnærminger. Hvis du vet at du bruker Linux hver gang bruk av underprosess, ellers kan du bruke PathLib -løsningen.

Å oppsummere

Python-resultater er ekstremt nyttige når du samhandler med operativsystemet. Du kan automatisere prosesser og spare mye tid med Python. Hovedmodulene som skal samhandle med operativsystemet er OS, SYS, PATH og underprosess.

I denne opplæringen lærte du:

  • Hvordan Python samhandler med operativsystemet
  • Bruken av innebygde moduler for å utføre OS-operasjoner
  • Hvordan bruke humaniseringsmodulen til å skrive ut menneskelig lesbar
  • For å beregne størrelsen på en fil med 3 tilnærminger
  • For å beregne størrelsen på en katalog rekursivt eller med du-kommandoen