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

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 try alrededor del bash de 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 se intenta abrir.

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

Devuelva True si la ruta es un archivo regular existente. Esto sigue a los enlaces simbólicos, por lo que tanto islink () como isfile () pueden ser verdaderos 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, el módulo pathlib 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, haga:

 if my_file.is_dir(): # directory exists 

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

 if my_file.exists(): # path exists 

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

 try: my_abs_path = my_file.resolve(strict=True) except FileNotFoundError: # doesn't exist else: # exists 

Tienes la función os.path.exists :

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

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

 os.path.isfile(file_path) 

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

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

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

 import os.path if os.path.isfile(filepath): 

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" 

 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 

Aunque casi todas las formas posibles se han incluido en (al menos una de) las respuestas existentes (por ejemplo, se agregaron cosas específicas de Python 3.4 ), intentaré 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 del problema :

1. Comprobar archivo ( argumentable : también carpeta (archivo “especial”)? Existencia
2. No use los bloques try / except / else / finally

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) 

   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.

   Todo bien, pero si siguiendo 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 de [Python 3]: os. stat ( ruta, *, dir_fd = Ninguna, follow_symlinks = True ) . Por lo tanto, su código es try / except free, pero más abajo en el frameestack hay (al menos) uno de estos bloques. Esto también se aplica a otras funciones ( incluido os.path.isfile ).

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

   • Es una forma más elegante (y más de python ic) de manejar caminos, 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 los administradores de contexto de statement . Ya sea:

   • 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 eg TypeError - if the user passes a wrong argument like None or float or ...) 

     • Y su uso: replicaré el comportamiento os.path.isfile (tenga en cuenta que esto es solo para fines de demostración, no intente escribir dicho código para la 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 

   • Utilice [Python 3]: contextlib. suprimir ( * excepciones ) – que fue diseñado específicamente para suprimir selectivamente excepciones

   Pero, parecen ser envoltorios sobre bloques try / except / else / finally , como [Python 3]: los estados de with :

   Esto permite el bash común … excepto … finalmente, los patrones de uso se encapsulan para una reutilización conveniente.

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

   • [Python 3]: os. listdir ( ruta = ‘.’ ) (o [Python 3]: os. scandir ( ruta = ‘.’ ) en Python v 3.5 +, backport: [PyPI]: scandir )

     • Bajo el capó, ambos utilizan:

       • Nix : [man7]: OPENDIR (3) / [man7]: READDIR (3) / [man7]: CLOSEDIR (3)
       • Win : [MS.Docs]: función FindFirstFileW / [MS.Docs]: función FindNextFileW / [MS.Docs]: función FindClose

       a través de [GitHub]: python / cpython – (master) cpython / Modules / posixmodule.c

     El uso de scandir () en lugar de listdir () puede boost significativamente el rendimiento del código que también necesita información sobre el tipo de archivo o los atributos del archivo, ya que los objetos os.DirEntry exponen esta información si el sistema operativo la proporciona al escanear un directorio. Todos los métodos os.DirEntry pueden realizar una llamada al sistema, pero is_dir () y is_file () generalmente solo requieren una llamada al sistema para enlaces simbólicos; os.DirEntry.stat () siempre requiere una llamada al sistema en Unix, pero solo requiere una para los enlaces simbólicos en Windows.

   • [Python 3]: os. walk ( top, topdown = True, onerror = None, followlinks = False )
     • Utiliza os.listdir ( os.scandir cuando esté disponible)
   • [Python 3]: glob. iglob ( nombre de ruta, *, recursivo = Falso ) (o su predecesor: glob.glob )
     • No parece una función de desplazamiento per se (al menos en algunos casos), pero todavía usa os.listdir

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

4. [Python 3]: os. acceso ( ruta, modo, *, dir_fd = ninguno, Effective_ids = False, follow_symlinks = True ) cuyo comportamiento es cercano a os.path.exists (en realidad es más amplio, principalmente debido al segundo argumento)

   • los permisos de los usuarios pueden restringir la “visibilidad” del archivo, como indica el documento:
     

     … prueba si el usuario que invoca tiene el acceso especificado a la ruta . el modo debe ser F_OK para probar la existencia de ruta …

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

   Como también trabajo en C , también utilizo este método porque bajo el capó, llama API s nativas (de nuevo, a través de “$ {PYTHON_SRC_DIR} /Modules/posixmodule.c” ), pero también abre una puerta para un posible usuario. errores , 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:

   • Nix : [man7]: ACCESS (2) (!!! ¡¡¡preste atención a la nota sobre el agujero de seguridad que su uso podría introducir !!!)
   • Win : [MS.Docs]: función GetFileAttributesW

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

   ( Ganancia específica): Como vcruntime * ( msvcr * ) .dll exporta una familia de funciones [MS.Docs]: _access, _waccess , 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 las diferencias relacionadas con Unicode 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) ) también:

    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 su lugar, codifique la ruta de acceso de libc ( “/lib/x86_64-linux-gnu/libc.so.6” ) que puede (y lo más probable es que varíe) entre los sistemas, ninguno (o la cadena vacía) se puede pasar al constructor de CDLL ( ctypes.CDLL(None).access(b"/tmp", os.F_OK) ). Según [man7]: DLOPEN (3) :

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

     • El progtwig principal (actual) ( python ) está vinculado contra libc , por lo que sus símbolos (incluido el acceso ) se cargarán
     • Esto debe manejarse con cuidado, ya que funciones como main , Py_Main y (todas) están disponibles; Llamarlos podría tener efectos desastrosos (en el progtwig 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]: la función GetProcAddress solo “ve” los símbolos exportados , así que a menos que alguien declare las funciones en el ejecutable principal como __declspec(dllexport) (¿por qué en la Tierra la persona normal haría eso?), el progtwig principal es cargable pero bastante inutilizable

