38 Pregunta: ¿Cómo verifico si un archivo existe sin excepciones?

pregunta creada en Mon, Nov 5, 2018 12:00 AM

¿Cómo puedo ver si un archivo existe o no, sin usar el try declaración?

    
5065
  1. ¿Por qué querrías evitar las excepciones en Python? Son la forma idiomática de hacer las cosas.
    2019-03-27 14: 39: 30Z
  2. Porque, si tiene una pieza importante de código que depende del archivo que no existe, al colocarlo en la cláusula except:, se creará una excepción en esta parte del código. generará un mensaje confuso (segundo error surgido durante el procesamiento del primero).
    2019-05-24 10: 40: 02Z
30 Respuestas                              30                         

Si la razón por la que estás verificando es para poder hacer algo como if file_exists: open_it(), es más seguro usar un try para intentar abrirlo. Al verificar y luego abrir, se corre el riesgo de que el archivo se elimine o se mueva, o algo así cuando se comprueba y cuando se intenta abrir.

Si no planea abrir el archivo inmediatamente, puede usar os.path.isfile

  

Devuelve True si la ruta es un archivo regular existente. Esto sigue a los enlaces simbólicos, por lo que ambos islink () y isfile () puede ser cierto para la misma ruta.

 
import os.path
os.path.isfile(fname) 

si necesitas estar seguro de que es un archivo.

Comenzando con Python 3.4, pathlib module ofrece un enfoque orientado a objetos (backported a pathlib2 en Python 2.7):

 
from pathlib import Path

my_file = Path("/path/to/file")
if my_file.is_file():
    # file exists

Para verificar un directorio, haz:

 
if my_file.is_dir():
    # directory exists

Para verificar si un objeto Path existe independientemente de si es un archivo o directorio, use exists():

 
if my_file.exists():
    # path exists

También puedes usar resolve(strict=True) en un bloque try:

 
try:
    my_abs_path = my_file.resolve(strict=True)
except FileNotFoundError:
    # doesn't exist
else:
    # exists
    
4642
2019-05-13 10: 40: 43Z
  1. en relación con el primer comentario (use "try" si se comprueba antes de abrir) desafortunadamente esto no funcionará si desea abrir para adjuntar, estar seguro de que existe antes ya que 'a' el modo creará si no existe.
    2018-06-20 07: 58: 09Z
  2. Tenga en cuenta que FileNotFoundError se introdujo en Python 3. Si también necesita ser compatible con Python 2.7 y Python 3, puede usar IOError en su lugar (que son las FileNotFoundError subclases) stackoverflow.com/a/21368457/1960959
    2019-03-29 13: 44: 15Z
  3. @ makapuf Puede abrirlo para "actualizar" (open('file', 'r+')) y luego buscar hasta el final.
    2019-04-30 17: 45: 44Z
  4. os.path.isfile (fname) es todo lo que necesito. ¡Gracias!
    2019-05-30 10: 30: 46Z

Tiene la función os.path.exists :

 
import os.path
os.path.exists(file_path)

Esto devuelve True tanto para archivos como para directorios, pero en su lugar puede usar

 
os.path.isfile(file_path)

para probar si es un archivo específicamente. Sigue los enlaces simbólicos.

    
1936
2018-10-19 08: 58: 59Z

A diferencia de isfile() , exists() devolverá True para directorios.
Entonces, dependiendo de si solo desea archivos simples o directorios, utilizará isfile() o exists(). Aquí hay una salida REPL simple.

 
>>> print os.path.isfile("/etc/password.txt")
True
>>> print os.path.isfile("/etc")
False
>>> print os.path.isfile("/does/not/exist")
False
>>> print os.path.exists("/etc/password.txt")
True
>>> print os.path.exists("/etc")
True
>>> print os.path.exists("/does/not/exist")
False
    
893
2016-12-02 19: 33: 06Z
 
import os.path

if os.path.isfile(filepath):
    
553
2017-06-21 20: 33: 46Z

Utilice os.path.isfile() con os.access() :

 
import os
import os.path

PATH='./file.txt'

if os.path.isfile(PATH) and os.access(PATH, os.R_OK):
    print "File exists and is readable"
else:
    print "Either the file is missing or not readable"
    
271
2018-07-16 10: 21: 08Z
  1. con múltiples condiciones, algunas de las cuales son superfluas, es menos clara y explícita.
    2013-04-09 05: 45: 27Z
  2. También es redundante. Si el archivo no existe, os.access() devolverá falso.
    2018-03-13 00: 01: 19Z
  3. @ EJP En linux, los archivos pueden existir pero no son accesibles.
    2018-07-16 21: 30: 18Z
  4. ya que import os, no necesita volver a usar import os.path ya que ya es parte de os. Solo necesita importar os.path si solo va a usar funciones de os.path y no de os para importar una cosa más pequeña, pero como usa os.access y os.R_OK, la segunda importación no es necesaria.
    2018-08-24 13: 10: 26Z
 
import os
os.path.exists(path) # Returns whether the path (directory or file) exists or not
os.path.isfile(path) # Returns whether the file exists or not
    
254
2018-06-02 20: 52: 01Z

Aunque casi todas las formas posibles se han incluido en (al menos una de) las respuestas existentes (por ejemplo, se agregaron Python 3.4 ), trataré de agrupar todo.

Nota : cada pieza del código de la biblioteca estándar de Python que voy a publicar pertenece a la versión 3.5.3 .

