Hur kontrollerar man fil- och mappstorlek i Python?

av

I den här artikeln lär du dig att kontrollera storleken på en fil eller mapp i Python

Python är ett av de mest mångsidiga programmeringsspråken. Med den kommer du att kunna bygga från ett litet CLI (Command-line interface)-program till en komplex webbapplikation.

En av dess mest underskattade funktioner är dock förmågan att interagera med operativsystem. Att hantera OS-operationer med Python kan spara massor av tid när du skapar automationsprocesser.

Låt oss se hur Python interagerar med operativsystemet.

Hur interagerar Python med operativsystemet?

Ingen kan leva isolerad från sina miljöer. Det gäller även i Python, där ibland är grundläggande att interagera med operativsystemet för att få saker gjorda.

Python har flera moduler som låter oss interagera med operativsystemet. De mest använda är os, sys, pathlib och subprocess.

Eftersom de är inbyggda moduler behöver du inte installera dem med PIP. Du kan importera dem alla med följande uttalande:

import os
import sys
import pathlib
import subprocess

Listan nedan anger huvudfunktionaliteten för var och en av dessa importer:

  • OS: Bärbart sätt att använda systemspecifik (beroende på ditt operativsystem) funktionalitet. Det är rätt val i de flesta fall om du inte behöver något mer avancerat
  • Sys: Systemspecifika parametrar och funktioner. Denna modul ger tillgång till tolkvariabler och funktioner. OS-modulen interagerar med operativsystemet och sys interagerar med Python-tolken
  • Pathlib: Avancerad väganvändning. Låter dig representera filsystem som objekt, med den relevanta semantiken för varje operativsystem.
  • Delprocess: Exekverings- och delprocesshantering direkt från Python. Det innebär att arbeta med stdin, stdout och returkoder. Du kan lära dig mer om det genom att läsa vår Python-delprocessguide.

Det finns bibliotek på hög nivå som inkluderar ännu mer specifik funktionalitet beroende på dina behov. Men för det mesta är du bra att gå med ovanstående moduler.

Obs: De flesta funktioner som tillhandahålls av dessa moduler kommer att ha olika utdata beroende på ditt operativsystem. Kom ihåg att vanligtvis är den bästa matchningen UNIX och Python.

Nu har du ett snabbt grepp om hur Python interagerar med operativsystemet, låt oss hoppa in i metoderna för att kontrollera fil- och mappstorlek. Alla följande lösningar finns tillgängliga i Fil- och mappstorlek i Python GitHub-förråd

Använder os.stat().st_size

I den här metoden kommer vi att använda statistik() funktion från OS-modulen. Det returnerar mycket information om en specifik väg.

Obs: Funktionen os.path.getsize() gör också jobbet gjort. Fördelen med att använda os.stat().st_size är att den inte följer simlänkar.

Innan vi fortsätter, låt oss skapa en testfil med namnet lorem.txt, där vi ska klistra in lite dum text. Vi kan besöka a Lorem Ipsum textgenerator och klistra in texten i lorem.txt-filen.

Skapa en fil med namnet method1.py i samma katalog och klistra in koden nedan:

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

Låt oss dela upp vad vi gör med den här koden:

  • I den första raden importerar vi OS-modulen
  • Storleksvariabeln innehåller storleken på filen lorem.txt
    • Funktionen os.stat() returnerar en massa information relaterad till filen
    • Attributet st_size representerar storleken på filen
  • Vi skriver ut storleksvariabeln

Försök att köra Python-skriptet. Du får ett annat resultat beroende på innehållet i din lorem.txt-fil.

Produktion:

20064

Utgången representeras i byte. Det här är inte alls läsbart, så låt oss humanisera det så att vi kan få ett bättre perspektiv på storleken på filen.

Installera först humanisera paket, genom att köra följande kommando i ditt skal:

pip install humanize

Sedan kan du använda funktionen naturalsize() som konverterar ett värde i byte till läsbar filstorlek, till exempel 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 ovan ut filens storlek i byte och skriver sedan ut resultatet i en läsbar storlek.

Produktion:

20064
20.1 kB

Använder Pathlib

Fastän pathlib är designad för att enbart fungera med sökvägar, den innehåller några användbara funktioner från andra moduler som metoder för sökvägsobjekt (instanser av klassen Path).

Skapa en fil method2.py och importera filen Banklass.

from pathlib import Path

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

file_ = Path('lorem.txt')

