¿Cómo comprobar el tamaño de archivos y carpetas 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) hasta una compleja aplicación web.

Sin embargo, una de sus características más infravaloradas es la capacidad de interactuar con sistemas operativos. Gestionar las operaciones del sistema operativo con Python puede ahorrarle mucho tiempo a la hora de crear procesos de automatización.

Veamos cómo Python interactúa con el SO.

¿Cómo interactúa Python con el SO?

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 conseguir hacer cosas.

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

Como son módulos incorporados, no necesitará instalarlos con PIP. Puede importarlos todos con la siguiente sentencia:

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 (dependiendo de su SO). 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íficas 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 avanzado de rutas. Le permite representar sistemas de archivos como objetos, con la semántica pertinente para cada SO.
• Subproceso: Ejecución y gestión de subprocesos directamente desde Python. Esto implica trabajar con stdin, stdout y códigos de retorno. Puede aprender más sobre ello leyendo nuestra guía de subprocesos en Python.

Existen librerías de alto nivel que incluyen funcionalidades aún más específicas dependiendo de sus necesidades. Sin embargo, la mayor parte del tiempo estará bien con los módulos anteriores.

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

Ahora que ya tiene una idea rápida de cómo Python interactúa con el SO, pasemos a los métodos para comprobar el tamaño de archivos y carpetas. Todas las soluciones siguientes están disponibles en Tamaño de archivos y carpetas en el repositorio GitHub de Python

Usando os.stat().st_size

En este método, vamos a utilizar 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 utilizar os .stat().st_size es que no sigue simlinks.

Antes de continuar, vamos a crear un archivo de prueba llamado lorem.txt, en el que vamos a pegar un texto tonto. Podemos visitar un generador de texto 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 código que aparece a continuación:

import os
tamaño = os.stat('lorem.txt').st_tamaño
print(tamaño)

Desglosemos lo que estamos haciendo con este código:

• En la primera línea, estamos importando el módulo os
• La variable 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 size

Intente ejecutar el script Python. Obtendrá un resultado diferente dependiendo del contenido de su archivo lorem.txt.

Salida:

20064

La salida se representa en bytes. Esto no es nada legible, así que vamos a humanizarlo para tener una mejor perspectiva del tamaño del archivo.

En primer lugar, instale el paquete humanize, ejecutando el siguiente comando en su shell:

pip install humanize

A continuación, puede utilizar la función naturalsize( ) que convierte un valor en bytes en un tamaño de archivo legible, por ejemplo, KB, MB, GB o TB.

importar os
from humanize import naturalsize

tamaño = os.stat('lorem.txt').st_tamaño

print(tamaño)
print(naturalsize(tamaño))

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

Uso de Pathlib

Aunque pathlib está diseñado para trabajar exclusivamente con trayectos, 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

A continuación, cree un objeto Path pasando la ruta al archivo lorem.txt como argumento.

archivo_ = 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(archivo_.stat().st_tamaño)

Salida:

20064

Como puede ver, obtenemos el mismo resultado que con el primer método que utilizamos. El resultado anterior también se imprime en formato byte, por lo que podemos utilizar el módulo humanize para hacerlo legible.

from pathlib import ruta
from humanize import naturalsize

tamaño = Path('lorem.txt').stat().st_tamaño

print(naturalsize(tamaño))

Este código produce la siguiente salida:

20.1 kB

Uso de comandos Unix con Subproceso:

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

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

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

from subproceso import ejecutar

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

print(proceso.stdout)

Profundizando en este trozo de código

• Importamos la función ejecutar del módulo subproceso
• La variable proceso contiene el resultado de ejecutar la orden 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 standout (salida estándar)
  • text 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á la siguiente salida:

20 lorem.txt

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

from subproceso import ejecución

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

tamaño = process.stdout.split()<x><x>[0]</x></x>

print(tamaño)

Salida:

20

Esta salida no es legible en absoluto. Podemos deducir que la unidad de medida utilizada es KB (debido a los métodos anteriores), pero nadie más podría 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 subproceso import ejecutar

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

tamaño = process.stdout.split()<x><x>[0]</x></x>

print(tamaño)

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

20K

Si quiere saber más sobre el módulo de subprocesos y sus posibles aplicaciones, consulte nuestra guía de subprocesos en Python.

Obtener el tamaño de una carpeta de forma recursiva

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

• Iterando sobre una ruta con pathlib
• Utilizando el comando du con subproceso

El siguiente código utilizará una ruta a un directorio de prueba dentro de mi carpeta home. Tendrá que sustituir 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 ruta
from humanize import tamaño natural

def obtener_tamaño(ruta = '.'):
    tamaño = 0

    para archivo_ en ruta(ruta).rglob('*'):

        tamaño = archivo_.stat().st_tamaño
    
    return naturalsize(tamaño)

test_path = Path.home() / 'Documentos/pruebas/'

print(get_size(ruta_prueba))

Este trozo de código parece un poco aterrador, desglosemos lo que hace cada parte.

• Importe la clase Path y la función naturalsize ()
• Defina la función get_size () con un parámetro path, que por defecto apunta al directorio actual.
• La variable tamaño es sólo un marcador de posición en el que iremos añadiendo el tamaño de cada archivo
• Itere sobre cada archivo de la ruta
  • El método rglob( ) devuelve recursivamente los archivos que coinciden con el patrón
  • rglob(‘*’), significa que estamos obteniendo todos los archivos dentro del directorio
• Obtiene el tamaño de cada archivo y lo añade a la variable de tamaño
• Devuelve la variable de tamaño de forma legible para el ser humano

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

En mi caso, obtengo la siguiente salida:

403.4 MB

Uso del comando du con subproceso

Este enfoque tiene algunas ventajas:

• El resultado es un poco más preciso
• Es mucho más rápido

from subproceso import ejecución
from pathlib import ruta

test_path = Path.home() / 'Documentos/pruebas/'

process = run(['du', '-sh', test_path], capture_output=True, text=True)

tamaño = process.stdout.split()<x><x>[0]</x></x>

print(tamaño)

Estamos utilizando el mismo enfoque que en el método 3, pero esta vez estamos obteniendo 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 más diferencia obtendrá.

Depende de usted elegir entre los enfoques pathlib o subproceso . Si sabe que va a utilizar Linux siempre utilice subproceso, de lo contrario puede utilizar la solución pathlib.

En resumen

Python resulta extremadamente práctico a la hora de interactuar con el SO. Puede automatizar procesos y ahorrar mucho tiempo con Python. Los principales módulos para interactuar con el SO son os, sys, path y subprocess.

En este tutorial usted aprendió:

• Cómo Python interactúa con el SO
• El uso de módulos incorporados para realizar operaciones con el SO
• Cómo utilizar el módulo humanize para imprimir legible por humanos
• A calcular el tamaño de un archivo con 3 aproximaciones
• Para calcular el tamaño de un directorio recursivamente o con el comando du