5. Instalar 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 (otra vez, específico de Win ) [GitHub]: mhammond / pywin32 – Extensiones Python para Windows (pywin32) , 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 de administrador de sistemas : usar Python como un contenedor para ejecutar comandos de shell

   • Ganar :

      (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

• Use los bloques try / except / else / finally , porque pueden evitar que se tope 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 final (es) :

• Trataré de mantenerlo actualizado, cualquier sugerencia es bienvenida, incorporaré cualquier cosa útil que surja en la respuesta.

Esta es la forma más sencilla de verificar si existe un archivo. El hecho de que el archivo haya existido cuando se verificó no garantiza que estará allí cuando necesite 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") 

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 de ruta 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 importarlo de la siguiente manera:

 # Older Python versions import pathlib2 as pathlib 

Prefiero la statement de prueba. Se considera mejor estilo y evita condiciones de carrera.

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

• Estilo: Sección “Manejo de condiciones inusuales” de http://allendowney.com/sd/notes/notes11.txt
• Evitar las condiciones de carrera

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

Ahora disponible desde Python 3.4, importe y cree una instancia de un objeto de Path con el nombre del archivo, y verifique el método is_file (tenga en cuenta que esto devuelve True 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á en Python 2, puede realizar una backport del módulo pathlib desde pypi, pathlib2 o, de lo contrario, verificar 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 intenta lograr), y el hecho de que la implementación subyacente usa un try , pero los usos de Python lo try en todas partes. implementación.

Debido a que los usos de Python try todas partes, realmente no hay razón para evitar una implementación que lo use.

Pero el rest de esta respuesta intenta considerar estas advertencias.

Respuesta más larga, mucho más pedante.

Disponible desde Python 3.4, use el nuevo objeto Path en pathlib . Tenga en cuenta que .exists no es del todo correcto, 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 

Así que 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). 

Así que vamos a obtener 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 

Sin embargo, si profundiza en la implementación , verá 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 condiciones de carrera. Con el 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 verificar que un archivo existe antes de intentar leerlo, y puede estar eliminándolo y luego podría estar usando múltiples procesos o subprocesos, u otro progtwig conoce ese archivo y podría eliminarlo, corre el riesgo 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 la carrera son muy difíciles de depurar porque hay una ventana muy pequeña en la que pueden hacer que su progtwig falle.

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

