Como verificar o tamanho do arquivo e da pasta em Python?

Neste artigo, você aprenderá a verificar o tamanho de um arquivo ou pasta em Python

Python é uma das linguagens de programação mais versáteis. Com ele, você será capaz de construir de um pequeno programa CLI (interface de linha de comando) para um aplicativo da web complexo.

No entanto, uma de suas características mais subestimadas é a capacidade de interagir com sistemas operacionais. Gerenciar as operações do sistema operacional com Python pode economizar muito tempo ao criar processos de automação.

Vamos ver como o Python interage com o sistema operacional.

Como o Python interage com o sistema operacional?

Ninguém pode viver isolado de seus ambientes. Isso também se aplica ao Python, onde às vezes é fundamental interagir com o sistema operacional para fazer as coisas.

Python possui vários módulos que nos permitem interagir com o sistema operacional. Os mais usados ​​são os, sys, pathlib e subprocess.

Como são módulos integrados, você não precisa instalá-los com o PIP. Você pode importar todos eles com a seguinte declaração:

 import os import sys import pathlib import subprocess

A lista a seguir indica as principais funcionalidades de cada uma dessas importações:

• Os: maneira portátil de usar funcionalidades específicas do sistema (dependendo do seu sistema operacional). É a escolha certa na maioria dos casos, a menos que você precise de algo mais avançado
• Sys: Parâmetros e funções específicos do sistema. Este módulo fornece acesso a variáveis ​​e funções do interpretador. O módulo os interage com o sistema operacional e sys interage com o interpretador Python
• Pathlib: uso de caminho avançado. Permite representar sistemas de arquivos como objetos, com a semântica pertinente para cada sistema operacional.
• Subprocesso: Execução e gerenciamento de subprocessos diretamente do Python. Isso envolve trabalhar com os códigos stdin , stdout e de retorno. Você pode aprender mais sobre isso lendo nosso guia de subprocesso Python.

Existem bibliotecas de alto nível que incluem funcionalidades ainda mais específicas, dependendo de suas necessidades. No entanto, na maioria das vezes, você está pronto para usar os módulos acima.

Observação: a maioria das funções fornecidas por esses módulos terão uma saída diferente dependendo do seu sistema operacional. Lembre-se de que, normalmente, a melhor combinação é UNIX e Python.

Agora que você tem uma ideia rápida de como o Python interage com o sistema operacional, vamos pular para os métodos de verificação de tamanho de arquivo e pasta. Todas as soluções a seguir estão disponíveis no arquivo e tamanho da pasta no repositório Python GitHub

Usando os.stat (). St_size

Neste método, vamos usar a função stat () do módulo os. Ele retorna muitas informações sobre um caminho específico.

Observação: a função os.path.getsize () também realiza o trabalho. A vantagem de usar os.stat (). st_size é que ele não segue simlinks.

Antes de continuar, vamos criar um arquivo de teste chamado lorem.txt , no qual colaremos algum texto idiota . Podemos visitar um gerador de texto Lorem Ipsum e colar o texto no arquivo lorem.txt .

No mesmo diretório, crie um arquivo com o nome method1.py e cole o código abaixo:

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

Vamos detalhar o que estamos fazendo com este código:

• Na primeira linha, estamos importando o módulo os
• A variável de tamanho contém o tamanho do arquivo lorem.txt
  • A função os.stat () retorna um monte de informações relacionadas ao arquivo
  • O atributo st_size representa o tamanho do arquivo
• Imprimimos a variável de tamanho

Tente executar o script Python. Você obterá um resultado diferente dependendo do conteúdo do seu arquivo lorem.txt .

Saída:

 20064

A saída é representada em bytes. Isso não é legível de forma alguma, então vamos humanizá-lo para que possamos ter uma melhor perspectiva do tamanho do arquivo.

Primeiro, instale o pacote humanize, executando o seguinte comando em seu shell:

 pip install humanize

Em seguida, você pode usar a função naturalsize () que converte um valor em bytes para um tamanho de arquivo legível, por exemplo, KB, MB, GB ou TB.

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

A princípio, o código acima imprime o tamanho do arquivo em bytes e, em seguida, imprime o resultado em um tamanho legível.

Saída:

 20064 20.1 kB

Usando Pathlib

Embora pathlib seja projetado para trabalhar exclusivamente com caminhos, ele incorpora algumas funções úteis de outros módulos como métodos de objetos Path (instâncias da classe Path).

Crie um arquivo method2.py e importe a classe Path.

 from pathlib import Path

Em seguida, crie um objeto Path passando o caminho para o arquivo lorem.txt como um argumento.

 file_ = Path('lorem.txt')

Agora, você pode acessar o método stat () da classe Path. Funciona da mesma forma que a função os.stat () , portanto, você poderá imprimir o tamanho do arquivo.

 print(file_.stat().st_size)

Saída:

 20064

