Neste guia, você explorará métodos eficazes para determinar o tamanho de arquivos e pastas utilizando Python.
Python se destaca como uma linguagem de programação notavelmente versátil, permitindo a criação de desde simples ferramentas de linha de comando até aplicações web sofisticadas.
Uma característica frequentemente subestimada é sua capacidade de interagir com o sistema operacional. Essa interação pode otimizar significativamente seus esforços ao criar fluxos de automação.
Vamos descobrir como Python se comunica com o sistema operacional.
Comunicação entre Python e o Sistema Operacional
Nenhum sistema opera em isolamento. Da mesma forma, o Python muitas vezes precisa interagir com o sistema operacional para realizar tarefas essenciais.
O Python oferece vários módulos que facilitam essa interação, como os, sys, pathlib e subprocess, que são amplamente utilizados.
Esses módulos já vêm com o Python, dispensando a necessidade de instalação via PIP. Importe-os com a seguinte declaração:
import os import sys import pathlib import subprocess
Abaixo, detalhamos as principais funções de cada um:
- os: Oferece uma maneira padronizada de utilizar funcionalidades específicas do sistema, sendo a escolha ideal na maioria das situações.
- sys: Permite acessar variáveis e funções do interpretador, interagindo diretamente com ele, enquanto o módulo os interage com o sistema.
- pathlib: Simplifica o uso de caminhos, representando sistemas de arquivos como objetos, com semântica específica para cada sistema.
- subprocess: Possibilita executar e gerenciar subprocessos diretamente do Python, interagindo com seus códigos stdin, stdout e return.
Para necessidades mais especializadas, bibliotecas de alto nível podem oferecer funcionalidades mais específicas, mas os módulos mencionados geralmente são suficientes.
Observação: As funções desses módulos podem ter saídas diferentes dependendo do sistema operacional, sendo o UNIX um sistema que frequentemente se alinha bem com o Python.
Com um entendimento básico de como Python interage com o sistema operacional, vamos abordar os métodos para verificar o tamanho de arquivos e pastas. Todas as soluções a seguir estão disponíveis no repositório GitHub File-and-folder-size-in-Python.
Utilizando os.stat().st_size
Este método emprega a função stat() do módulo os, que retorna várias informações sobre um caminho específico.
Observação: A função os.path.getsize() também pode realizar essa tarefa, mas os.stat().st_size se destaca por não seguir links simbólicos.
Antes de prosseguir, crie um arquivo de teste chamado lorem.txt e insira um texto qualquer. Você pode usar um gerador de texto Lorem Ipsum para criar o texto.
No mesmo diretório, crie um arquivo chamado method1.py e insira o seguinte código:
import os
size = os.stat('lorem.txt').st_size
print(size)
Analisando o código:
- Importamos o módulo os.
- A variável `size` armazena o tamanho do arquivo lorem.txt:
- `os.stat()` retorna informações detalhadas sobre o arquivo.
- `st_size` especifica o tamanho do arquivo.
- O tamanho é impresso.
Execute o script. O resultado dependerá do conteúdo do arquivo lorem.txt.
Resultado:
20064
A saída está em bytes, o que pode ser difícil de interpretar. Para torná-la mais legível, podemos usar um conversor.
Primeiro, instale o pacote humanize usando o comando:
pip install humanize
Agora, utilize a função `naturalsize()`, que converte bytes em formatos como KB, MB, GB ou TB.
import os
from humanize import naturalsize
size = os.stat('lorem.txt').st_size
print(size)
print(naturalsize(size))
O código acima imprime o tamanho em bytes e, em seguida, em um formato legível.
Resultado:
20064 20.1 kB
Utilizando Pathlib
Embora o módulo pathlib seja projetado para manipular caminhos, ele integra 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
Crie um objeto Path fornecendo o caminho para o arquivo lorem.txt como argumento.
file_ = Path('lorem.txt')
Agora, use o método `stat()` da classe Path para obter o tamanho do arquivo.
print(file_.stat().st_size)
Resultado:
20064
Como visto, obtemos o mesmo resultado que com o primeiro método. Para formatá-lo de forma legível, use o módulo humanize.
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
Utilizando Comandos Unix com Subprocess
O módulo subprocess permite que você execute e gerencie subprocessos a partir do Python, incluindo a execução de comandos e o tratamento de suas saídas diretamente.
Observação: Este método só funcionará em sistemas operacionais Unix (Linux, macOS).
Crie um arquivo chamado method3.py e adicione o seguinte código:
from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) print(process.stdout)
Analisando o código:
- Importamos a função run do módulo subprocess.
- A variável `process` armazena o resultado da execução do comando `du lorem.txt`.
- `du` é um utilitário Linux que retorna o espaço em disco de um arquivo.
- `capture_output` permite acessar o atributo `stdout` (saída padrão).
- `text` indica que a saída será armazenada como string, não bytes.
- A saída padrão do processo é impressa.
A execução do código acima produz a seguinte saída:
20 lorem.txt
O tamanho e o nome do arquivo são fornecidos. Se você só precisa do tamanho, você deve separar a saída (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)
Resultado:
20
A saída, neste formato, não é legível. É possível deduzir que a unidade de medida é KB (devido aos métodos anteriores), mas não é intuitivo.
Para resolver isso, use o sinalizador -h (human-readable).
Observação: Execute man du ou du –help para mais informações.
from subprocess import run process = run(['du', '-h', 'lorem.txt'], capture_output=True, text=True) size = process.stdout.split()[0] print(size)
A saída será muito mais legível:
20K
Para mais informações sobre o módulo subprocess, veja o guia de subprocesso Python.
Obtenção do Tamanho de uma Pasta Recursivamente
Para obter o tamanho de uma pasta, você precisa iterar sobre todos os arquivos presentes no diretório e seus subdiretórios. Faremos isso com dois métodos:
- Iterando sobre um caminho com pathlib.
- Usando o comando du com subprocess.
O código abaixo usará um caminho para um diretório de teste. Substitua este caminho pelo diretório desejado.
Iterando sobre um Caminho com pathlib
Veja como obter o tamanho de um diretório iterando sobre o tamanho de seus 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))
Analisando o código:
- Importamos a classe Path e a função naturalsize().
- Definimos a função get_size(), com um parâmetro de caminho, que por padrão aponta para o diretório atual.
- A variável `size` é um marcador onde adicionaremos o tamanho de cada arquivo.
- Iteramos sobre todos os arquivos do caminho.
- Obtemos o tamanho de cada arquivo e o adicionamos à variável `size`.
- Retornamos a variável `size` em um formato legível.
Teste a função com um diretório existente em seu computador.
No meu caso, a saída é:
403.4 MB
Utilizando o Comando du com Subprocess
Essa abordagem possui vantagens:
- O resultado é mais preciso.
- É 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 para obter o tamanho de um diretório.
Resultado:
481M
As duas abordagens retornam resultados ligeiramente diferentes. Quanto maior o diretório, maior a diferença.
Escolha entre pathlib e subprocess. Se você sempre usar Linux, subprocess é uma boa escolha, caso contrário, use pathlib.
Resumo
Os recursos do Python para interação com o sistema operacional são cruciais para automatizar tarefas e economizar tempo. Os módulos chave são os, sys, path e subprocess.
Neste guia você aprendeu:
- Como Python interage com o sistema operacional.
- Como utilizar módulos integrados para operações de sistema operacional.
- O uso do módulo humanize para tornar as saídas legíveis.
- Como calcular o tamanho de um arquivo com 3 abordagens.
- Como calcular o tamanho de um diretório recursivamente ou com o comando du.