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

Si la razón por la que está verificando es para poder hacer algo como if file_exists: open_it(), es más seguro usar una try en el intento de abrirla. 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

Devuelva True si la ruta es un archivo regular existente. Esto sigue a los enlaces simbólicos, por lo que islink () y isfile () puede ser verdadero 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 (con puerto inverso 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 Path existe independientemente de si es 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.
Entonces, dependiendo de si solo quieres archivos simples o directorios, usarás 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

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, Python 3.4 se agregaron elementos específicos), intentaré agrupar todo.

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

Enunciado del problema :

1. Comprobar archivo (argumentable: ¿también carpeta (archivo "especial")?
2. No usetry/excepto/else/finalmentebloques

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 comportamientos ligeramente diferentes)

   os.path.exists(path)
   

   Devuelva True si 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 el 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 untry/exceptoblock around [Python 3]: os. stat (ruta, *, dir_fd = Ninguna, follow_symlinks = True) . Por lo tanto, su código estry/exceptofree, pero más abajo en la compilación hay (al menos) one tal bloque. Esto también se aplica a otras funciones ( incluyendo os.path.isfile).

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

   • Es una forma más elegante (y más 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 los administradores de contexto de instrucciones . 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 e.g. 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, hacer no intentar 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 envolturas sobretry/except/else/finalmenteblocks, como [Python 3]: La con instrucción dice:

   Esto permite que los patrones de uso de try ... except ... finally se encapsulen para una reutilización conveniente.

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

   • [Python 3]: os. listdir (path = '.') (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 aumentar significativamente el rendimiento del código que también necesita información sobre el tipo de archivo o atributo de archivo, porque los objetos os.DirEntry exponen esta información si el sistema operativo Lo proporciona al escanear un directorio. Todos los métodos os.DirEntry pueden realizar una llamada al sistema, pero is_dir () y is_file () usualmente 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 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 (pathname, *, recursive = False) (o su predecesor: glob.glob)
     • No parece una función de desplazamiento per se (al menos en algunos casos), pero sigue usando os.listdir

   
   Ya que estas iteraciones sobre carpetas, (en la mayoría de los casos) son ineficientes para nuestro problema (hay excepciones, como el comodín glob bing - como @ShadowRanger señaló), 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 (path, mode, *, dir_fd = None, Effective_ids = False, follow_symlinks = True) cuyo comportamiento es cercano a os.path.exists ( En realidad es más ancho, principalmente por el 2.^{dakota del Norte} argumento)

   • permisos de usuario puede restringir la "visibilidad" del archivo como indica el documento:

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

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

   Como también trabajo en C, también uso este método porque bajo el capó, llama nativo API 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:

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

   Nota : llamar a API s nativo también es posible a través de [Python 3]: ctypes - Una biblioteca de funciones foránea para Python , pero en la mayoría Los casos es más complicado.

   (Winespecífico): Dado que vcruntime * (msvcr *) .dll exporta a [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 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 libc ("/lib/x86_64-linux-gnu/libc.so.6") que puede (y muy probablemente,) variará entre los sistemas, Ninguna (o la cadena vacía) se puede pasar a CDLL constructor (ctypes.CDLL(None).access(b"/tmp", os.F_OK)). Según [man7]: DLOPEN (3) :

     Si nombre de archivo es NULL, entonces el identificador devuelto es para el programa principal. 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 al 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 se cargarán sus símbolos (incluido acceso)
     • Esto debe manejarse con cuidado, ya que funciones como main, Py_Main y (todas las) 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% por defecto). 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" exportado símbolos, así que a menos que alguien declare que las funciones en el ejecutable principal son __declspec(dllexport) (¿por qué en la Tierra regular persona haría eso?), el programa 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 (nuevamente, Win específico) [GitHub]: mhammond/pywin32 - Python para Windows (pywin32) Extensiones , que es un Python envoltorio sobre WINAPI s.

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

6. Otra solución (coja) (gainarie) es (como me gusta llamarlo) el sysadmin enfoque: use 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)):

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

Línea inferior :

• Hacer usarintentar/excepto/else/finalmenteblocks, porque 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) :

• 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. Solo porque el archivo existía cuando marcó 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) seguir utilizando 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 declaración 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
• Evitando Condiciones de Carrera

¿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 también devuelve True para los enlaces simbólicos que 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 backport del módulo pathlib desde pypi, pathlib2 , o de lo contrario marcar 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 usa try, pero Python usa try en todas partes. 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, 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 everything 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).

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 ya 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á 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, detecta la excepción y realiza 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 programa conoce ese archivo y podría eliminarlo, corre el riesgo de a condición de carrera si verifica que existe, porque entonces está racing para abrirlo antes de que condición (su existencia) cambie.

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 programa falle.

