I denne artikel lærer du at kontrollere størrelsen på en fil eller mappe i Python
Python er et af de mest alsidige programmeringssprog. Med det vil du være i stand til at bygge fra et lille CLI (Command-line interface) program til en kompleks webapplikation.
En af dens mest undervurderede funktioner er imidlertid evnen til at interagere med operativsystemer. Administration af OS-operationer med Python kan spare dig masser af tid, når du opretter automatiseringsprocesser.
Lad os se, hvordan Python interagerer med OS.
Indholdsfortegnelse
Hvordan interagerer Python med operativsystemet?
Ingen kan leve isoleret fra deres omgivelser. Det gælder også i Python, hvor nogle gange er fundamentalt at interagere med operativsystemet for at få tingene gjort.
Python har flere moduler, der lader os interagere med OS. De mest brugte er os, sys, pathlib og subprocess.
Da de er indbyggede moduler, behøver du ikke installere dem med PIP. Du kan importere dem alle med følgende sætning:
import os import sys import pathlib import subprocess
Nedenstående liste angiver hovedfunktionaliteten af hver enkelt af disse importer:
- OS: Bærbar måde at bruge systemspecifik (afhængigt af dit OS) funktionalitet på. Det er det rigtige valg i de fleste tilfælde, medmindre du har brug for noget mere avanceret
- Sys: Systemspecifikke parametre og funktioner. Dette modul giver adgang til fortolkningsvariabler og -funktioner. OS-modulet interagerer med operativsystemet og sys interagerer med Python-fortolkeren
- Pathlib: Avanceret stibrug. Lader dig repræsentere filsystemer som objekter med den relevante semantik for hvert OS.
- Underproces: Eksekverings- og underprocesstyring direkte fra Python. Det involverer at arbejde med stdin, stdout og returkoder. Du kan lære mere om det ved at læse vores Python-underprocesvejledning.
Der er biblioteker på højt niveau, der inkluderer endnu mere specifik funktionalitet afhængigt af dine behov. Men det meste af tiden er du god til at gå med ovenstående moduler.
Bemærk: De fleste af funktionerne i disse moduler vil have et andet output afhængigt af dit OS. Husk, at normalt er det bedste match UNIX og Python.
Nu har du et hurtigt greb om, hvordan Python interagerer med OS, lad os springe ind i metoderne til at kontrollere fil- og mappestørrelse. Alle de følgende løsninger er tilgængelige i Fil- og mappestørrelse i Python GitHub-depot
Bruger os.stat().st_size
I denne metode vil vi bruge stat() funktion fra os-modulet. Det returnerer en masse information om en bestemt sti.
Bemærk: os.path.getsize()-funktionen får også arbejdet gjort. Fordelen ved at bruge os.stat().st_size er, at den ikke følger simlinks.
Inden vi fortsætter, lad os oprette en testfil ved navn lorem.txt, hvori vi skal indsætte noget dum tekst. Vi kan besøge en Lorem Ipsum tekstgenerator og indsæt teksten i lorem.txt-filen.
I samme mappe skal du oprette en fil med navnet method1.py og indsætte koden nedenfor:
import os
size = os.stat('lorem.txt').st_size
print(size)
Lad os nedbryde, hvad vi laver med denne kode:
- I den første linje importerer vi os-modulet
- Størrelsesvariablen indeholder størrelsen på filen lorem.txt
- os.stat()-funktionen returnerer en masse info relateret til filen
- St_size-attributten repræsenterer størrelsen af filen
- Vi udskriver størrelsesvariablen
Prøv at køre Python-scriptet. Du får et andet resultat afhængigt af indholdet af din lorem.txt-fil.
Produktion:
20064
Outputtet er repræsenteret i bytes. Dette kan slet ikke læses, så lad os humanisere det, så vi kan få et bedre perspektiv på filens størrelse.
Først skal du installere menneskeliggøre pakke, ved at køre følgende kommando i din shell:
pip install humanize
Så kan du bruge naturalsize()-funktionen, der konverterer en værdi i bytes til læsbar 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 udskriver koden ovenfor filens størrelse i bytes og udskriver derefter resultatet i en læsbar størrelse.
Produktion:
20064 20.1 kB
Bruger Pathlib
Selvom stilib er designet til udelukkende at arbejde med stier, den inkorporerer nogle nyttige funktioner fra andre moduler som metoder til Path-objekter (Forekomster af Path-klassen).
Opret en fil method2.py og importer Sti klasse.
from pathlib import Path
Opret derefter et Sti-objekt, der sender stien til lorem.txt-filen som et argument.
file_ = Path('lorem.txt')
Nu kan du få adgang til stat()-metoden for Path-klassen. Det fungerer på samme måde som os.stat()-funktionen, derfor vil du være i stand til at udskrive filens størrelse.
print(file_.stat().st_size)
Produktion:
20064
Som du kan se, fik vi det samme resultat som med den første metode, vi brugte. Resultatet ovenfor er også printet i byte-format, så vi kan bruge humanize-modulet til at gøre det læsbart.
from pathlib import Path
from humanize import naturalsize
size = Path('lorem.txt').stat().st_size
print(naturalsize(size))
Denne kode producerer følgende output:
20.1 kB
Brug af Unix-kommandoer med underproces:
Underprocesmodulet giver os mulighed for at kalde og administrere underprocesser fra Python. Derfor kan vi køre enhver kommando og behandle dens output direkte i Python.
Bemærk: Denne metode virker kun, hvis du kører et Unix OS (Linux, Mac)
Åbn en fil method3.py og indsæt koden nedenfor:
from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) print(process.stdout)
Dykker ned i dette stykke kode:
- Vi importerer køre funktion fra delprocesmodulet
- Variabelprocessen indeholder resultatet af at køre kommandoen du lorem.txt
- du er et Linux-værktøj, der giver os mulighed for at få diskpladsen til en fil
- capture_output giver os adgang til attributten standout (standard output).
- tekst betyder, at vi gemmer output som en streng i stedet for bytes
- Vi udskriver standardoutput af processen
Hvis du kører koden ovenfor, får du følgende output:
20 lorem.txt
Som du kan se, giver det os størrelsen og navnet på filen. Hvis du kun ønsker at få størrelsen på filen, skal du opdele outputtet (husk det er en streng) og udskrive det første element.
from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) size = process.stdout.split()[0] print(size)
Produktion:
20
Dette output er slet ikke læsbart. Vi kan udlede, at den anvendte måleenhed er KB (på grund af de tidligere metoder), men ingen andre kunne gætte størrelsen på filen.
For at løse dette problem kan vi gøre brug af flaget -h (læsbart for mennesker).
Bemærk: Du kan få en manual til denne kommando ved at kø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)
Nu vil outputtet af dette script være meget mere læsbart:
20K
Hvis du vil vide mere om underprocesmodulet og mulige applikationer, så tjek vores Python-underprocesguide.
Få størrelsen på en mappe rekursivt
Hvis du vil have størrelsen på en mappe, skal du gentage hver fil, der findes i mappen og dens undermapper. Vi gør det med to metoder:
- Iteration over en sti med pathlib
- Brug af kommandoen du med underproces
Følgende kode vil bruge en sti til en testmappe inde i min hjemmemappe. Du bliver nødt til at erstatte stien til den fil for den mappe, du ønsker at få størrelsen.
Iteration over en sti med pathlib
Lad os se, hvordan du kan få størrelsen på en mappe ved at iterere over størrelserne på filerne.
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))
Dette stykke kode virker en lille smule skræmmende, lad os nedbryde, hvad hver del laver.
- Importer Path-klassen og naturalsize()-funktionen
- Definer funktionen get_size() med en parametersti, som som standard peger på den aktuelle mappe.
- Størrelsesvariablen er kun en pladsholder, hvor vi tilføjer størrelsen på hver fil
- Gentag over hver fil på stien
- Få størrelsen på hver fil og tilføj den til størrelsesvariablen
- Returnerer størrelsesvariablen på en måde, der kan læses af mennesker
Selvfølgelig tester jeg funktionen med en mappe, der kun er tilgængelig på min maskine. Glem ikke at ændre stien til en mappe, der findes på din computer.
I mit tilfælde får jeg følgende output:
403.4 MB
Brug af kommandoen du med underproces
Denne tilgang har nogle fordele:
- Resultatet er en lille smule mere præcist
- Det er meget hurtigere
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 bruger samme tilgang som metode 3, men denne gang får vi størrelsen på en mappe i stedet for en fil.
Produktion:
481M
Som du kan se, giver disse to måder at få størrelsen på en mappe på, et lidt anderledes resultat. Jo større mappen er, jo større forskel får du.
Det er op til dig at vælge mellem pathlib- eller subproces-tilgangen. Hvis du ved, at du vil bruge Linux, hver gang du bruger subprocess, ellers kan du bruge pathlib-løsningen.
For at opsummere
Python-resultater er ekstremt praktiske, når du interagerer med operativsystemet. Du kan automatisere processer og spare en masse tid med Python. De vigtigste moduler til at interagere med os er os, sys, sti og underproces.
I denne tutorial lærte du:
- Hvordan Python interagerer med operativsystemet
- Brugen af indbyggede moduler til at udføre OS-operationer
- Sådan bruger du humaniseringsmodulet til at udskrive menneskeligt læsbart
- For at beregne størrelsen af en fil med 3 fremgangsmåder
- For at beregne størrelsen af en mappe rekursivt eller med kommandoen du