¿Cómo veo si un archivo existe o no, sin usar la statement de try
?
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 :
Posibles soluciones :
[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. DevuelveFalse
para enlaces simbólicos rotos. En algunas plataformas, esta función puede devolverFalse
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 ()
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
[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.
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:
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.
os.listdir
( os.scandir
cuando esté disponible) glob.glob
)
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.
[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)
… 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:
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 :
os.F_OK
en la llamada, pero eso es solo por claridad (su valor es 0 ) 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 .
__declspec(dllexport)
(¿por qué en la Tierra la persona normal haría eso?), el progtwig principal es cargable pero bastante inutilizable 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í.
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
Nota final (es) :
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:
¿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.
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
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
.
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
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()
comoisfile()
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.
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
):
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
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
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 ).