Nu kan du komma åt metoden stat() för klassen Path. Det fungerar på samma sätt som os.stat()-funktionen, därför kommer du att kunna skriva ut storleken på filen.

print(file_.stat().st_size)

Produktion:

20064

Som du kan se fick vi samma resultat som med den första metoden vi använde. Resultatet ovan skrivs också ut i byte-format, 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 producerar följande utdata:

20.1 kB

Använda Unix-kommandon med Subprocess:

Delprocessmodulen låter oss anropa och hantera delprocesser från Python. Därför kan vi köra vilket kommando som helst och behandla dess utdata direkt i Python.

Obs: Den här metoden fungerar bara om du kör ett Unix OS (Linux, Mac)

Öppna en fil method3.py och klistra in koden nedan:

from subprocess import run

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

print(process.stdout)

Dyker in i denna kodbit:

  • Vi importerar kör funktion från delprocessmodulen
  • Variabelprocessen innehåller resultatet av att köra kommandot du lorem.txt
    • du är ett Linux-verktyg som låter oss få diskutrymmet för en fil
    • capture_output ger oss tillgång till attributet standout (standard output).
    • text betyder att vi lagrar utdata som en sträng istället för byte
  • Vi skriver ut standardutdata för processen

Om du kör koden ovan får du följande utdata:

20      lorem.txt

Som du kan se ger den oss storleken och namnet på filen. Om du bara vill få storleken på filen, måste du dela upp resultatet (kom ihåg att det är en sträng) 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)

Produktion:

20

Denna utdata är inte alls läsbar. Vi kan dra slutsatsen att den använda måttenheten är KB (på grund av de tidigare metoderna), men ingen annan kunde gissa storleken på filen.

För att lösa detta problem kan vi använda flaggan -h (läsbar för människor).

Obs: Du kan få en manual för detta kommando genom att köra 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 kommer resultatet av detta skript att vara mycket mer läsbart:

20K

Om du vill veta mer om delprocessmodulen och möjliga applikationer, kolla in vår Python-delprocessguide.

Få storleken på en mapp rekursivt

Om du vill få storleken på en mapp måste du iterera över varje fil som finns i katalogen och dess underkataloger. Vi gör det med två metoder:

  • Itererar över en väg med pathlib
  • Använda kommandot du med underprocess

Följande kod kommer att använda en sökväg till en testkatalog i min hemmapp. Du måste ersätta sökvägen till den filen för den katalog du vill få storleken på.

Itererar över en väg med pathlib

Låt oss se hur du kan få storleken på en katalog genom att iterera över storleken på 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 kodbiten verkar lite skrämmande, låt oss dela upp vad varje del gör.

  • Importera klassen Path och naturalsize()-funktionen
  • Definiera funktionen get_size() med en parametersökväg, som pekar på den aktuella katalogen som standard.
  • Storleksvariabeln är bara en platshållare där vi lägger till storleken på varje fil
  • Iterera över varje fil i sökvägen
  • Få storleken på varje fil och lägg till den i storleksvariabeln
  • Returnerar storleksvariabeln på ett läsbart sätt för människor

Naturligtvis testar jag funktionen med en katalog som endast är tillgänglig i min maskin. Glöm inte att ändra sökvägen till en mapp som finns på din dator.

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

403.4 MB

Använda kommandot du med Subprocess

Detta tillvägagångssätt har några fördelar:

  • Resultatet är 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 metod 3, men den här gången får vi storleken på en katalog istället för en fil.

Produktion:

481M

Som du kan se dessa två sätt att få storleken på en mapp, returnerar ett något annorlunda resultat. Ju större katalogen är desto större skillnad får du.

Det är upp till dig att välja mellan tillvägagångssätten pathlib eller subprocessen. Om du vet att du kommer att använda Linux varje gång du använder subprocess, annars kan du använda pathlib-lösningen.

För att sammanfatta

Python-resultaten är extremt praktiska när du interagerar med operativsystemet. Du kan automatisera processer och spara mycket tid med Python. Huvudmodulerna för att interagera med operativsystemet är os, sys, sökväg och underprocess.

I den här handledningen lärde du dig:

  • Hur Python interagerar med operativsystemet
  • Användningen av inbyggda moduler för att göra OS-operationer
  • Hur man använder modulen för humanisering för att skriva ut mänskligt läsbart
  • För att beräkna storleken på en fil med 3 metoder
  • För att beräkna storleken på en katalog rekursivt eller med kommandot du