Hur kontrollerar man fil- och mappstorlek i Python?

Utforska fil- och mappstorlekar med Python

I denna artikel kommer vi att undersöka hur man effektivt kan hantera fil- och mappstorlekar med hjälp av Python. Python är känt för sin mångsidighet, vilket gör det möjligt att skapa allt från enkla kommandoradsverktyg till avancerade webbapplikationer.

En ofta förbisedd förmåga hos Python är dess samverkan med operativsystemet. Genom att automatisera OS-relaterade uppgifter kan man spara mycket tid och ansträngning.

Låt oss granska hur Python kan interagera med operativsystemet.

Pythons samspel med operativsystemet

För att utföra vissa uppgifter är det nödvändigt för Python att interagera med operativsystemet. Python tillhandahåller flera moduler för att underlätta denna interaktion. De mest framstående inkluderar os, sys, pathlib, och subprocess.

Dessa moduler är inbyggda och kräver inte installation via pip. De kan importeras med följande kod:

import os
import sys
import pathlib
import subprocess

Nedan följer en sammanfattning av varje moduls huvudfunktionalitet:

• os: Ger ett plattformsoberoende sätt att använda systemspecifik funktionalitet. Idealisk för de flesta vanliga OS-interaktioner.
• sys: Erbjuder systemspecifika parametrar och funktioner. Denna modul ger tillgång till tolkvariabler och funktioner. Till skillnad från os-modulen som interagerar med operativsystemet, samverkar sys-modulen med själva Python-tolken.
• pathlib: Tillhandahåller ett avancerat sätt att hantera filsystemvägar, vilket möjliggör representation av filsystemet som objekt, med relevant semantik för varje operativsystem.
• subprocess: Möjliggör exekvering och hantering av underprocesser direkt från Python, inklusive interaktion med stdin, stdout och returkoder. För mer information, läs vår Python-underprocessguide.

Det finns också bibliotek på högre nivå som tillhandahåller ännu mer specialiserade funktioner. Men för de flesta uppgifter är de ovan nämnda modulerna tillräckliga.

Viktigt: Observera att utdata från funktioner i dessa moduler kan variera beroende på operativsystem. Vanligtvis är Python mest kompatibelt med UNIX-baserade system.

Nu när vi har en översikt över hur Python interagerar med operativsystemet, låt oss utforska olika metoder för att kontrollera fil- och mappstorlekar. All kod som presenteras nedan finns tillgänglig i File- and folder-size in Python GitHub-förrådet.

Använda os.stat().st_size

I denna metod använder vi funktionen stat() från os-modulen. Den ger omfattande information om en given fil- eller mappväg.

Observera: Funktionen os.path.getsize() utför också samma uppgift, men en fördel med os.stat().st_size är att den inte följer symboliska länkar.

Först skapar vi en testfil med namnet lorem.txt och fyller den med text. Använd en Lorem Ipsum textgenerator för att generera texten.

Skapa en fil med namnet method1.py i samma katalog och kopiera in följande kod:

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

Låt oss granska koden:

• Den första raden importerar os-modulen.
• Variabeln size tilldelas filens storlek i lorem.txt.
  • Funktionen os.stat() returnerar detaljerad information om filen.
  • Attributet st_size representerar filens storlek i bytes.
• Filens storlek skrivs ut.

Kör Python-skriptet. Resultatet beror på innehållet i lorem.txt-filen.

Exempelutdata:

20064

Utdata anges i byte, vilket inte är särskilt läsvärt. Därför ska vi humanisera det så att vi får en bättre bild av filens storlek.

Installera paketet humanize genom att köra följande kommando i terminalen:

pip install humanize

Nu kan du använda funktionen naturalsize() som konverterar ett värde i byte till en läsbar storlek som KB, MB, GB eller TB.

import os
from humanize import naturalsize

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

print(size)
print(naturalsize(size))

Den här koden skriver först ut filens storlek i byte och sedan i läsbar form.

Exempelutdata:

20064
20.1 kB

Använda Pathlib

Även om pathlib är utformat för att hantera sökvägar, innehåller det användbara funktioner från andra moduler som metoder i sökvägsobjekt.

Skapa en fil method2.py och importera klassen Path.

from pathlib import Path

Skapa sedan ett sökvägsobjekt med sökvägen till lorem.txt som argument.

file_ = Path('lorem.txt')

Nu kan du komma åt stat()-metoden i Path-klassen. Den fungerar på samma sätt som os.stat()-funktionen, och du kan skriva ut filstorleken.

