• ¡Obtenga la seguridad de la aplicación de la manera correcta! Detectar, proteger, monitorear, acelerar y más ...
  • 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  stdinstdouty 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

    Usando 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 method1.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:

    20064

    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

    Usando Pathlib

    Aunque el 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 method2.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:

    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)

    Abrir el archivo method3.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:

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

    Nota: Puede obtener un manual de este comando ejecutando hombre dudu –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 sus posibles aplicaciones, consulte nuestro 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 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 Camino 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 las 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