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ê poderá construir desde um pequeno programa CLI (interface de linha de comando) até uma aplicação web complexa.
No entanto, uma de suas características mais subestimadas é a capacidade de interagir com sistemas operacionais. O gerenciamento de 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.
últimas postagens
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 tem 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 embutidos, você não precisará instalá-los com PIP. Você pode importar todos eles com a seguinte declaração:
import os import sys import pathlib import subprocess
A lista abaixo indica as principais funcionalidades de cada uma dessas importações:
- Os: Maneira portátil de usar a funcionalidade específica 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 return. 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ê pode usar os módulos acima.
Nota: A maioria das funções fornecidas por esses módulos terá uma saída diferente dependendo do seu sistema operacional. Lembre-se de que geralmente a melhor correspondência é UNIX e Python.
Agora que você tem uma noção rápida de como o Python interage com o sistema operacional, vamos pular para os métodos de verificação do tamanho do arquivo e da pasta. Todas as soluções a seguir estão disponíveis no Tamanho de arquivo e pasta no Python Repositório GitHub
Usando os.stat().st_size
Neste método, vamos usar o Estado() função do módulo os. Ele retorna muitas informações sobre um caminho específico.
Nota: A função os.path.getsize() também faz o trabalho. A vantagem de usar os.stat().st_size é que ele não segue links sim.
Antes de continuar, vamos criar um arquivo de teste chamado lorem.txt, no qual vamos colar algum texto idiota. Podemos visitar um Lorem Ipsum gerador de texto e cole 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 size contém o tamanho do arquivo lorem.txt
- A função os.stat() retorna várias 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.
Resultado:
20064
A saída é representada em bytes. Isso não é legível, então vamos humanizá-lo para que possamos ter uma melhor perspectiva do tamanho do arquivo.
Primeiro, instale o humanizar pacote, 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 em 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 depois imprime o resultado em um tamanho legível.
Resultado:
20064 20.1 kB
Usando Pathlib
Embora pathlib é 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 o Classe de caminho.
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)
Resultado:
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))
Esse 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 subprocessos do Python. Portanto, podemos executar qualquer comando e tratar sua saída diretamente no Python.
Nota: 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:
- Nós importamos o executar função do módulo de subprocesso
- A variável process contém o resultado da execução do comando du lorem.txt
- du é um utilitário 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)
- text 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á a seguinte saída:
20 lorem.txt
Como você pode ver, ele nos dá o tamanho e o nome do arquivo. Se você deseja obter apenas 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)
Resultado:
20
Esta saída não é legível. Podemos inferir que a unidade de medida utilizada é KB (por causa dos métodos anteriores), mas ninguém mais poderia adivinhar o tamanho do arquivo.
Para resolver esse problema, podemos usar o sinalizador -h (legível por 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 aplicações, confira nosso guia de subprocesso Python.
Obter 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 subprocess
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 que deseja obter o tamanho.
Iterando sobre um caminho com pathlib
Vamos ver como você pode obter o tamanho de um diretório iterando sobre 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 detalhar 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 espaço reservado no qual adicionaremos o tamanho de cada arquivo
- Iterar sobre cada arquivo do caminho
- Obtenha o tamanho de cada arquivo e adicione-o à variável de tamanho
- Retorna a variável de tamanho de 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 existente no seu computador.
No meu caso, obtenho a seguinte saída:
403.4 MB
Usando o Comando du com Subprocess
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 estamos obtendo o tamanho de um diretório em vez de um arquivo.
Resultado:
481M
Como você pode ver, essas duas maneiras de obter o tamanho de uma pasta retornam um resultado ligeiramente diferente. Quanto maior o diretório, mais diferença você terá.
Cabe a você escolher entre as abordagens pathlib ou subprocess. Se você sabe que usará o Linux sempre, use o subprocesso, caso contrário, 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