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

En este artículo, aprenderá a verificar 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á crear desde un pequeño programa CLI (interfaz de línea de comandos) hasta una aplicación web compleja.

Sin embargo, una de sus características más subestimadas es la capacidad de interactuar con los sistemas operativos. Administrar 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?

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 subprocess.

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: forma portátil de utilizar la funcionalidad específica del sistema (según el 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: Ejecución y gestión de subprocesos directamente desde Python. Eso implica trabajar con los códigos stdin , stdout y return. Puede obtener más información al respecto leyendo nuestra guía de subprocesos de Python.

Existen bibliotecas de alto nivel que incluyen funcionalidades 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 el repositorio de Python GitHub

Usando os.stat (). St_size

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

Nota: La función os.path.getsize () 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 un texto tonto . Podemos visitar un generador de texto de Lorem Ipsum y pegar el texto en el archivo lorem.txt .

En el mismo directorio, cree un archivo con el nombre method1.py y pegue el siguiente código:

 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 módulo del sistema operativo.
• La variable de tamaño contiene el tamaño del archivo lorem.txt
  • La función os.stat () devuelve un montón de información relacionada con el archivo
  • El atributo st_size representa el tamaño del archivo
• Imprimimos la variable de tamaño

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

Producción:

 20064

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

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

 pip install humanize

Luego puede usar la función naturalsize () que convierte un valor en bytes a 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.

Producción:

 20064 20.1 kB

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

Cree un archivo method2.py e importe la clase Path.

 from pathlib import Path

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

 file_ = Path('lorem.txt')

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

 print(file_.stat().st_size)

Producción:

 20064

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

Usando comandos Unix con 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)

Abra un archivo method3.py y pegue el siguiente código:

 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 la función de ejecución del 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
  • capture_output 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)

Producción:

 20

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 bandera -h (legible por humanos).

Nota: Puede obtener un manual de este comando ejecutando man du o du –help .

 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 las posibles aplicaciones, consulte nuestra guía de subprocesos de Python.

Obtener el tamaño de una carpeta de forma recursiva

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 usará 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 la clase Path y la función naturalsize ()
• Defina la función get_size () con una ruta de parámetro, que apunta al directorio actual por defecto.
• 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
  • El método rglob () 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.

Producción:

 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 los enfoques de pathlib o de subproceso . Si sabe que usará Linux cada vez que use un 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
• Cómo utilizar el módulo humanizar para imprimir en formato 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 el comando du