Evitar las condiciones de carrera sin una statement de prueba: suppress

Python 3.4 nos proporciona el administrador de contexto de suppress (anteriormente el administrador de contexto de ignore ), que hace exactamente lo mismo en forma semántica en menos líneas, al mismo tiempo que (al menos superficialmente) cumple con la solicitud original para evitar una statement de 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, puedes rodar tu propia 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 de Python que se pueda 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) 

Tal vez más fácil con un bash:

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

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

isfile

 import os os.path.isfile(path) 

de los documentos :

os.path.isfile(path)

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

Pero si examinas el origen de esta función, verás que realmente usa una statement 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 hace 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, sugeriría intentarlo directamente con un bash, 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 indicadores, y no distingue entre archivos y directorios. Esto se usa más para probar si el usuario que invoca real tiene acceso en un entorno de privilegios elevados:

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

También sufre los mismos problemas de condición de carrera que isfile . De los documentos :

Nota: el uso de access () para verificar si un usuario está autorizado para, por ejemplo, abrir un archivo antes de hacerlo, utilizando open () crea un agujero de seguridad, ya que el usuario puede aprovechar el corto intervalo de tiempo entre la verificación y la apertura del archivo para manipularlo. Es preferible utilizar técnicas de EAFP. 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 utilizar 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ítica de otra respuesta:

Otra respuesta dice esto sobre 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 los usuarios, y no es tan Pythonic como otras variantes. :

Esta respuesta dice que prefiere un método no pythonico, 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 (¡incluyendo KeyboardInterrupt y SystemExit !) SystemExit en silencio, lo que es una buena manera de ocultar errores.

Esto parece alentar a los usuarios a adoptar malas prácticas.

 import os #Your path here eg "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!" 

La importación de os hace que sea más fácil 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 .

Prueba 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:

También puede probar si un archivo es un tipo determinado de archivo usando 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 

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(): ... 

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

Si quieres leer un archivo, si existe, hazlo

 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,

 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 locking de archivos, eso es un asunto diferente.

Podrías 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: ‘whatever.txt’)

Luego, dependiendo del resultado, su progtwig puede seguir ejecutándose desde allí o puede codificar para detenerlo si lo desea.

Although I always recommend using try and except statements, here are a few possibilities for you (my personal favourite is using os.access ):

1. Try opening the file:

   Opening the file will always verify the existence of the file. You can make a function just like so:

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

   If it’s False, it will stop execution with an unhanded IOError or OSError in later versions of Python. To catch the exception, you have to use a try except clause. Of course, you can always use a try except` statement like so (thanks to hsandt for making me think):

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

2. Use os.path.exists(path) :

   This will check the existence of what you specify. However, it checks for files and directories so beware about how you use it.

    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. Use os.access(path, mode) :

   This will check whether you have access to the file. It will check for permissions. Based on the os.py documentation, typing in os.F_OK , it will check the existence of the path. However, using this will create a security hole, as someone can attack your file using the time between checking the permissions and opening the file. You should instead go directly to opening the file instead of checking its permissions. ( EAFP vs LBYP ). If you’re not going to open the file afterwards, and only checking its existence, then you can use this.

   Anyway, here:

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

I should also mention that there are two ways that you will not be able to verify the existence of a file. Either the issue will be permission denied or no such file or directory . If you catch an IOError , set the IOError as e (like my first option), and then type in print(e.args) so that you can hopefully determine your issue. ¡Espero que ayude! 🙂

Date:2017-12-04

Every possible solution has been listed in other answers.

An intuitive and arguable way to check if a file exists is the following:

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

I made an exhaustive cheatsheet for your reference:

 #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']} 

In Python 3.4 the language provides a new module to manage files:

 import pathlib path = pathlib.Path('path/to/file') if path.is_file(): # If you want to check a directory: path.is_dir() # If it is true, return true on your code. 

Additionally, os.access() :

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

Being R_OK , W_OK , and X_OK the flags to test for permissions ( doc ).