Pero si esta es su motivación, usted 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 da el suppress context manager (anteriormente el ignore context manager), que hace semánticamente exactamente lo mismo en menos líneas, mientras que (al menos superficialmente) cumple con el pedido original para evitar un try declaración:

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 rodar tu propia suppress, pero sin una 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)

Tal vez 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":

isfile

import os
os.path.isfile(path)

de la docs :

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 verdad para la misma ruta.

Pero si examinas el source de esta función, verás que realmente usa una instrucción try:

# 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, sugeriría intentarlo directamente 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 está 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 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 la docs :

Nota: usar 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 breve 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 acerca de os.access:

Personalmente, prefiero éste 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 (incluyendo KeyboardInterrupt y SystemExit!) Pasen 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 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 hace que sea más fácil navegar y realizar acciones estándar con su sistema operativo.

Para referencia también vea ¿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 seguir usando 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(), así que debes 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 bloqueo 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 programa puede seguir ejecutándose desde allí o puede codificar para detenerlo si lo desea.

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:

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

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

   Si es False, detendrá la ejecución con un IOError u OSError no administrado en versiones posteriores de Python. Para detectar la excepción, debe usar una cláusula de excepción de prueba. Por supuesto, siempre puedes usar una declaración de try except` (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. Use os.path.exists(path):

   Esto comprobará la existencia de lo que especifique. Sin embargo, comprueba los archivos y directorios, 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. Use os.access(path, mode):

   Esto comprobará si tiene acceso al archivo. Se comprobará los permisos. Basándose en la documentación de os.py, escribiendo 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 va a abrir el archivo más tarde y solo está verificando su existencia, puede usar esto.

   De todos modos, aquí:

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

También debo mencionar que hay dos formas de no poder verificar la existencia de un archivo. El problema será permission denied o no such file or directory. Si detecta una 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! :)

Fecha: 2017-12-04

Cada solución posible ha sido listada en otras respuestas.

Una forma intuitiva y discutible de verificar si un archivo existe 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']}

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 banderas para probar los permisos ( doc ).

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

ACTUALIZACIÓN

Solo para evitar confusiones y en base a las respuestas que recibí, la respuesta actual encuentra un archivo o un directorio con el nombre dado.

if os.path.isfile(path_to_file):
    try: 
        open(path_to_file)
            pass
    except IOError as e:
        print "Unable to open file"

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

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

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

Si ya importó NumPy para otros propósitos, 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 basado en su existencia.

Revisar archivo o directorio existe

Puedes seguir estas tres formas:

Nota 1: el os.path.isfile usado 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 usado para archivos y 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()

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

Esto manejará el caso de que file_path sea 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

Añadiendo 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):

Soy el autor de un paquete que ha existido durante aproximadamente 10 años y tiene una función que aborda esta pregunta directamente. Básicamente, si estás en un sistema que no es Windows, usa Popen para acceder a find. Sin embargo, si está en Windows, 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 hand-buillt find. Las pruebas de tiempo mostraron que la try fue más rápida en la determinación del sistema operativo, así que usé una 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í: https://github.com/uqfoundation/pox/blob/89f90fb308f285ca7a62eabe2c38acb87e89dad9/pox/shutils.py#L190

Aquí hay un comando de 1 línea de Python 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.

¿Cómo compruebo si existe un archivo sin usar la instrucción try?

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 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 el manejo de archivos faltantes con IOErrors, en lugar de if sentencias (solo un consejo).

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

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)

Puede usar el siguiente método abierto para verificar si existe un archivo + legible:

open(inputFile, 'r')

import os
path = /path/to/dir

root,dirs,files = os.walk(path).next()
if myfile in files:
   print "yes it exists"

Esto es útil cuando se comprueban varios archivos. O desea hacer un conjunto de intersección/resta con una lista existente.

Para comprobar si existe un archivo,

from sys import argv

from os.path import exists
script, filename = argv
target = open(filename)
print "file exists: %r" % exists(filename)

Puede usar os.listdir para verificar si un archivo está en un directorio determinado.

import os
if 'file.ext' in os.listdir('dirpath'):
    #code

import os

# for testing purpose args defaulted to current folder & file. 
# returns True if file found
def file_exists(FOLDER_PATH='../', FILE_NAME=__file__):
    return os.path.isdir(FOLDER_PATH) \
        and os.path.isfile(os.path.join(FOLDER_PATH, FILE_NAME))

Básicamente, una comprobación de carpeta, luego una comprobación de archivo con el separador de directorio adecuado utilizando os.path.join .

Definitivamente deberías usar este.

from os.path import exists

if exists("file") == True:
    print "File exists."
Elif exists("file") == False:
    print "File doesn't exist."

Probablemente no sea necesario, pero si lo es, aquí hay algo de código.

import os

def file_exists(path, filename):
    for file_or_folder in os.listdir(path):
        if file_or_folder == filename:
            return True
    return False