Declaración de problema :

  1. Comprobar archivo ( argumentable : también carpeta (archivo "especial")?
  2. No uses tratico//>> /except / else / finalmente bloques

Posibles soluciones :

  1. [Python 3]: os.path. existe ( ruta ) (también verifique otros miembros de la familia de funciones como os.path.isfile, os.path.isdir, os.path.lexists para ver comportamientos ligeramente diferentes)

     
    os.path.exists(path)
    
      

    Devuelve True si ruta se refiere a una ruta existente o un descriptor de archivo abierto. Devuelve False por enlaces simbólicos rotos. En algunas plataformas, esta función puede devolver False si no se concede el permiso para ejecutar os .stat () en el archivo solicitado, incluso si la ruta existe físicamente.

    Todo bien, pero si sigue el árbol de importación:

    • os.path - posixpath.py ( ntpath.py )

      • genericpath.py , línea ~#20+

         
        def exists(path):
            """Test whether a path exists.  Returns False for broken symbolic links"""
            try:
                st = os.stat(path)
            except os.error:
                return False
            return True
        

    es solo un bloque try /except alrededor de [Python 3]: os. stat ( path, *, dir_fd = None, follow_symlinks = Verdadero ) . Por lo tanto, su código es try /except libre, pero más bajo en el marco de estudio hay (al menos) uno tal bloque. Esto también se aplica a otras funciones ( incluida os.path.isfile).

    1.1. [Python 3]: Ruta. is_file ()

    • Es una forma más sofisticada (y más de python ic) de manejar rutas, pero
    • Bajo el capó, hace exactamente lo mismo ( pathlib.py , línea ~ # 1330 ):

       
      def is_file(self):
          """
          Whether this path is a regular file (also True for symlinks pointing
          to regular files).
          """
          try:
              return S_ISREG(self.stat().st_mode)
          except OSError as e:
              if e.errno not in (ENOENT, ENOTDIR):
                  raise
              # Path doesn't exist or is a broken symlink
              # (see https://bitbucket.org/pitrou/pathlib/issue/12/)
              return False
      
  2. [Python 3]: con gestores de contexto de declaración . O bien:

    • Crea uno:

       
      class Swallow:  # Dummy example
          swallowed_exceptions = (FileNotFoundError,)
      
          def __enter__(self):
              print("Entering...")
      
          def __exit__(self, exc_type, exc_value, exc_traceback):
              print("Exiting:", exc_type, exc_value, exc_traceback)
              return exc_type in Swallow.swallowed_exceptions  # only swallow FileNotFoundError (not e.g. TypeError - if the user passes a wrong argument like None or float or ...)
      
      • Y su uso: replicaré el comportamiento del os.path.isfile (tenga en cuenta que esto es solo para fines de demostración, no intente escribir dicho código para producción ):  

        import os
        import stat
        
        
        def isfile_seaman(path):  # Dummy func
            result = False
            with Swallow():
                result = stat.S_ISREG(os.stat(path).st_mode)
            return result
        
    • Use [Python 3]: contextlib. suprimir ( * excepciones ) , que fue específicamente diseñado para suprimir selectivamente las excepciones


    Pero, parecen estar envueltos en try /except / else /finally bloquea, como [Python 3]: el con declaración dice:

      

    Esto permite try común except ... finalmente los patrones de uso se encapsularán para una reutilización conveniente.

  3. Funciones transversales del sistema de archivos (y busque en los resultados elementos coincidentes)


    Dado que estas iteraciones sobre carpetas, (en la mayoría de los casos) son ineficientes para nuestro problema (hay excepciones, como glob bing sin comodines - como señala @ShadowRanger), así que no voy a insistir en ellos. Sin mencionar que, en algunos casos, puede ser necesario el procesamiento del nombre de archivo.

  4. [Python 3]: os. access ( ruta, modo, *, dir_fd = Ninguno, Effective_ids = False, follow_symlinks = True ) cuyo comportamiento es cercano a os.path.exists (en realidad es más ancho, principalmente debido a los 2 nd argumento)

    • Los permisos de usuario podrían restringir la "visibilidad" del archivo como indica el documento:
        

      ... prueba si el usuario que invoca tiene el acceso especificado a ruta . mode debe ser F_OK para probar la existencia del camino ...

    os.access("/tmp", os.F_OK)

    Como también trabajo en C , también uso este método porque bajo el capó, se llama API nativa s (de nuevo, a través de "${PYTHON_SRC_DIR} /Modules/posixmodule.c" ), pero también abre una puerta para posibles errores de usuario , y no es tan Python ic como otras variantes. Así que, como bien señaló @AaronHall, no lo use a menos que sepa lo que está haciendo:

    Nota : también es posible invocar API s mediante [Python 3]: ctypes - Una biblioteca de funciones extrañas para Python , pero en la mayoría de los casos es más complicada.

    (Win específico): Desde vcruntime * ( msvcr * ) .dll exporta un [ MS.Docs]: _access, _waccess también funciona la familia, aquí hay un ejemplo:

     
    Python 3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 16:02:32) [MSC v.1900 64 bit (AMD64)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import os, ctypes
    >>> ctypes.CDLL("msvcrt")._waccess(u"C:\\Windows\\System32\\cmd.exe", os.F_OK)
    0
    >>> ctypes.CDLL("msvcrt")._waccess(u"C:\\Windows\\System32\\cmd.exe.notexist", os.F_OK)
    -1
    

    Notas :

    • Aunque no es una buena práctica, estoy usando os.F_OK en la llamada, pero eso es solo por claridad (su valor es 0 )
    • Estoy usando _waccess para que el mismo código funcione en Python3 y Python2 (a pesar de unicode diferencias relacionadas entre ellos)
    • Aunque esto se dirige a un área muy específica, no se mencionó en ninguna de las respuestas anteriores


    La contraparte de Lnx ( Ubtu (16 x64) ):

     
    Python 3.5.2 (default, Nov 17 2016, 17:05:23)
    [GCC 5.4.0 20160609] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import os, ctypes
    >>> ctypes.CDLL("/lib/x86_64-linux-gnu/libc.so.6").access(b"/tmp", os.F_OK)
    0
    >>> ctypes.CDLL("/lib/x86_64-linux-gnu/libc.so.6").access(b"/tmp.notexist", os.F_OK)
    -1
    

    Notas :

    • En lugar de

      codificar la ruta de libc ( "/lib/x86_64-linux-gnu/libc.so.6" ) que puede (y muy probablemente, lo hará) varía según los sistemas, Ninguna (o la cadena vacía) se puede pasar al CDLL constructor ( ctypes.CDLL(None).access(b"/tmp", os.F_OK) ). Según [man7]: DLOPEN (3) :

        

      Si filename es NULL, entonces el identificador devuelto es para el principal   programa. Cuando se le da a dlsym (), este identificador provoca una búsqueda de un   símbolo en el programa principal, seguido de todos los objetos compartidos cargados en   inicio del programa, y ​​luego todos los objetos compartidos cargados por dlopen () con   la bandera RTLD_GLOBAL .

      • El programa principal (actual) ( python ) está vinculado contra libc , por lo que sus símbolos (incluido access ) se cargarán
      • Esto debe manejarse con cuidado, ya que las funcionescomo main , Py_Main y (todos los demás) están disponibles; llamarlos podría tener efectos desastrosos (en el programa actual)
      • Esto no se aplica también a Win (pero eso no es tan importante, ya que msvcrt.dll se encuentra en "% SystemRoot% \System32 " que está en % PATH% de forma predeterminada). Quería ir más allá y replicar este comportamiento en Win (y enviar un parche), pero resulta que, [MS.Docs]: función GetProcAddress solo" ve " exportados símbolos, así que a menos que haya alguien declara que las funciones en el ejecutable principal son __declspec(dllexport) (¿por qué en la Tierra la persona regular haría eso?), el programa principal es cargable pero bastante inutilizable
  5. Instale algún módulo de terceros con capacidades de sistema de archivos

    Lo más probable es que dependa de una de las formas anteriores (tal vez con personalizaciones leves).
    Un ejemplo sería (de nuevo, Win específico) [GitHub]: mhammond /pywin32 - Python para Windows (pywin32) Extensiones , que es un envoltorio de Python sobre WINAPI s.

    Pero, como esto es más como una solución, me detengo aquí.

  6. Otra solución (lame) ( gainarie ) es (como me gusta llamarlo), el enfoque sysadmin : use Python como contenedor para ejecutar comandos de shell

    • Win :

       
      (py35x64_test) e:\Work\Dev\StackOverflow\q000082831>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" -c "import os; print(os.system('dir /b \"C:\\Windows\\System32\\cmd.exe\" > nul 2>&1'))"
      0
      
      (py35x64_test) e:\Work\Dev\StackOverflow\q000082831>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" -c "import os; print(os.system('dir /b \"C:\\Windows\\System32\\cmd.exe.notexist\" > nul 2>&1'))"
      1
      
    • Nix ( Lnx ( Ubtu )):

       
      [cfati@cfati-ubtu16x64-0:~]> python3 -c "import os; print(os.system('ls \"/tmp\" > /dev/null 2>&1'))"
      0
      [cfati@cfati-ubtu16x64-0:~]> python3 -c "import os; print(os.system('ls \"/tmp.notexist\" > /dev/null 2>&1'))"
      512
      

Línea inferior :

  • No use try /except / else bloques em> / finalmente , ya que pueden evitar que te encuentres con una serie de problemas desagradables. Un contra-ejemplo en el que puedo pensar es en el rendimiento: tales bloques son costosos, así que trate de no colocarlos en el código que se supone que debe ejecutarse cientos de miles de veces por segundo (pero dado que (en la mayoría de los casos) implica acceso al disco, no será el caso).

Nota (s) final (es) :

  • Intentaré mantenerlo actualizado, cualquier sugerencia es bienvenida, incorporaré cualquier cosa útil que surja en la respuesta
216
2019-02-08 09: 36: 33Z
  1. ¿Puede explicar esta declaración? "Aunque no es una buena práctica, estoy usando os.F_OK en la llamada, pero eso es solo por claridad (su valor es 0)"
    2017-11-19 01: 46: 40Z
  2. @ sk8asd123: Es un poco difícil hacerlo en un comentario: en general, es mejor usar constantes con funciones con las que se unen. Esto se aplica cuando se trabaja con varios módulos que definen la misma constante, ya que algunos pueden no estar actualizados y es mejor que las funciones y constantes estén sincronizadas. Al trabajar con ctypes (llamando directamente a las funciones) debería haber definido la constante (de MSDN ), o no utilizar una constante. Es solo una guía que uso, en el 99.9% probablemente no haga ninguna diferencia (funcionalmente).
    2017-11-19 23: 54: 34Z
  3. @ CristiFati: A partir de 3.6, glob.iglob (y glob.glob también) se basan en os.scandir , por lo que es perezoso ahora; para obtener el primer golpe en un directorio de archivos 10M, solo escanea hasta alcanzar el primer golpe. E incluso antes de la 3.6, si usa los métodos glob sin comodines, la función es inteligente: sabe que solo puede tener un hit, por lo que simplifica el uso de globos a solo os.path.isdir o os.path.lexists (dependiendo de si la ruta termina en /).
    2017-11-29 18: 29: 02Z
  4. La segunda parte de mi comentario (el uso de globos sin comodines en realidad no itera la carpeta y nunca lo ha hecho) significa que es una solución perfectamente eficiente para el problema (más lento que llamar directamente al os.path.isdir o al os.path.lexist, ya que es un grupo de llamadas a funciones de nivel Python y operaciones de cadenas antes de decidir que la ruta eficiente es viable, pero no hay una llamada adicional al sistema ni trabajo de E /S, lo que es un orden de magnitud más lento).
    2017-11-29 18: 38: 49Z

Esta es la forma más sencilla de verificar si existe un archivo. Solo porque el archivo existía cuando lo verificaste no garantiza que estará allí cuando necesites abrirlo.

 
import os
fname = "foo.txt"
if os.path.isfile(fname):
    print("file does exist at this time")
else:
    print("no such file exists at this time")
    
146
2018-01-14 04: 07: 53Z
  1. Mientras tenga la intención de acceder al archivo, la condición de carrera existe , independientemente de cómo se construya su programa. Su programa no puede garantizar que otro proceso en la computadora no haya modificado el archivo. Es lo que Eric Lippert denomina excepción exógena . No puede evitarlo comprobando de antemano la existencia del archivo.
    2014-11-23 18: 37: 59Z
  2. @ IsaacSupeene La mejor práctica es hacer que la ventana de (archivo) sea lo más pequeña posible, seguida de un adecuado manejo de excepciones
    2018-07-28 02: 52: 48Z

Python 3.4+ tiene un módulo de ruta orientada a objetos: pathlib . Usando este nuevo módulo, puedes verificar si un archivo existe así:

 
import pathlib
p = pathlib.Path('path/to/file')
if p.is_file():  # or p.is_dir() to see if it is a directory
    # do stuff

Puede (y normalmente debería) usar un bloque try/except al abrir archivos:

 
try:
    with p.open() as f:
        # do awesome stuff
except OSError:
    print('Well darn.')

El módulo pathlib tiene un montón de cosas geniales en él: prácticas convenciones, verificación del propietario del archivo, una conexión más fácil, etc. Vale la pena echarle un vistazo. Si estás en una versión anterior de Python (versión 2.6 o posterior), puedes instalar pathlib con pip:

 
# installs pathlib2 on older Python versions
# the original third-party module, pathlib, is no longer maintained.
pip install pathlib2

Luego impórtalo de la siguiente manera:

 
# Older Python versions
import pathlib2 as pathlib
    
133
2017-12-04 14: 45: 12Z

Prefiero la declaración de prueba. Se considera mejor estilo y evita las condiciones de carrera.

No tomes mi palabra por ello. Hay mucho apoyo para esta teoría. Aquí hay una pareja:

117
2014-04-28 01: 01: 59Z
  1. Agregue mejores fuentes para respaldar su declaración.
    2015-09-10 09: 09: 37Z
  2. El enlace de Condiciones de carrera evitadas (compatibilidad con Apple Dev) no admite tu respuesta. Solo se refiere al uso de archivos temporales que contienen información confidencial sobre sistemas operativos mal diseñados que no protegen adecuadamente los archivos /directorios temporales a través de permisos restringidos. El uso de try...except no ayuda a resolver ese problema de todos modos.
    2015-09-28 15: 38: 00Z
  3. @ chrisz No creo que sea solo de enlace, en realidad tiene otra información que no es el enlace.
    2018-02-19 04: 30: 09Z
  4. El problema con este método, es que si tiene una pieza importante de código que depende del archivo que no existe, al colocarlo en la cláusula except:, será una excepción.Si se encuentra en esta parte de su código, aparecerá un mensaje confuso (segundo error surgido durante el procesamiento del primero).
    2019-05-24 10: 43: 34Z
  

¿Cómo compruebo si existe un archivo, usando Python, sin usar una declaración de prueba?

Ahora disponible desde Python 3.4, importe y cree una instancia de un objeto Path con el nombre del archivo, y verifique el método is_file (tenga en cuenta que esto devuelve Verdadero para los enlaces simbólicos que también apuntan a archivos normales):

 
>>> from pathlib import Path
>>> Path('/').is_file()
False
>>> Path('/initrd.img').is_file()
True
>>> Path('/doesnotexist').is_file()
False

Si estás en Python 2, puedes realizar una copia de seguridad del módulo pathlib desde pypi, pathlib2 , o de lo contrario marque isfile desde el módulo os.path:

 
>>> import os
>>> os.path.isfile('/')
False
>>> os.path.isfile('/initrd.img')
True
>>> os.path.isfile('/doesnotexist')
False

Ahora, lo anterior es probablemente la mejor respuesta directa pragmática aquí, pero existe la posibilidad de una condición de carrera (dependiendo de lo que se está tratando de lograr), y el hecho de que la implementación subyacente utiliza un try, pero Python usa try En todas partes en su implementación.

Como Python usa try en todas partes, realmente no hay razón para evitar una implementación que lo use.

Pero el resto de esta respuesta intenta considerar estas advertencias.

Respuesta más larga, mucho más pedante

Disponible desde Python 3.4, usa el nuevo objeto Path en pathlib. Tenga en cuenta que .exists no está del todo bien, porque los directorios no son archivos (excepto en el sentido de Unix que todo es un archivo).

 
>>> from pathlib import Path
>>> root = Path('/')
>>> root.exists()
True

Entonces necesitamos usar is_file:

 
>>> root.is_file()
False

Aquí está la ayuda en is_file:

 
is_file(self)
    Whether this path is a regular file (also True for symlinks pointing
    to regular files).

Entonces obtengamos un archivo que sabemos que es un archivo:

 
>>> import tempfile
>>> file = tempfile.NamedTemporaryFile()
>>> filepathobj = Path(file.name)
>>> filepathobj.is_file()
True
>>> filepathobj.exists()
True

De forma predeterminada, NamedTemporaryFile elimina el archivo cuando está cerrado (y se cerrará automáticamente cuando no haya más referencias a él).

 
>>> del file
>>> filepathobj.exists()
False
>>> filepathobj.is_file()
False

Si profundiza en la implementación , sin embargo , verás que is_file usa try:

 
def is_file(self):
    """
    Whether this path is a regular file (also True for symlinks pointing
    to regular files).
    """
    try:
        return S_ISREG(self.stat().st_mode)
    except OSError as e:
        if e.errno not in (ENOENT, ENOTDIR):
            raise
        # Path doesn't exist or is a broken symlink
        # (see https://bitbucket.org/pitrou/pathlib/issue/12/)
        return False

Condiciones de carrera: por qué nos gusta probar

Nos gusta try porque evita las condiciones de carrera. Con try, simplemente intenta leer su archivo, esperando que esté allí, y si no, puede detectar la excepción y realizar cualquier comportamiento de recuperación que tenga sentido.

Si desea comprobar que existe un archivo antes de intentar leerlo, y podría estar eliminándolo y luego podría estar usando varios subprocesos o procesos, u otro programa conoce ese archivo y podría eliminarlo, se arriesga la posibilidad de una condición de carrera si verifica que existe, porque entonces está compitiendo para abrirla antes de que cambie su condición (su existencia).

Las condiciones de carrera son muy difíciles de depurar porque hay una ventana muy pequeña en la que pueden hacer que tu programa falle.

Pero si esta es su motivación, puede obtener el valor de una declaración try utilizando el administrador de contexto suppress.

Evitar las condiciones de carrera sin una declaración de prueba: suppress

Python 3.4 nos brinda el suppress administrador de contexto (anteriormente el ignore administrador de contexto), que hace exactamente lo mismo semánticamente en menos líneas, mientras que también (al menos de manera superficial ) cumpliendo con el pedido original para evitar una declaración try:

 
from contextlib import suppress
from pathlib import Path

Uso:

 
>>> with suppress(OSError), Path('doesnotexist').open() as f:
...     for line in f:
...         print(line)
... 
>>>
>>> with suppress(OSError):
...     Path('doesnotexist').unlink()
... 
>>> 

Para los Pythons anteriores, podrías lanzar tu propio suppress, pero sin un try será más detallado que con. Creo que en realidad esta es la única respuesta que no usa try en ningún nivel en Python que se puede aplicar antes de Python 3.4 porque usa un administrador de contexto en su lugar:

 
class suppress(object):
    def __init__(self, *exceptions):
        self.exceptions = exceptions
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type is not None:
            return issubclass(exc_type, self.exceptions)

Quizás más fácil con un intento:

 
from contextlib import contextmanager

@contextmanager
def suppress(*exceptions):
    try:
        yield
    except exceptions:
        pass

Otras opciones que no cumplen con la solicitud de "sin intentarlo":

es un archivo

 
import os
os.path.isfile(path)

de la docs :

  

os.path.isfile(path)

     

Devuelve True si la ruta es un archivo regular existente. Esto sigue simbólico   enlaces, por lo que tanto islink() como isfile() pueden ser verdaderos para la misma ruta.

Pero si examinas la fuente de este función, verás que realmente usa una declaración de prueba:

 
# This follows symbolic links, so both islink() and isdir() can be true
# for the same path on systems that support symlinks
def isfile(path):
    """Test whether a path is a regular file"""
    try:
        st = os.stat(path)
    except os.error:
        return False
    return stat.S_ISREG(st.st_mode)
 
>>> OSError is os.error
True

Todo lo que está haciendo es usar la ruta dada para ver si puede obtener estadísticas, capturar OSError y luego verificar si es un archivo si no produjo la excepción.

Si pretende hacer algo con el archivo, le sugeriría que direcInténtelo con un intento, excepto para evitar una condición de carrera:

 
try:
    with open(path) as f:
        f.read()
except OSError:
    pass

os.access

Disponible para Unix y Windows es os.access, pero para usarlo debe pasar marcas, y no distingue entre archivos y directorios. Esto se usa más para probar si el usuario que invoca realmente tiene acceso en un entorno de privilegios elevados:

 
import os
os.access(path, os.F_OK)

También tiene los mismos problemas de condición de carrera que el isfile. De los docs :

  

Nota:   Usar access () para verificar si un usuario está autorizado para, por ejemplo, abrir un archivo   antes de hacerlo, usar open () crea un agujero de seguridad, porque   el usuario podría explotar el corto intervalo de tiempo entre la verificación y   Abriendo el archivo para manipularlo. Es preferible utilizar EAFP.   tecnicas Por ejemplo:

 
if os.access("myfile", os.R_OK):
    with open("myfile") as fp:
        return fp.read()
return "some default data"
     

está mejor escrito como:

 
try:
    fp = open("myfile")
except IOError as e:
    if e.errno == errno.EACCES:
        return "some default data"
    # Not a permission error.
    raise
else:
    with fp:
        return fp.read()

Evite el uso de os.access. Es una función de bajo nivel que tiene más oportunidades de error de usuario que los objetos y funciones de nivel superior descritos anteriormente.

Críticas a otra respuesta:

Otra respuesta dice esto sobre el os.access:

  

Personalmente, prefiero este porque bajo el capó, llama API nativas (a través de "${PYTHON_SRC_DIR} /Modules/posixmodule.c"), pero también abre una puerta para posibles errores de usuario, y no es tan Pythonic. como otras variantes:

Esta respuesta dice que prefiere un método no pitónico, propenso a errores, sin justificación. Parece animar a los usuarios a usar API de bajo nivel sin entenderlos.

También crea un administrador de contexto que, al devolver incondicionalmente True, permite que todas las Excepciones (¡incluidas KeyboardInterrupt y SystemExit!) pasen en silencio, lo que es una buena manera de ocultar errores.

Esto parece animar a los usuarios a adoptar prácticas deficientes.

    
110
2018-02-25 20: 45: 39Z
 
import os
#Your path here e.g. "C:\Program Files\text.txt"
#For access purposes: "C:\\Program Files\\text.txt"
if os.path.exists("C:\..."):   
    print "File found!"
else:
    print "File not found!"

Importar os facilita navegar y realizar acciones estándar con su sistema operativo.

Para referencia, vea también ¿Cómo verificar si existe un archivo usando Python?

Si necesita operaciones de alto nivel, use shutil.

    
82
2017-05-16 16: 36: 46Z
  1. Esta respuesta es incorrecta. os.path.exists devuelve true para cosas que no son archivos, como directorios. Esto da falsos positivos. Vea las otras respuestas que recomiendan os.path.isfile.
    2015-08-01 13: 56: 22Z

Comprobación de archivos y carpetas con os.path.isfile(), os.path.isdir() y os.path.exists()

Suponiendo que la "ruta" es una ruta válida, esta tabla muestra lo que devuelve cada función para los archivos y carpetas:

enter descripción de la imagen aquí

También puede probar si un archivo es un tipo determinado de archivo utilizando os.path.splitext() para obtener la extensión (si aún no lo sabe)

 
>>> import os
>>> path = "path to a word document"
>>> os.path.isfile(path)
True
>>> os.path.splitext(path)[1] == ".docx" # test if the extension is .docx
True
    
76
2016-10-08 12: 43: 02Z

En 2016, la mejor manera es usar os.path.isfile:

 
>>> os.path.isfile('/path/to/some/file.txt')

O en Python 3 puedes usar pathlib:

 
import pathlib
path = pathlib.Path('/path/to/some/file.txt')
if path.is_file():
    ...
    
67
2017-05-27 01: 00: 22Z
  1. ¿Puedo preguntar: cuál es la ventaja de usar el módulo 'pathlib' en lugar del módulo 'os' en python3 para esta comprobación?
    2016-02-25 08: 55: 33Z
  2. pathlib es la solución OOP de python para las rutas. Puedes hacer mucho más con él. Si solo necesita verificar la existencia, la ventaja no es tan grande.
    2016-02-25 10: 44: 49Z

No parece que haya una diferencia funcional significativa entre try /except y isfile(), por lo que deberías usar cuál tiene sentido.

Si desea leer un archivo, si existe, haga

 
try:
    f = open(filepath)
except IOError:
    print 'Oh dear.'

Pero si solo desea cambiar el nombre de un archivo si existe y, por lo tanto, no necesita abrirlo, hágalo

 
if os.path.isfile(filepath):
    os.rename(filepath, filepath + '.old')

Si desea escribir en un archivo, si no existe, haga

 
# python 2
if not os.path.isfile(filepath):
    f = open(filepath, 'w')

# python 3, x opens for exclusive creation, failing if the file already exists
try:
    f = open(filepath, 'wx')
except IOError:
    print 'file already exists'

Si necesita el bloqueo de archivos, eso es un asunto diferente.

    
62
2015-08-25 03: 12: 24Z
  1. Esta respuesta es incorrecta. os.path.exists devuelve true para cosas que no son archivos, como directorios. Esto da falsos positivos. Vea las otras respuestas que recomiendan os.path.isfile.
    2015-08-01 13: 54: 35Z
  2. En su tercer ejemplo, creo un enlace llamado filepath con el tiempo correcto, y BAM , sobrescribe el archivo de destino. Debes hacer open(filepath, 'wx') en un bloque try...except para evitar el problema.
    2015-08-24 14: 05: 09Z
  3. En su segundo ejemplo, al menos en Windows, obtendrá un OSError si ya existe filepath + '.old': "En Windows, si ya existe dst, OSError se generará incluso si es un archivo; puede que no haya forma de implementar un cambio de nombre atómico cuando dst nombra un archivo existente ".
    2016-05-24 14: 14: 04Z
  4. @ TomMyddeltyn: A partir de Python 3.3, os.replace puede realizar un reemplazo silencioso del archivo de destino (es idéntico al comportamiento de Linux del os.rename) (solo se produce un error si el nombre del destino existe y es un directorio). Así que estás atascado en 2.x, pero los usuarios de Py3 han tenido una buena opción desde hace varios años.
    2017-11-29 18: 14: 56Z
  5. En el ejemplo rename: aún debe hacerse con try/except. os.rename (o os.replace en Python moderno) es atómico; Haciéndolo chequear luego renombrar introduce una carrera innecesaria y llamadas adicionales al sistema. Solo haz try: os.replace(filepath, filepath + '.old') except OSError: pass
    2017-11-29 18: 17: 31Z

Puedes probar esto (más seguro):

 
try:
    # http://effbot.org/zone/python-with-statement.htm
    # 'with' is safer to open a file
    with open('whatever.txt') as fh:
        # Do something with 'fh'
except IOError as e:
    print("({})".format(e))

La salida sería:

  

([Errno 2] No existe tal archivo o directorio:   'lo que sea.txt')

Luego, dependiendo del resultado, tu programa puede seguir ejecutándose desde allí o puedes programar para detenerlo si lo deseas.

    
53
2017-05-27 00: 43: 51Z
  1. La pregunta original solicitó una solución que no usa try
    2014-04-23 13: 10: 01Z
  2. Esta respuesta pierde el punto del OP. Comprobar que un archivo existe no es lo mismo que comprobar si puede abrirlo. Habrá casos en que exista un archivo, pero por diversos motivos, no podrá abrirlo.
    2016-02-17 18: 52: 12Z

Aunque siempre recomiendo usar las declaraciones try y except, aquí hay algunas posibilidades para ti (mi favorito personal es usar os.access):

  1. Intenta abrir el archivo:

    Al abrir el archivo siempre se verificará la existencia del archivo. Puedes hacer una función así:

     
    def File_Existence(filepath):
        f = open(filepath)
        return True
    

    Si es falso, detendrá la ejecución con un IOError no administrado o OSError en versiones posteriores de Python. Para atrapar la excepción, Tienes que usar una cláusula de prueba excepto. Claro que siempre puedes use un try excepto una declaración como tal (gracias a hsandt por hacerme pensar):

     
    def File_Existence(filepath):
        try:
            f = open(filepath)
        except IOError, OSError: # Note OSError is for later versions of Python
            return False
    
        return True
    
  2. Utilice os.path.exists(path):

    Esto comprobará la existencia de lo que especifique. Sin embargo, comprueba los archivos y , así que ten cuidado con la forma en que lo usas.

     
    import os.path
    >>> os.path.exists("this/is/a/directory")
    True
    >>> os.path.exists("this/is/a/file.txt")
    True
    >>> os.path.exists("not/a/directory")
    False
    
  3. Utilice os.access(path, mode):

    Esto verificará si tienes acceso al archivo. Se comprobará los permisos. Sobre la base de la documentación de os.py, al escribir os.F_OK, comprobará la existencia de la ruta. Sin embargo, usar esto creará un agujero de seguridad, ya que alguien puede atacar su archivo usando el tiempo entre la verificación de los permisos y la apertura del archivo. En su lugar, debería ir directamente a abrir el archivo en lugar de verificar sus permisos. ( EAFP vs LBYP ). Si no vas a abrir el archivo más tarde y solo verificas su existencia, puedes usarlo.

    De todos modos, aquí:

     
    >>> import os
    >>> os.access("/is/a/file.txt", os.F_OK)
    True
    

También debo mencionar que hay dos formas en las que no podrá verificar la existencia de un archivo. O bien el problema será permission denied o no such file or directory. Si atrapa un IOError, configure el IOError as e (como mi primera opción) y luego escriba print(e.args) para que pueda determinar su problema. ¡Espero que ayude! :)

    
48
2017-05-27 00: 52: 18Z

Fecha: 2017-12-04

Todas las soluciones posibles se han incluido en otras respuestas.

Una forma intuitiva y discutible de verificar si existe un archivo es la siguiente:

 
import os
os.path.isfile('~/file.md')  # Returns True if exists, else False
# additionaly check a dir
os.path.isdir('~/folder')  # Returns True if the folder exists, else False
# check either a dir or a file
os.path.exists('~/file')

Hice una hoja de trucos exhaustiva para su referencia:

 
#os.path methods in exhaustive cheatsheet
{'definition': ['dirname',
               'basename',
               'abspath',
               'relpath',
               'commonpath',
               'normpath',
               'realpath'],
'operation': ['split', 'splitdrive', 'splitext',
               'join', 'normcase'],
'compare': ['samefile', 'sameopenfile', 'samestat'],
'condition': ['isdir',
              'isfile',
              'exists',
              'lexists'
              'islink',
              'isabs',
              'ismount',],
 'expand': ['expanduser',
            'expandvars'],
 'stat': ['getatime', 'getctime', 'getmtime',
          'getsize']}
    
42
2018-12-23 10: 46: 13Z

Además, os.access():

 
if os.access("myfile", os.R_OK):
    with open("myfile") as fp:
        return fp.read()

Siendo R_OK, W_OK y X_OK las marcas para probar los permisos ( doc ).

    
33
2016-05-04 15: 24: 02Z

Si el archivo es para abrir, puede utilizar una de las siguientes técnicas:

 
>>> with open('somefile', 'xt') as f: #Using the x-flag, Python3.3 and above
...     f.write('Hello\n')

>>> if not os.path.exists('somefile'): 
...     with open('somefile', 'wt') as f:
...         f.write("Hello\n")
... else:
...     print('File already exists!')

ACTUALIZAR

Para evitar confusiones y según las respuestas que recibí, la respuesta actual encuentra un archivo o un directorio con el nombre dado.

    
30
2018-07-22 19: 12: 53Z
  1. Esta respuesta es incorrecta. os.path.exists devuelve true para cosas que no son archivos, como directorios. Esto da falsos positivos. Vea las otras respuestas que recomiendan os.path.isfile.
    2015-08-01 13: 55: 01Z
  2. también tiene el problema del falso positivo.
    2018-05-19 21: 33: 55Z
  3. docs.python.org/3/library/os.path.html#os.path.exists A la declaración anterior de chris > > os.path.exists (ruta) > Devuelva True si la ruta se refiere a una ruta existente o un descriptor de archivo abierto. Devuelve False para enlaces simbólicos rotos. En algunas plataformas, esta función puede devolver False si no se concede el permiso para ejecutar os.stat () en el archivo solicitado, incluso si la ruta existe físicamente. Cambiado en la versión 3.3: la ruta ahora puede ser un entero: True se devuelve si es un descriptor de archivo abierto, False de lo contrario. Cambiado en la versión 3.6: Acepta un objeto similar a una ruta.
    2018-08-31 23: 24: 22Z
 
if os.path.isfile(path_to_file):
    try: 
        open(path_to_file)
            pass
    except IOError as e:
        print "Unable to open file"
  

Elevando excepciones se considera un aceptable, y Pythonic,   enfoque para el control de flujo en su programa. Considere el manejo de faltantes   archivos con IOErrors. En esta situación, una excepción IOError será   se genera si el archivo existe pero el usuario no tiene permisos de lectura.

SRC: http://www.pfinn.net/python-check-if-file -exists.html

    
20
2015-07-18 17: 41: 08Z
  1. El OP preguntó cómo verificar si existe un archivo. Es posible que exista un archivo pero que usted no pueda abrirlo. Por lo tanto, al abrir un archivo como proxy para verificar si el archivo existe no es correcto: tendrá falsos negativos.
    2016-02-17 18: 58: 54Z

Si ya importó NumPy para otros fines, no es necesario importar otras bibliotecas como pathlib, os, paths, etc.

 
import numpy as np
np.DataSource().exists("path/to/your/file")

Esto devolverá verdadero o falso según su existencia.

    
18
2018-09-01 01: 00: 51Z

Puedes escribir la sugerencia de Brian sin el try:.

 
from contextlib import suppress

with suppress(IOError), open('filename'):
    process()

suppress es parte de Python 3.4. En versiones anteriores puedes escribir rápidamente tu propia supresión:

 
from contextlib import contextmanager

@contextmanager
def suppress(*exceptions):
    try:
        yield
    except exceptions:
        pass
    
17
2017-05-27 00: 48: 31Z

El archivo o directorio de verificación existe

Puedes seguir estas tres formas:

  

Nota 1: el os.path.isfile utilizado solo para archivos

 
import os.path
os.path.isfile(filename) # True if file exists
os.path.isfile(dirname) # False if directory exists
  

Nota2: el os.path.exists utilizado tanto para archivos como para directorios

 
import os.path
os.path.exists(filename) # True if file exists
os.path.exists(dirname) #True if directory exists
  

El método pathlib.Path (incluido en Python 3+, instalable con pip para Python 2)

 
from pathlib import Path
Path(filename).exists()
    
16
2018-03-04 06: 24: 37Z

Agregando una ligera variación más que no se refleja exactamente en las otras respuestas.

Esto manejará el caso del file_path siendo None o una cadena vacía.

 
def file_exists(file_path):
    if not file_path:
        return False
    elif not os.path.isfile(file_path):
        return False
    else:
        return True

Agregando una variante basada en la sugerencia de Shahbaz

 
def file_exists(file_path):
    if not file_path:
        return False
    else:
        return os.path.isfile(file_path)

Añadiendo una variante basada en la sugerencia de Peter Wood

 
def file_exists(file_path):
    return file_path and os.path.isfile(file_path):
    
15
2017-04-07 16: 10: 59Z
  1. if (x) return true; else return false; es en realidad solo return x. Tus últimas cuatro líneas pueden convertirse en return os.path.isfile(file_path). Mientras estamos en ello, toda la función se puede simplificar como return file_path and os.path.isfile(file_path).
    2017-01-04 22: 50: 16Z
  2. Tienes que tener cuidado con return x en el caso de if (x). Python considerará una cadena vacía. Falso, en cuyo caso devolveríamos una cadena vacía en lugar de un bool. El propósito de esta función es devolver siempre bool.
    2017-01-05 17: 08: 43Z
  3. Verdadero. Sin embargo, en este caso, x es os.path.isfile(..), por lo que ya es bool.
    2017-01-05 17: 10: 24Z
  4. os.path.isfile(None) genera una excepción, por lo que agregué el cheque if. Probablemente podría simplemente envolverlo en un try /excepto en su lugar, pero sentí que era más explícito de esta manera.
    2017-01-05 17: 13: 10Z
  5. return file_path and os.path.isfile(file_path)
    2017-04-06 10: 35: 01Z

Soy el autor de un paquete que ha existido durante unos 10 años y tiene una función que aborda esta pregunta directamente. Básicamente, si está en un sistema que no es Windows, usa Popen para acceder a find. Sin embargo, si está en Windows, se replica find con un sistema de archivos eficiente.

El código en sí no usa un bloque try ... excepto para determinar el sistema operativo y así dirigirlo al estilo "Unix" find o al manual find. Las pruebas de tiempo mostraron que el try fue más rápido en la determinación del sistema operativo, así que usé uno allí (pero en ninguna otra parte).

 
>>> import pox
>>> pox.find('*python*', type='file', root=pox.homedir(), recurse=False)
['/Users/mmckerns/.python']

Y el doc ...

 
>>> print pox.find.__doc__
find(patterns[,root,recurse,type]); Get path to a file or directory

    patterns: name or partial name string of items to search for
    root: path string of top-level directory to search
    recurse: if True, recurse down from root directory
    type: item filter; one of {None, file, dir, link, socket, block, char}
    verbose: if True, be a little verbose about the search

    On some OS, recursion can be specified by recursion depth (an integer).
    patterns can be specified with basic pattern matching. Additionally,
    multiple patterns can be specified by splitting patterns with a ';'
    For example:
        >>> find('pox*', root='..')
        ['/Users/foo/pox/pox', '/Users/foo/pox/scripts/pox_launcher.py']

        >>> find('*shutils*;*init*')
        ['/Users/foo/pox/pox/shutils.py', '/Users/foo/pox/pox/__init__.py']

>>>

La implementación, si te interesa mirar, está aquí: 15

2017-05-27 00: 59: 52Z

Aquí hay un comando de Python de 1 línea para el entorno de línea de comandos de Linux. Encuentro esto MUY BUENO ya que no soy un tipo Bash tan caliente.

 
python -c "import os.path; print os.path.isfile('/path_to/file.xxx')"

Espero que esto sea útil.

    
14
2015-08-29 16: 15: 29Z
  1. Comprobación de una línea en bash: [ -f "${file}" ] && echo "file found" || echo "file not found" (que es lo mismo que if [ ... ]; then ...; else ...; fi).
    2015-10-01 07: 48: 29Z

Puedes usar la biblioteca "OS" de Python:

 
>>> import os
>>> os.path.exists("C:\\Users\\####\\Desktop\\test.txt") 
True
>>> os.path.exists("C:\\Users\\####\\Desktop\\test.tx")
False
    
11
2017-05-27 00: 49: 25Z
  1. Esta respuesta es incorrecta. os.path.exists devuelve true para cosas que no son archivos, como directorios. Esto da falsos positivos. Vea las otras respuestas que recomiendan os.path.isfile.
    2015-08-01 13: 55: 13Z
  2. @ Chris Johnson, la función os.path.exists () verifica si existe una ruta en el sistema. PATH puede ser un directorio o un archivo. Funcionará bien en ambos casos. Por favor, intente con algún ejemplo
    2015-08-02 14: 51: 41Z
  3. Entonces, esta respuesta funciona. Genial. Iff la ruta no es la de un archivo. ¿De eso se trató la pregunta? No.
    2016-04-14 23: 33: 56Z
  4. Depende. Si el objetivo de determinar la existencia de un "archivo" es averiguar si la ruta ya existe (y, por lo tanto, no es una ruta donde se pueden almacenar nuevos datos sin eliminar otra información), entonces exists está bien. Si el objetivo es determinar si es seguro abrir un archivo presumiblemente existente, entonces la crítica está justificada y existe no es lo suficientemente precisa. Lamentablemente, el OP no especifica cuál es el objetivo deseado (y probablemente ya no lo hará).
    2017-09-05 11: 24: 42Z
  

¿Cómo compruebo si existe un archivo sin usar la declaración de prueba?

En 2016, esta es todavía la forma más fácil de verificar si existe un archivo y si es un archivo:

 
import os
os.path.isfile('./file.txt')    # Returns True if exists, else False

isfile es en realidad solo un método auxiliar que utiliza internamente os.stat y stat.S_ISREG(mode) debajo. Este os.stat es un método de nivel inferior que le proporcionará información detallada sobre archivos, directorios, sockets, buffers y más. Más información sobre os.stat aquí

Nota: Sin embargo, este enfoque no bloqueará el archivo de ninguna manera y, por lo tanto, su código puede ser vulnerable a " tiempo de verificación a tiempo de uso " ( TOCTTOU ) errores.

Por lo tanto, se considera que generar excepciones es un enfoque aceptable y Pythonic para el control de flujo en su programa. Y uno debería considerar manejar los archivos faltantes con IOErrors, en lugar de las declaraciones if ( solo un consejo ).

    
11
2017-05-27 00: 57: 43Z
 
import os.path

def isReadableFile(file_path, file_name):
    full_path = file_path + "/" + file_name
    try:
        if not os.path.exists(file_path):
            print "File path is invalid."
            return False
        elif not os.path.isfile(full_path):
            print "File does not exist."
            return False
        elif not os.access(full_path, os.R_OK):
            print "File cannot be read."
            return False
        else:
            print "File can be read."
            return True
    except IOError as ex:
        print "I/O error({0}): {1}".format(ex.errno, ex.strerror)
    except Error as ex:
        print "Error({0}): {1}".format(ex.errno, ex.strerror)
    return False
#------------------------------------------------------

path = "/usr/khaled/documents/puzzles"
fileName = "puzzle_1.txt"

isReadableFile(path, fileName)
    
9
2015-10-08 21: 22: 53Z
  1. eso es True y False, ¿verdad ..?
    2015-08-08 21: 27: 18Z
  2. @ j6m8 yes, isReadableFile(path,fileName) devolverá True si el archivo \program \thread
    puede acceder y leer el archivo
    2015-08-09 07: 46: 31Z
fuente colocada aquí