Sjekk fil- og mappestørrelse i Python: 3 enkle metoder

I denne artikkelen vil du lære hvordan du kan bestemme størrelsen på filer og mapper ved hjelp av Python.

Python er et programmeringsspråk kjent for sin allsidighet. Det kan brukes til å utvikle alt fra enkle kommandolinjeverktøy til komplekse webapplikasjoner.

En ofte oversett funksjon er Pythons evne til å kommunisere direkte med operativsystemet. Denne funksjonen er svært nyttig for å automatisere prosesser og spare verdifull tid.

La oss undersøke hvordan Python interagerer med operativsystemet.

Hvordan interagerer Python med operativsystemet?

Det er sjelden at et program opererer isolert. I Python er det ofte nødvendig å samhandle med operativsystemet for å utføre visse oppgaver.

Python tilbyr flere moduler som gir oss mulighet til å kommunisere med operativsystemet. De mest brukte modulene inkluderer `os`, `sys`, `pathlib` og `subprocess`.

Disse modulene er innebygde, og krever ingen installasjon via PIP. Du kan importere dem alle med følgende kode:

import os
import sys
import pathlib
import subprocess

Nedenfor er en oversikt over hovedfunksjonaliteten til hver import:

• `os`: Gir en plattformuavhengig måte å bruke systemspesifikke funksjoner. Dette er det mest vanlige valget med mindre du trenger mer avanserte funksjoner.
• `sys`: Gir tilgang til systemspesifikke parametere og funksjoner i selve Python-tolken.
• `pathlib`: Tilbyr en avansert måte å håndtere filbaner på. Lar deg representere filsystemet som objekter med relevant semantikk for hvert operativsystem.
• `subprocess`: Lar deg kjøre og administrere underprosesser direkte fra Python, og jobbe med stdin, stdout og returkoder.

Det finnes også andre spesialiserte biblioteker, men de ovennevnte modulene vil dekke de fleste behov.

Merk: Resultatene av disse modulenene kan variere avhengig av operativsystemet. UNIX-baserte systemer er ofte best tilpasset med Python.

Nå som vi har en grunnleggende forståelse for hvordan Python samhandler med operativsystemet, la oss se på de ulike metodene for å sjekke fil- og mappestørrelser. Alle eksemplene er tilgjengelige i Fil- og mappestørrelse i Python GitHub-repository.

Bruker `os.stat().st_size`

Her skal vi benytte oss av funksjonen `stat()` fra `os`-modulen, som gir mye informasjon om en gitt fil eller mappe.

Merk: Funksjonen `os.path.getsize()` kan også brukes til samme formål, men `os.stat().st_size` følger ikke symlinks.

Før vi fortsetter, la oss opprette en testfil kalt `lorem.txt`. Vi kan hente tekst fra en Lorem Ipsum tekstgenerator og lime den inn i `lorem.txt`.

I samme mappe lager vi en fil som heter `method1.py` og legger inn følgende kode:

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

La oss forklare koden:

• Første linje importerer `os`-modulen.
• `size`-variabelen lagrer størrelsen på filen `lorem.txt`.
  • `os.stat()`-funksjonen returnerer detaljert informasjon om filen.
  • `st_size`-attributtet representerer størrelsen i antall bytes.
• Den siste linjen skriver ut størrelsen.

Kjør Python-skriptet. Resultatet vil variere avhengig av innholdet i `lorem.txt`.

Eksempel på output:

20064

Størrelsen er oppgitt i byte, noe som ikke er særlig lesbart. La oss forbedre dette ved å bruke en modul som konverterer dette til mer lesbare enheter.

Installer `humanize` pakken ved å kjøre følgende kommando i terminalen:

pip install humanize

Deretter kan vi bruke `naturalsize()`-funksjonen for å konvertere byte til lesbare enheter som KB, MB, GB eller TB.

import os
from humanize import naturalsize

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

print(size)
print(naturalsize(size))

Denne koden printer ut filstørrelsen i byte og deretter i en mer forståelig format.

Eksempel på output:

20064
20.1 kB

Bruker `pathlib`

Selv om `pathlib` hovedsakelig er laget for å håndtere filbaner, tilbyr den også nyttige funksjoner fra andre moduler.

Lag en ny fil `method2.py` og importer `Path`-klassen:

from pathlib import Path

Lag deretter et `Path`-objekt som tar banen til `lorem.txt` som argument:

file_ = Path('lorem.txt')

Nå kan du bruke `stat()`-metoden til `Path`-klassen, som fungerer på samme måte som `os.stat()`. Dermed kan vi skrive ut filstørrelsen.

print(file_.stat().st_size)

Eksempel på output:

20064

Som du ser, får vi samme resultat som med første metode. La oss igjen bruke `humanize`-modulen for å gjøre det mer lesbart.

from pathlib import Path
from humanize import naturalsize

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

print(naturalsize(size))

Output:

20.1 kB

Bruke Unix-kommandoer med `subprocess`

`subprocess`-modulen lar oss kjøre og administrere underprosesser fra Python. Vi kan dermed kjøre kommandoer og behandle output direkte i Python.

Merk: Denne metoden fungerer kun på Unix-baserte operativsystemer (Linux, macOS).

Lag en fil `method3.py` og lim inn følgende kode:

from subprocess import run

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

print(process.stdout)

La oss gå gjennom koden:

• Vi importerer `run`-funksjonen fra `subprocess`-modulen.
• `process`-variabelen lagrer resultatet av å kjøre kommandoen `du lorem.txt`.
  • `du` er et Linux-verktøy for å finne diskplass som brukes av filer.
  • `capture_output` gir oss tilgang til standard output.
  • `text` angir at output skal lagres som streng i stedet for bytes.
• Til slutt skrives standard utdata.

Output fra koden:

20      lorem.txt

Output viser størrelsen og navnet på filen. Hvis du kun trenger størrelsen, kan du dele output strengen 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)

Output:

20

Dette er fortsatt ikke lesbart. Vi kan anta at enheten er KB, men det gir ikke en fullstendig forståelse. For å løse dette kan vi bruke `-h` (human-readable) flagget.

Merk: Du kan finne mer informasjon om 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å gir koden et mer lesbart output:

20K

For mer informasjon om `subprocess`-modulen, sjekk ut vår guide om Python-subprocess.

Finne størrelsen på en mappe rekursivt

For å finne størrelsen på en mappe, må vi iterere gjennom alle filene og undermappene. Vi skal gjøre det på to måter:

• Ved å iterere gjennom filbaner med `pathlib`.
• Ved å bruke `du`-kommandoen med `subprocess`.

Følgende kode vil bruke en testmappe i hjemmekatalogen min. Du må erstatte banen med din egen mappe.

Iterere over filbaner med `pathlib`

La oss se hvordan vi kan finne størrelsen på en mappe ved å iterere gjennom 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))

La oss bryte ned koden:

• Importerer `Path`-klassen og `naturalsize`-funksjonen.
• Definerer en `get_size()`-funksjon som tar en valgfri `path`-parameter (som peker til gjeldende mappe som standard).
• `size`-variabelen holder total størrelse.
• Itererer gjennom hver fil i den gitte mappen, inkludert undermapper.
• Henter størrelsen på hver fil og legger den til `size`.
• Returnerer totalstørrelsen i et lesbart format.

Jeg bruker en testmappe som er spesifikk for min maskin. Husk å endre banen til en mappe som finnes på din datamaskin.

Output:

403.4 MB

Bruke `du`-kommandoen med `subprocess`

Denne tilnærmingen har flere fordeler:

• Resultatet er ofte mer nøyaktig.
• Det er 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 i metode 3, men denne gangen henter vi størrelsen på en mappe i stedet for en fil.

Output:

481M

Som du ser gir disse to metodene litt forskjellig resultat. Jo større mappen er, desto større blir forskjellen.

Valget mellom `pathlib` og `subprocess` avhenger av dine preferanser og situasjon. Hvis du alltid bruker Linux, kan `subprocess` være raskere. Ellers kan `Pathlib` være et bedre alternativ.

Oppsummering

Pythons evne til å samhandle med operativsystemet er svært nyttig for automatisering. De viktigste modulene for dette er `os`, `sys`, `pathlib` og `subprocess`.

I denne artikkelen har vi lært:

• Hvordan Python samhandler med operativsystemet.
• Hvordan bruke innebygde moduler for å utføre operativsystem-relaterte oppgaver.
• Hvordan bruke `humanize`-modulen for å skrive ut lesbare filstørrelser.
• Hvordan finne størrelsen på en fil med tre forskjellige metoder.
• Hvordan finne størrelsen på en mappe rekursivt eller ved hjelp av `du`-kommandoen.