Como você pode ver, obtivemos o mesmo resultado do primeiro método que usamos. O resultado acima também é impresso em formato de byte, então podemos usar o módulo humanize para torná-lo legível.

 from pathlib import Path from humanize import naturalsize size = Path('lorem.txt').stat().st_size print(naturalsize(size))

Este código produz a seguinte saída:

 20.1 kB

Usando comandos Unix com Subprocess:

O módulo de subprocesso nos permite chamar e gerenciar o subprocesso do Python. Portanto, podemos executar qualquer comando e tratar sua saída diretamente em Python.

Observação: este método só funciona se você estiver executando um sistema operacional Unix (Linux, Mac)

Abra um arquivo method3.py e cole o código abaixo:

 from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) print(process.stdout)

Mergulhando neste pedaço de código:

• Importamos a função de execução do módulo de subprocesso
• A variável processo contém o resultado da execução do comando du lorem.txt
  • du é um utilitário do Linux que nos permite obter o espaço em disco de um arquivo
  • capture_output nos dá acesso ao atributo standout (saída padrão)
  • texto significa que estamos armazenando a saída como uma string em vez de bytes
• Imprimimos a saída padrão do processo

Se você executar o código acima, obterá o seguinte resultado:

 20 lorem.txt

Como você pode ver, ele nos fornece o tamanho e o nome do arquivo. Se você quiser apenas obter o tamanho do arquivo, precisará dividir a saída (lembre-se de que é uma string) e imprimir o primeiro elemento.

 from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) size = process.stdout.split()[0] print(size)

Saída:

 20

Esta saída não pode ser lida de forma alguma. Podemos inferir que a unidade de medida usada é KB (por causa dos métodos anteriores), mas ninguém mais conseguiu adivinhar o tamanho do arquivo.

Para resolver esse problema, podemos usar o sinalizador -h (legível para humanos).

Nota: Você pode obter um manual deste comando executando man du ou du –help .

 from subprocess import run process = run(['du', '-h', 'lorem.txt'], capture_output=True, text=True) size = process.stdout.split()[0] print(size)

Agora, a saída deste script será muito mais legível:

 20K

Se você quiser saber mais sobre o módulo de subprocesso e possíveis aplicativos, verifique nosso guia de subprocesso Python.

Obtenha o tamanho de uma pasta recursivamente

Se você deseja obter o tamanho de uma pasta, precisará iterar sobre cada arquivo presente no diretório e seus subdiretórios. Faremos isso com dois métodos:

• Iterando sobre um caminho com pathlib
• Usando o comando du com o subprocesso

O código a seguir usará um caminho para um diretório de teste dentro da minha pasta pessoal. Você precisará substituir o caminho desse arquivo pelo diretório cujo tamanho deseja obter.

Iterando sobre um caminho com pathlib

Vamos ver como você pode obter o tamanho de um diretório iterando os tamanhos dos arquivos.

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

Este pedaço de código parece um pouco assustador, vamos analisar o que cada parte está fazendo.

• Importe a classe Path e a função naturalsize ()
• Defina a função get_size () com um caminho de parâmetro, que aponta para o diretório atual por padrão.
• A variável de tamanho é apenas um marcador no qual iremos adicionar o tamanho de cada arquivo
• Itere sobre cada arquivo do caminho
  • O método rglob () retorna recursivamente os arquivos que correspondem ao padrão
  • rglob ('*') , significa que estamos obtendo todos os arquivos dentro do diretório
• Pegue o tamanho de cada arquivo e adicione-o à variável de tamanho
• Retorna a variável de tamanho de uma forma legível por humanos

Claro, estou testando a função com um diretório disponível apenas na minha máquina. Não se esqueça de alterar o caminho para uma pasta que existe em seu computador.

No meu caso, obtenho o seguinte resultado:

 403.4 MB

Usando o comando du com o subprocesso

Essa abordagem tem algumas vantagens:

• O resultado é um pouco mais preciso
• É muito mais rápido

 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)

Estamos usando a mesma abordagem do método 3, mas desta vez obtendo o tamanho de um diretório em vez de um arquivo.

Saída:

 481M

Como você pode ver essas duas maneiras de obter o tamanho de uma pasta, retorna um resultado ligeiramente diferente. Quanto maior o diretório, mais diferença você terá.

Cabe a você escolher entre as abordagens pathlib ou subprocesso . Se você sabe que usará o Linux sempre que usar um subprocesso , poderá usar a solução pathlib.

Resumindo

Os resultados do Python são extremamente úteis ao interagir com o sistema operacional. Você pode automatizar processos e economizar muito tempo com Python. Os principais módulos para interagir com o sistema operacional são os, sys, path e subprocess.

Neste tutorial, você aprendeu:

• Como o Python interage com o sistema operacional
• O uso de módulos integrados para fazer operações do sistema operacional
• Como usar o módulo humanize para imprimir legível por humanos
• Para calcular o tamanho de um arquivo com 3 abordagens
• Para calcular o tamanho de um diretório recursivamente ou com o comando du