¿Cómo verificar el tamaño de archivo y carpeta en Python?

En este artículo, aprenderá a comprobar el tamaño de un archivo o carpeta en Python

Python es uno de los lenguajes de programación más versátiles. Con él, podrá construir desde un pequeño programa CLI (interfaz de línea de comandos) a un aplicación web compleja.

Sin embargo, una de sus características más subestimadas es la capacidad de interactuar con los sistemas operativos. La gestión de las operaciones del sistema operativo con Python puede ahorrarle mucho tiempo al crear procesos de automatización.

Veamos cómo Python interactúa con el sistema operativo.

¿Cómo interactúa Python con el sistema operativo?

Python interactúa con el SO con los módulos os, sys, path y subprocess

Nadie puede vivir aislado de su entorno. Eso también se aplica en Python, donde a veces es fundamental interactuar con el sistema operativo para hacer las cosas.

Python tiene varios módulos que nos permiten interactuar con el sistema operativo. Los más utilizados son os, sys, pathlib y subproceso.

Dado que son módulos integrados, no necesitará instalarlos con PIP. Puede importarlos todos con la siguiente declaración:

import os
import sys
import pathlib
import subprocess

La siguiente lista indica la funcionalidad principal de cada una de estas importaciones:

Os: Manera portátil de utilizar la funcionalidad específica del sistema (según su sistema operativo). Es la elección correcta en la mayoría de los casos, a menos que necesite algo más avanzado.
sys: Parámetros y funciones específicos del sistema. Este módulo proporciona acceso a las variables y funciones del intérprete. El módulo os interactúa con el sistema operativo y sys interactúa con el intérprete de Python
Pathlib: Uso de ruta avanzado. Le permite representar sistemas de archivos como objetos, con la semántica pertinente para cada sistema operativo.
Subproceso: Gestión de ejecuciones y subprocesos directamente desde Python. Eso implica trabajar con el stdin, stdouty códigos de retorno. Puede obtener más información al respecto leyendo nuestro Guía de subprocesos de Python.

Existen bibliotecas de alto nivel que incluyen funciones aún más específicas según sus necesidades. Sin embargo, la mayoría de las veces está listo para usar los módulos anteriores.

Nota: La mayoría de las funciones proporcionadas por estos módulos tendrán una salida diferente según su sistema operativo. Recuerde que, por lo general, la mejor combinación es UNIX y Python.

Ahora que tiene una idea rápida de cómo Python interactúa con el sistema operativo, veamos los métodos para verificar el tamaño de archivos y carpetas. Todas las siguientes soluciones están disponibles en el Tamaño de archivo y carpeta en Python Repositorio GitHub

Using os.stat().st_size

En este método, usaremos el stat () función desde el módulo del sistema operativo. Devuelve mucha información sobre una ruta específica.

Nota: La os.path.getsize () La función también hace el trabajo. La ventaja de usar os.stat ().st_size es que no sigue simlinks.

Antes de continuar, creemos un archivo de prueba llamado lorem.txt, en el que vamos a pegar algunos texto tonto. Podemos visitar un Generador de texto Lorem Ipsum y pegue el texto en el lorem.txt archivo.

En el mismo directorio, cree un archivo con el nombre método1.py y pega el código a continuación:

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

Analicemos lo que estamos haciendo con este código:

En la primera línea, estamos importando el os módulo
La variable de tamaño contiene el tamaño del archivo. lorem.txt
- La os.stat () La función devuelve un montón de información relacionada con el archivo.
- La st_size atributo representa el tamaño del archivo
Imprimimos el tamaño variable

Trate de ejecutar la secuencia de comandos de Python. Obtendrá un resultado diferente según el contenido de su lorem.txt archivo.

Salida:

La salida se representa en bytes. Esto no se puede leer en absoluto, así que humanicémoslo para que podamos tener una mejor perspectiva del tamaño del archivo.

Primero, instale el humanizar paquete, ejecutando el siguiente comando en su shell:

pip install humanize

Entonces puedes usar el tamaño natural () función que convierte un valor en bytes en un tamaño de archivo legible, por ejemplo, KB, MB, GB o TB.

import os
from humanize import naturalsize

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

print(size)
print(naturalsize(size))

Al principio, el código anterior imprime el tamaño del archivo en bytes y luego imprime el resultado en un tamaño legible.

Salida:

20064
20.1 kB

Using Pathlib

Aunque Pathlib Está diseñado para trabajar exclusivamente con rutas, incorpora algunas funciones útiles de otros módulos como métodos de objetos Path (Instancias de la clase Path).

Crear un archivo método2.py e importar el Clase de ruta.

from pathlib import Path

Luego crea un objeto Path pasando la ruta al lorem.txt archivo como argumento.

file_ = Path('lorem.txt')

Ahora, puede acceder al stat () método de la clase Path. Funciona igual que el os.stat () función, por lo tanto, podrá imprimir el tamaño del archivo.

