• ¡Obtenga la seguridad de la aplicación de la manera correcta! Detectar, proteger, monitorear, acelerar y más ...
  • La biblioteca estándar de Python contiene la mayor parte de la funcionalidad que un desarrollador necesitaría para resolver un problema. En este tutorial, aprenderá diferentes formas de verificar la existencia de un archivo o directorio utilizando solo módulos integrados.

    Verificando si un archivo o guión está en el lugar correcto es crucial para cualquier programa CLI. Su programa podría volverse inútil si un archivo específico no está en su lugar en el momento de la ejecución.

    En el tutorial de hoy, aprenderá algunas formas rápidas de verificar si un archivo o carpeta existe en Python.

    Antes de empezar

    Antes de ejecutar cualquier comando a continuación, asegúrese de tener Python 3 instalado en su sistema. Abra su terminal y escriba el siguiente comando:

    python --version
    # Python 3.9.5, my result

    Si tiene una versión 2.x, deberá usar el comando "python3". Echa un vistazo a nuestro Guía de instalación de Python si no tiene Python 3 instalado.

    Usaremos algunos archivos de prueba junto con este tutorial, así que asegúrese de crear los siguientes archivos:

    touch testfile.txt
    mkdir testdirectory/ 
    touch testdirectory/otherfile.txt

    Los comandos anteriores crean un archivo para jugar, un directorio de prueba y otro archivo dentro del directorio de pruebas. Los archivos pueden estar vacíos ya que no necesitaremos leer su contenido,

    Nota: Si está utilizando Windows, configure esa estructura de archivos simple con un administrador de archivos gráfico.

    Finalmente, usaremos Ipython como nuestro shell interactivo de Python que ofrece una bonita interfaz para trabajar. Esto es solo una mercancía, por lo tanto, no es estrictamente necesario.

    pip install ipython

    Después de hacer esto, obtendrá acceso a un hermoso shell de Python con solo escribir ipython.

    Shell interactivo Ipython ejecutando Python 3.9

    Ahora que está todo listo, profundicemos en las formas de verificar si una carpeta o archivo existe en Python.

    Prueba, abre y excepto

    Ésta es la opción más sencilla. Si intenta abrir un archivo que no existe, Python generará un FileNotFoundError.

    In [1]: open('im-not-here.txt')
    ---------------------------------------------------------------------------
    FileNotFoundError: [Errno 2] No such file or directory: 'im-not-here.txt'
    

    Podemos aprovechar esto y manejar la excepción en caso de que el archivo que estamos buscando no exista.

    In [2]: try:
       ...:     file = open('im-not-here.txt')
       ...:     print(file) # File handler
       ...:     file.close()
       ...: except FileNotFoundError:
       ...:     print('Sorry the file we\'re looking for doesn\' exist')
       ...:     exit()
       ...: 
    Sorry the file we're looking for doesn't exist
    

    En el código anterior, estamos imprimiendo un mensaje personalizado y deteniendo la ejecución del programa si el archivo no existe.

    Tenga en cuenta cómo el salida() La función solo se ejecutará si se genera una excepción. Veamos qué sucede cuando el archivo que estamos buscando existe realmente.

    In [2]: try:
       ...:     file = open('testfile.txt')
       ...:     print(file) # File handler
       ...:     file.close()
       ...: except FileNotFoundError:
       ...:     print('Sorry the file we\'re looking for doesn\'t exist')
       ...:     exit()
       ...: 
    <_io.TextIOWrapper name='testfile.txt' mode='r' encoding='UTF-8'>

    Observe cómo cerramos el archivo justo después de abrirlo. Se considera una buena práctica según la Documentación de Python.

    llamar <span class="pre">file.write()</span> sin usar el <span class="pre">with</span> palabra clave o llamada <span class="pre">file.close()</span> podría resultar en los argumentos de <span class="pre">file.write()</span> no se escribe completamente en el disco, incluso si el programa se cierra correctamente.

    Incluso si no estamos escribiendo en el archivo, es muy recomendable cerrar el archivo porque podría provocar múltiples problemas de rendimiento.

    Si no queremos cerrar el archivo por nosotros mismos, podríamos usar el con administrador de contexto. Asigna y libera recursos con precisión, por lo que no necesitaremos cerrar el archivo.

    In [3]: try:
       ...:     with open('testfile.txt') as file:
       ...:         print(file)
       ...:         # No need to close the file
       ...: except FileNotFoundError:
       ...:     print('Sorry the file we\'re looking for doesn\'t exist')
       ...:     exit()
       ...: 
       ...: 
    <_io.TextIOWrapper name='testfile.txt' mode='r' encoding='UTF-8'>
    

    Este método es extremadamente útil cuando se escribe en archivos, pero resulta ineficaz si solo queremos verificar si existe un archivo. Analicemos otras opciones para lograrlo.

    os.path.exists ()

    La módulo del sistema operativo proporciona múltiples funciones para interactuar con el sistema operativo. Para comprobar si existe un archivo o carpeta podemos utilizar el camino.existe () función que acepta la ruta al archivo o directorio como argumento. Devuelve un valor booleano basado en la existencia de la ruta.

    Nota: Una ruta es la ubicación única de un archivo o directorio en un sistema de archivos.

    En Python, el os.path El submódulo contiene funciones diseñadas exclusivamente para operar con rutas de archivo. Todas estas funciones aceptan el argumento de ruta como cadenas o bytes, y puede decidir trabajar con rutas absolutas, por ejemplo:

    /home/daniel/.bashrc

    O con rutas relativas, dependiendo del directorio en el que esté ejecutando el script:

    .bashrc
    # Running the script in my home folder

    Aquí hay varios ejemplos que utilizan el os.path.exists () función, ejecutándose en el directorio donde se encuentran mis archivos de prueba:

    In [1]: import os
    
    In [2]: os.path.exists('testfile.txt')
    Out[2]: True
    
    In [3]: os.path.exists('testdirectory')
    Out[3]: True
    
    In [4]: os.path.exists('hey-i-dont-exist')
    Out[4]: False

    Como ves, vuelve Verdadero al probar con el testfile.txt archivo y el testdirectory carpeta, y Falso cuando el archivo no existe.

    os.path.isfile ()

    Si solo quisiera probar la existencia de un archivo (no un directorio), llamaría al os.path.isfile () función.

    In [1]: import os
    
    In [2]: os.path.isfile('testfile.txt')
    Out[2]: True
    
    In [3]: os.path.isfile('testdirectory/')
    Out[3]: False
    
    In [4]: os.path.isfile('i-dont-even-exist')
    Out[4]: False
    
    In [5]: os.path.isfile('testdirectory/otherfile.txt')
    Out[5]: True
    

    Nota: En UNIX, todos los directorios terminan con una barra inclinada (/), mientras que en Windows usamos una barra invertida (\).

    En el código sobre el isfile () retorno de función Falso en dos ocasiones, veamos por qué:

    • testdirectory/ es un directorio, por lo que no se considera un archivo. Esto no es absolutamente cierto ya que en Linux todo es un descriptor de archivo, pero Python trata los directorios de manera diferente solo por conveniencia (si intenta abrir un directorio obtendrá un IsADirectoryError)
    • i-dont-even-exist apunta a un archivo que, irónicamente, no existe

    os.path.isdir ()

    Si desea comprobar que un directorio está en el lugar correcto, deberá utilizar el os.path.isdir () función, que solo devuelve Verdadero si la ruta dada apunta a un directorio.

    In [1]: import os
    
    In [2]: os.path.isdir('testfile.txt')
    Out[2]: False
    
    In [3]: os.path.isdir('testdirectory')
    Out[3]: True
    
    In [4]: os.path.isdir('anotherfile.txt')
    Out[4]: False
    

    Observe cómo regresan los ejemplos anteriores Falso incluso cuando la ruta apunta a un archivo que existe.

    Glob

    La glob El módulo proporciona funciones para trabajar Patrones tipo shell de Unix (por lo tanto, no funciona correctamente en Windows). Para comprobar si un archivo coincide con un patrón dentro del directorio actual, puede utilizar el glob.glob () función.

    In [1]: import glob
    
    In [2]: glob.glob('testfile.txt')
    Out[2]: ['testfile.txt']
    
    In [3]: glob.glob('testdirectory')
    Out[3]: ['testdirectory']
    

    En el código anterior, el patrón pasado a la función glob es una cadena normal que representa la ruta al archivo y directorio de prueba. Dado que existen ambas rutas, la función devuelve una lista con los nombres de ruta coincidentes dentro de ella.

    Nota: Si el patrón no coincidía, obtendría una lista vacía.

    Teniendo en cuenta que podemos pasar patrones a la función glob, ¿por qué no probar algunas de sus principales ventajas?

    El siguiente código obtiene todas las rutas de archivo con una extensión. .TXT py respectivamente:

    In [4]: glob.glob('*.txt')
    Out[4]: ['testfile.txt']
    
    In [5]: glob.glob('*.py')
    Out[5]: 
    ['pathlib-exists.py',
     'list-dir.py',
     'glob-file.py',
     'open-except.py',
     'subprocess-test.py',
     'isfile.py',
     'exists.py',
     'isdir.py']

    Usando la clase de ruta

    La Clase de ruta es una de las mejores formas de trabajar con rutas, ya que nos brinda una interfaz limpia para trabajar con rutas de archivos como objetos.

    La cereza del pastel es que las instancias de ruta tienen todos los métodos que necesita para obtener información sobre una ruta determinada. Esto incluye funcionalidades similares a las opciones anteriores.

    Nota: Necesitará Python 3.4 o superior para usar la biblioteca pathlib

    Los métodos de ruta que usará:

    Comprueba si existe una ruta

    In [1]: from pathlib import Path
    
    In [2]: Path('testfile.txt').exists()
    Out[2]: True
    
    In [3]: Path('im-not-here.txt').exists()
    Out[3]: False
    
    In [4]: Path('testdirectory').exists()
    Out[4]: True
    

    Funciona igual que os.path.exists ().

    Compruebe si la ruta apunta a un archivo

    In [5]: Path('testfile.txt').is_file()
    Out[5]: True
    
    In [6]: Path('testdirectory').is_file()
    Out[6]: False
    

    Equivalente a os.path.isfile ().

    Compruebe si la ruta apunta a un directorio

    In [7]: Path('testfile.txt').is_dir()
    Out[7]: False
    
    In [8]: Path('testdirectory').is_dir()
    Out[8]: True
    

    Corresponde a os.path.isdir ().

    subproceso

    Si eres un módulo de subproceso amante, necesitará conocer esta opción. Puede determinar si existe un archivo o carpeta utilizando el comando de prueba.

    Nota: La prueba El comando solo funciona en Unix.

    Las siguientes banderas de prueba harán el trabajo:

    • prueba -e: Comprueba si existe una ruta
    • prueba -f: Compruebe si existe un archivo
    • prueba-d: Comprueba si existe una carpeta

    En caso de que desee sumergirse en más banderas de prueba, puede leer el manual ejecutando:

    man test

    Comprobación de una ruta con subproceso:

    El siguiente código determina si existe una ruta comparando el código de retorno del subproceso con 0.

    Recuerde que en Linux, si un proceso salió bien, devolverá cero, si no, devolverá cualquier otro código.

    In [1]: from subprocess import run
    
    In [2]: run(['test', '-e', 'testfile.txt']).returncode == 0
    Out[2]: True
    
    In [3]: run(['test', '-e', 'im-not-here.txt']).returncode == 0
    Out[3]: False
    

    En la primera declaración, estamos importando el módulo de subproceso, luego usamos el ejecutar función y obteniendo su código de retorno.

    Verificando la existencia de un archivo con subproceso

    In [4]: run(['test', '-f', 'testfile.txt']).returncode == 0
    Out[4]: True
    
    In [5]: run(['test', '-f', 'testdirectory']).returncode == 0
    Out[5]: False
    

    Comprobando un directorio con subproceso:

    In [6]: run(['test', '-d', 'testfile.txt']).returncode == 0
    Out[6]: False
    
    In [7]: run(['test', '-d', 'testdirectory']).returncode == 0
    Out[7]: True
    

    No se recomienda usar esta opción, ya que consume más recursos y no obtenemos ninguna ventaja de ella.

    Para resumir

    Python es uno de los más utilizados lenguajes de programación para automatizar procesos interactuando con el sistema operativo. Una cosa interesante que puede hacer con él es comprobar si existe un archivo o una carpeta.

    Los más sencillos de hacerlo son:

    • Abrir y manejar excepciones de archivos de inmediato
    • Usando el patrón de velas del existe () función de la os.path or pathlib módulos.

    En este tutorial aprendiste:

    • Cómo abrir un archivo y manejar excepciones en caso de que no exista
    • El significado de los caminos
    • 3 funciones diferentes el os.path El submódulo proporciona para verificar la existencia de un archivo o carpeta.
    • Unix usa barras diagonales (/), mientras que Windows usa barras diagonales inversas (\)

    Siguiente lectura: ¿Qué es un subproceso en Python? [5 ejemplos de uso]