print(file_.stat().st_size)

Exempelutdata:

20064

Vi får samma resultat som med den första metoden. Återigen, utdata skrivs ut i bytes, så vi kan använda modulen humanize för att göra det läsbart.

from pathlib import Path
from humanize import naturalsize

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

print(naturalsize(size))

Denna kod ger följande utdata:

20.1 kB

Använda Unix-kommandon med Subprocess

Modulen subprocess gör det möjligt att köra och hantera underprocesser från Python. Det innebär att vi kan köra vilket kommando som helst och hantera dess utdata direkt i Python.

Viktigt: Denna metod fungerar endast på Unix-baserade system (Linux, macOS).

Skapa en fil method3.py och kopiera in koden nedan:

from subprocess import run

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

print(process.stdout)

Låt oss granska koden:

• Vi importerar run-funktionen från subprocess-modulen.
• Variabeln process innehåller resultatet av att köra kommandot du lorem.txt.
  • du är ett Linux-verktyg som visar diskförbrukningen för en fil.
  • capture_output ger tillgång till attributet stdout (standardutdata).
  • text indikerar att utdata ska lagras som en sträng, inte som bytes.
• Vi skriver ut standardutdata från processen.

När koden körs får vi följande utdata:

20      lorem.txt

Som du ser får vi både storleken och filens namn. För att endast få filens storlek måste vi splitta strängen och skriva ut det första elementet.

from subprocess import run

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

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

print(size)

Exempelutdata:

20

Denna utdata är inte särskilt läsbar. Vi kan anta att enheten är KB, men det är inte tydligt. Genom att använda flaggan -h (mänskligt läsbart) får vi utdata i mer begripligt format.

Observera: Använd man du eller du --help för att se mer information om detta kommando.

from subprocess import run

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

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

print(size)

Nu är resultatet mer lättförståeligt:

20K

För mer information om subprocess-modulen och dess användningsområden, se vår Python-underprocessguide.

Hämta mappstorlek rekursivt

För att hämta en mappstorlek behöver man iterera igenom alla filer i katalogen och dess underkataloger. Detta kan göras på två sätt:

• Iterera över en sökväg med pathlib.
• Använda kommandot du med subprocess.

Följande kod använder en sökväg till en testkatalog i min hemkatalog. Du måste ersätta denna sökväg med den katalog du vill hämta storleken på.

Iterera över en sökväg med pathlib

Här visar vi hur man hämta storleken på en katalog genom att iterera över filerna.

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

Den här koden kan verka komplicerad, så låt oss bryta ner den:

• Vi importerar Path-klassen och funktionen naturalsize().
• Vi definierar en funktion get_size() med en parametersökväg som pekar på den aktuella katalogen som standard.
• Variabeln size fungerar som en plats där vi ackumulerar storleken på varje fil.
• Vi itererar igenom varje fil i sökvägen.
• Vi hämtar storleken på varje fil och lägger till den i variabeln size.
• Vi returnerar den sammanlagda storleken i ett läsbart format.

Vi testar nu funktionen med en katalog som endast finns på min dator. Kom ihåg att byta sökväg till en mapp på din egen dator.

I mitt fall får jag följande utdata:

403.4 MB

Använda kommandot du med Subprocess

Denna metod har några fördelar:

• Resultatet blir lite mer exakt.
• Det är mycket snabbare.

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 använder samma tillvägagångssätt som i metod 3, men vi hämtar storleken på en hel katalog istället för en enskild fil.

Exempelutdata:

481M

Som du kan se kan dessa två metoder ge något olika resultat. Ju större katalogen är, desto större blir skillnaden. Det är upp till dig att välja det tillvägagångssätt som passar bäst.

Om du vet att du alltid kommer att använda Linux, kan du välja metoden med subprocess. Annars kan pathlib-metoden vara ett bättre val.

Sammanfattning

Python är oerhört användbart när det gäller att interagera med operativsystemet, vilket gör det möjligt att automatisera processer och spara mycket tid. De huvudsakliga modulerna för OS-interaktion är os, sys, pathlib och subprocess.

I denna genomgång har du lärt dig:

• Hur Python interagerar med operativsystemet.
• Användningen av inbyggda moduler för att utföra OS-relaterade operationer.
• Hur man använder humanize-modulen för att skriva ut läsbar information.
• Hur man beräknar storleken på en fil med tre olika metoder.
• Hur man beräknar storleken på en katalog rekursivt eller med kommandot du.