¿Cómo verificar el tamaño del archivo y la 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 toneladas de tiempo al crear procesos de automatización.

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

Tabla de contenido

¿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 usar la funcionalidad específica del sistema (dependiendo de su sistema operativo). Es la elección correcta en la mayoría de los casos a menos que necesites 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 avanzado de rutas. Le permite representar sistemas de archivos como objetos, con la semántica pertinente para cada sistema operativo.
Subproceso: Gestión de ejecución y 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 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 Pitón.

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

Usando os.stat().st_size

En este método, vamos a utilizar el estadística() función 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 enlaces sim.

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 Lorem Ipsum y pegue el texto en el archivo lorem.txt.

En el mismo directorio, cree un archivo con el nombre method1.py y pegue 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 módulo os
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 tamaño

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

Producción:

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 humanizar paquete, ejecutando el siguiente comando en su shell:

pip install humanize

Luego, puede usar la función naturalsize() 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.

Producción:

20064
20.1 kB

Usando Pathlib

A pesar de que rutalib 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 el Clase de ruta.

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:

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 byte, 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 el siguiente resultado:

20.1 kB

Usando comandos de Unix con Subproceso:

El módulo de subprocesos, 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)

Sumergiéndonos en este fragmento de código:

Importamos el ejecutar función del módulo de subprocesos
La variable proceso 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 sobresaliente (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 está dando 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:

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 podría adivinar el tamaño del archivo.

Para resolver este problema, podemos hacer uso del indicador -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 obtener más información 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 recursivamente

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 en el 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.

Importe 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 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
Obtenga el tamaño de cada archivo y agréguelo a la variable de tamaño
Devuelve la variable de tamaño de una manera 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

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

Usamos 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 devuelven 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 usará Linux cada vez que use el 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 módulos principales 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 de humanización para imprimir de forma legible por humanos
Para calcular el tamaño de un archivo con 3 enfoques
Para calcular el tamaño de un directorio recursivamente o con el comando du