print(file_.stat().st_size)

Salida:

Como puede ver, obtuvimos el mismo resultado que con el primer método que usamos. El resultado anterior también se imprime en formato de bytes, por lo que podemos usar el módulo humanizar para hacerlo legible.

from pathlib import Path
from humanize import naturalsize

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

print(naturalsize(size))

Este código produce la siguiente salida:

20.1 kB

Using Unix commands with Subprocess:

El módulo de subproceso, nos permite llamar y administrar subprocesos desde Python. Por lo tanto, podemos ejecutar cualquier comando y tratar su salida directamente en Python.

Nota: Este método solo funciona si está ejecutando un sistema operativo Unix (Linux, Mac)

Abrir el archivo método3.py y pega el código a continuación:

from subprocess import run

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

print(process.stdout)

Buceando en este fragmento de código:

Importamos el ejecutar función desde el módulo de subproceso
El proceso variable contiene el resultado de ejecutar el comando du lorem.txt
- du es una utilidad de Linux que nos permite obtener el espacio en disco de un archivo
- captura_salida nos da acceso al atributo destacado (salida estándar)
- texto significa que estamos almacenando la salida como una cadena en lugar de bytes
Imprimimos la salida estándar del proceso

Si ejecuta el código anterior, obtendrá el siguiente resultado:

20      lorem.txt

Como puede ver, nos da el tamaño y el nombre del archivo. Si solo desea obtener el tamaño del archivo, deberá dividir la salida (recuerde que es una cadena) e imprimir el primer elemento.

from subprocess import run

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

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

print(size)

Salida:

Esta salida no es legible en absoluto. Podemos inferir que la unidad de medida utilizada es KB (debido a los métodos anteriores), pero nadie más pudo adivinar el tamaño del archivo.

Para resolver este problema, podemos hacer uso de la -h (legible por humanos).

Nota: Puede obtener un manual de este comando ejecutando hombre duo du-ayuda.

from subprocess import run

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

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

print(size)

Ahora la salida de este script será mucho más legible:

20K

Si desea saber más sobre el módulo de subprocesos y sus posibles aplicaciones, consulte nuestro Guía de subprocesos de Python.

Get the Size of a Folder Recursively

Si desea obtener el tamaño de una carpeta, deberá iterar sobre cada archivo presente en el directorio y sus subdirectorios. Lo haremos con dos métodos:

Iterando sobre una ruta con pathlib
Usando el comando du con subproceso

El siguiente código utilizará una ruta a un directorio de prueba dentro de mi carpeta de inicio. Deberá reemplazar la ruta de ese archivo por el directorio del que desea obtener el tamaño.

Iterando sobre una ruta con pathlib

Veamos cómo puede obtener el tamaño de un directorio iterando sobre los tamaños de los archivos.

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 fragmento de código parece un poco aterrador, analicemos lo que hace cada parte.

Importar el Path clase y la tamaño natural () función
Definir el get_size () función con un parámetro camino, que apunta al directorio actual de forma predeterminada.
La variable de tamaño es solo un marcador de posición en el que agregaremos el tamaño de cada archivo
Iterar sobre cada archivo de la ruta
- La rglob () El método devuelve de forma recursiva los archivos que coinciden con el patrón
- rglob ('*'), significa que estamos obteniendo todos los archivos dentro del directorio
Obtenga el tamaño de cada archivo y agréguelo a la variable de tamaño
Devuelve la variable de tamaño de forma legible por humanos.

Por supuesto, estoy probando la función con un directorio disponible solo en mi máquina. No olvide cambiar la ruta a una carpeta que exista en su computadora.

En mi caso, obtengo el siguiente resultado:

403.4 MB

Usando el comando du con subproceso

Este enfoque tiene algunas ventajas:

El resultado es un poco más preciso
Es mucho mas rapido

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 el mismo enfoque que el método 3, pero esta vez obtenemos el tamaño de un directorio en lugar de un archivo.

Salida:

481M

Como puede ver, estas dos formas de obtener el tamaño de una carpeta, devuelve un resultado ligeramente diferente. Cuanto más grande sea el directorio, mayor será la diferencia que obtendrá.

Depende de usted elegir entre Pathlib o subproceso enfoques. Si sabe que utilizará Linux cada vez que utilice subproceso, de lo contrario, puede usar la solución pathlib.

Para resumir

Python resulta extremadamente útil al interactuar con el sistema operativo. Puede automatizar procesos y ahorrar mucho tiempo con Python. Los principales módulos para interactuar con el sistema operativo son os, sys, path y subprocess.

En este tutorial aprendiste:

Cómo interactúa Python con el sistema operativo
El uso de módulos integrados para realizar operaciones del sistema operativo
Como utilizar el humanizar módulo para imprimir legible por humanos
Para calcular el tamaño de un archivo con 3 enfoques
Para calcular el tamaño de un directorio de forma recursiva o con la du comando