python - 如何检查文件是否存在无异常？

Question

如何在不使用try语句的情况下检查文件是否存在？

Answer 1

如果您检查的原因是您可以执行类似的操作，那么在尝试打开它if file_exists: open_it()时使用 a 会更安全。try检查然后打开可能会导致文件被删除或移动，或者在检查和尝试打开文件之间存在风险。

如果您不打算立即打开文件，可以使用os.path.isfile

True如果 path 是现有的常规文件，则返回。这遵循符号链接，因此islink()和isfile()对于同一路径都可以为真。

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

如果您需要确定它是一个文件。

从 Python 3.4 开始，该pathlib模块提供了一种面向对象的方法（pathlib2在 Python 2.7 中向后移植）：

from pathlib import Path

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

要检查目录，请执行以下操作：

if my_file.is_dir():
    # directory exists

要检查一个Path对象是否独立于它是文件还是目录而存在，请使用exists()：

if my_file.exists():
    # path exists

您还可以resolve(strict=True)在try块中使用：

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

Answer 2

你有这个os.path.exists功能：

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

这True将为文件和目录返回，但您可以改为使用

os.path.isfile(file_path)

测试它是否是专门的文件。它遵循符号链接。

Answer 3

与, 不同isfile()，exists()将返回True目录。因此，取决于您是否只想要普通文件或目录，您将使用isfile()or exists()。这是一些简单的 REPL 输出：

>>> os.path.isfile("/etc/password.txt")
True
>>> os.path.isfile("/etc")
False
>>> os.path.isfile("/does/not/exist")
False
>>> os.path.exists("/etc/password.txt")
True
>>> os.path.exists("/etc")
True
>>> os.path.exists("/does/not/exist")
False

Answer 4

import os

if os.path.isfile(filepath):
   print("File exists")

Answer 5

os.path.isfile()与 一起使用os.access()：

import os

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

Answer 6

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

Answer 7

尽管几乎所有可能的方式都列在（至少一个）现有答案中（例如添加了Python 3.4特定的东西），但我会尝试将所有内容组合在一起。

注意：我要发布的每一段Python标准库代码都属于3.5.3版本。

问题陈述：

1. 检查文件（有争议：还有文件夹（“特殊”文件）？）存在
2. 不要使用try / except / else / finally块

可能的解决方案：

1. [Python 3]：os.path。存在（路径）（也检查其他函数系列成员，如，，，以os.path.isfile了解略有不同的行为）os.path.isdiros.path.lexists

   os.path.exists(path)
   

   True如果path引用现有路径或打开的文件描述符，则返回。返回False损坏的符号链接。False在某些平台上，如果未授予对请求的文件执行os.stat()的权限，即使路径物理存在，此函数也可能返回。

   一切都好，但如果遵循导入树：

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

     • genericpath.py，行~#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
       

   这只是 [Python 3] 周围的try / except块：os. stat（路径，*，dir_fd=None，follow_symlinks=True）。因此，您的代码是try / except free，但在框架堆栈的较低位置（至少）有一个这样的块。这也适用于其他功能（包括 os.path.isfile）。

   1.1。[Python 3]：路径。is_file ()

   • 这是一种处理路径的更高级（和更多python ic）的方式，但是

   • 在引擎盖下，它做的事情完全相同（pathlib.py，行~#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]：使用语句上下文管理器。任何一个：

   • 创建一个：

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

     • 及其用法 - 我将复制该os.path.isfile行为（请注意，这仅用于演示目的，请勿尝试为生产编写此类代码）：

       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
       

   • 使用[Python 3]：contextlib。抑制( *exceptions ) -专为选择性抑制异常而设计

   
   但是，它们似乎是try / except / else / finally块的包装器，如[Python 3]：with语句指出：

   这允许封装常见的try ... except ... finally使用模式以方便重用。

3. 文件系统遍历函数（并搜索匹配项的结果）

   • [Python 3]：操作系统。listdir ( path='.' )（或[Python 3]: os.scandir ( path='.' ) on Python v 3.5 +，backport: [PyPI]: scandir）

     • 在引擎盖下，两者都使用：

       • 尼克斯：[man7]：OPENDIR（3） / [man7]：READDIR（3） / [man7]：CLOSEDIR（3）
       • Win : [MS.Docs]: FindFirstFileW 函数/ [MS.Docs]: FindNextFileW 函数/ [MS.Docs]: FindClose 函数

       通过[GitHub]：python/cpython - (master) cpython/Modules/posixmodule.c

     使用scandir()代替listdir()可以显着提高还需要文件类型或文件属性信息的代码的性能，因为如果操作系统在扫描目录时提供了这些信息， os.DirEntry对象就会公开这些信息。所有os.DirEntry方法都可以执行系统调用，但is_dir()和is_file()通常只需要对符号链接进行系统调用；os.DirEntry.stat()在 Unix 上总是需要一个系统调用，但在 Windows 上只需要一个用于符号链接。

   • [Python 3]：操作系统。walk ( top, topdown=True, onerror=None, followlinks=False )
     • 它使用os.listdir（os.scandir如果可用）
   • [Python 3]：全局。iglob ( pathname, *, recursive=False ) (或其前身: glob.glob)
     • 本身似乎不是一个遍历函数（至少在某些情况下），但它仍然使用os.listdir

   
   由于这些迭代文件夹，（在大多数情况下）它们对我们的问题效率低下（有例外，如非通配符glob bing - 正如@ShadowRanger 指出的那样），所以我不会坚持使用它们。更不用说在某些情况下，可能需要文件名处理。

4. [Python 3]：操作系统。访问（path, mode, *, dir_fd=None, Effective_ids=False, follow_symlinks=True）的行为接近os.path.exists（实际上它更广泛，主要是因为^第二个参数）

   • 正如文档所述，用户权限可能会限制文件“可见性”：

     ...测试调用用户是否具有对path的指定访问权限。模式应该是F_OK来测试路径的存在...

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

   由于我也在C中工作，因此我也使用此方法，因为在后台，它调用本机API（再次通过"${PYTHON_SRC_DIR}/Modules/posixmodule.c"），但它也为可能的用户打开了一扇门errors，它不像其他变体那样是Python ic。因此，正如@AaronHall 正确指出的那样，除非您知道自己在做什么，否则不要使用它：

   • Nix : [man7]: ACCESS(2) (!!!注意关于它的使用可能引入的安全漏洞的注释!!!)
   • 赢：[MS.Docs]：GetFileAttributesW 函数

   注意：也可以通过[Python 3]调用本机API ： ctypes - Python 的外部函数库，但在大多数情况下它更复杂。

   （特定于Win）：由于vcruntime* ( msvcr* ) .dll也导出了[MS.Docs]: _access, _waccess函数系列，下面是一个示例：

   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
   

   备注：

   • 虽然这不是一个好习惯，但我os.F_OK在通话中使用，但这只是为了清楚起见（其值为0）
   • 我正在使用_waccess以便在Python3和Python2上运行相同的代码（尽管它们之间存在unicode相关的差异）
   • 虽然这针对一个非常具体的领域，但在之前的任何答案中都没有提到

   
   Lnx ( Ubtu (16 x64) ) 也对应：

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

   备注：

   • 相反，硬编码libc的路径（“/lib/x86_64-linux-gnu/libc.so.6”）可能（并且很可能会）因系统而异，无（或空字符串）可以传递给CDLL构造函数( ctypes.CDLL(None).access(b"/tmp", os.F_OK))。根据[man7]： DLOPEN(3)：

     如果filename为 NULL，则返回的句柄用于主程序。当给dlsym () 时，这个句柄会导致在主程序中搜索一个符号，然后是在程序启动时加载的所有共享对象，然后是由dlopen () 加载的所有共享对象，带有标志RTLD_GLOBAL。

     • 主（当前）程序（python）与libc链接，因此将加载其符号（包括access ）
     • 这必须小心处理，因为main、Py_Main和（所有）其他函数都是可用的；调用它们可能会产生灾难性影响（在当前程序上）
     • 这也不适用于Win（但这没什么大不了的，因为msvcrt.dll位于“%SystemRoot%\System32”中，默认情况下位于%PATH%中）。我想更进一步并在Win上复制这种行为（并提交补丁），但事实证明，[MS.Docs]：GetProcAddress 函数只“看到”导出的符号，所以除非有人在主可执行文件中声明这些函数作为__declspec(dllexport)（为什么地球上的普通人会这样做？），主程序是可加载的，但几乎无法使用

5. 安装一些具有文件系统功能的第三方模块

   最有可能的是，将依赖上述方式之一（可能有轻微的定制）。
   一个例子是（同样，特定于Win）[GitHub]：mhammond/pywin32 - Python for Windows (pywin32) Extensions，它是WINAPI上的Python包装器。

   但是，由于这更像是一种解决方法，所以我在这里停下来。

6. 另一个（蹩脚的）解决方法（gainarie）是（我喜欢这样称呼它）系统管理员方法：使用Python作为包装器来执行 shell 命令

   • 赢：

     (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
     

   • 尼克斯（Lnx（乌图））：

     [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
     

底线：

• 一定要使用try / except / else / finally块，因为它们可以防止你遇到一系列讨厌的问题。我能想到的一个反例是性能：这样的块很昂贵，所以尽量不要将它们放在应该每秒运行数十万次的代码中（但因为（在大多数情况下）它涉及磁盘访问，不会是这样）。

最后说明：

• 我会尽量保持最新，欢迎任何建议，我会将任何有用的东西纳入答案

Answer 8

Python 3.4+有一个面向对象的路径模块：pathlib。使用这个新模块，您可以像这样检查文件是否存在：

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

try/except您可以（通常应该）在打开文件时仍然使用块：

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

pathlib 模块中有很多很酷的东西：方便的通配符、检查文件的所有者、更简单的路径连接等。值得一试。如果您使用的是较旧的 Python（2.6 版或更高版本），您仍然可以使用 pip 安装 pathlib：

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

然后按如下方式导入：

# Older Python versions
import pathlib2 as pathlib

Answer 9

这是检查文件是否存在的最简单方法。仅仅因为您检查时该文件存在并不能保证在您需要打开它时它会在那里。

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

Answer 10

如何在不使用 try 语句的情况下使用 Python 检查文件是否存在？

现在从 Python 3.4 开始可用，Path使用文件名导入和实例化一个对象，并检查is_file方法（注意，对于指向常规文件的符号链接，这也会返回 True）：

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

如果您使用的是 Python 2，则可以从 pypi 反向移植 pathlib 模块pathlib2，或者isfile从os.path模块中检查：

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

现在上面可能是这里最好的实用直接答案，但是可能存在竞争条件（取决于您要完成的工作），以及底层实现使用 a 的事实try，但 Pythontry在其实现中无处不在。

因为 Pythontry无处不在，所以没有理由避免使用它的实现。

但是这个答案的其余部分试图考虑这些警告。

更长，更迂腐的答案

从 Python 3.4 开始可用，Path使用pathlib. 请注意，这.exists并不完全正确，因为目录不是文件（除非在 unix 意义上，一切都是文件）。

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

所以我们需要使用is_file：

>>> root.is_file()
False

这是关于的帮助is_file：

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

所以让我们得到一个我们知道是文件的文件：

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

默认情况下，NamedTemporaryFile关闭时删除文件（当没有更多引用时将自动关闭）。

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

但是，如果您深入研究实现，您会看到is_file使用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

比赛条件：为什么我们喜欢尝试

我们喜欢try，因为它避免了竞争条件。使用try，您只需尝试读取您的文件，并期望它存在，如果没有，您将捕获异常并执行任何有意义的回退行为。

如果您想在尝试读取文件之前检查文件是否存在，并且您可能正在删除它，然后您可能正在使用多个线程或进程，或者另一个程序知道该文件并可以删除它 - 您可能会冒如果您检查它是否存在，则为竞争条件，因为您随后会在其条件（其存在）更改之前竞相打开它。

竞态条件很难调试，因为有一个非常小的窗口可能会导致程序失败。

但如果这是你的动机，你可以try通过使用suppress上下文管理器来获得语句的价值。

在没有 try 语句的情况下避免竞争条件：suppress

Python 3.4 为我们提供了suppress上下文管理器（以前的ignore上下文管理器），它在语义上以更少的行数完成完全相同的事情，同时（至少在表面上）满足了避免try声明的原始要求：

from contextlib import suppress
from pathlib import Path

用法：

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

对于早期的 Python，你可以自己滚动suppress，但没有 atry会比 with 更冗长。我确实相信这实际上是唯一一个在 Python 3.4 之前的 Python 中任何级别都没有使用的答案，因为它使用了上下文管理器：try

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)

尝试一下可能更容易：

from contextlib import contextmanager

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

其他不符合“无需尝试”要求的选项：

文件

import os
os.path.isfile(path)

来自文档：

os.path.isfile(path)

如果 path 是现有的常规文件，则返回 True。这遵循符号链接，因此对于同一路径，两者islink()和isfile()都可以为真。

但是如果你检查这个函数的源代码，你会发现它确实使用了一个 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

它所做的只是使用给定的路径来查看它是否可以获得统计信息，捕获OSError然后检查它是否是一个文件，如果它没有引发异常。

如果您打算对该文件执行某些操作，我建议您直接尝试使用 try-except 来避免竞争条件：

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

操作系统访问

适用于 Unix 和 Windows 的是os.access，但要使用你必须传递标志，并且它不区分文件和目录。这更用于测试真正的调用用户是否可以在提升的特权环境中访问：

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

它也遭受与isfile. 从文档：

注意：使用 access() 来检查用户是否被授权例如在使用 open() 实际打开文件之前打开文件会产生安全漏洞，因为用户可能会利用检查和打开文件之间的短时间间隔来操作它。最好使用 EAFP 技术。例如：

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

最好写成：

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

避免使用os.access. 它是一个低级函数，比上面讨论的高级对象和函数有更多的用户错误机会。

对另一个答案的批评：

另一个答案是这样说的os.access：

就个人而言，我更喜欢这个，因为在底层，它调用原生 API（通过“${PYTHON_SRC_DIR}/Modules/posixmodule.c”），但它也为可能的用户错误打开了大门，而且它不像其他变体那样 Pythonic ：

这个答案说它更喜欢非 Pythonic、容易出错的方法，没有任何理由。它似乎鼓励用户在不了解它们的情况下使用低级 API。

它还创建了一个上下文管理器，通过无条件返回True，允许所有异常（包括KeyboardInterrupt和SystemExit！）静默通过，这是隐藏错误的好方法。

这似乎鼓励用户采用不良做法。

Answer 11

更喜欢 try 语句。它被认为是更好的风格并避免了竞争条件。

不要相信我的话。这个理论有很多支持。这是一对：

• 样式： http ://allendowney.com/sd/notes/notes11.txt 的“处理异常情况”部分
• 避免竞争条件

Answer 12

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

导入os使您可以更轻松地在操作系统中导航和执行标准操作。

另请参阅如何使用 Python 检查文件是否存在？

如果您需要高级操作，请使用shutil.

Answer 13

os.path.isfile()使用和测试文件和文件os.path.isdir()夹os.path.exists()

假设“路径”是有效路径，下表显示了每个函数为文件和文件夹返回的内容：

您还可以测试文件是否是用于获取扩展名的某种类型的文件os.path.splitext()（如果您还不知道）

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

Answer 14

在 2016 年，最好的方法仍然是使用os.path.isfile：

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

或者在 Python 3 中，您可以使用pathlib：

import pathlib
path = pathlib.Path('/path/to/some/file.txt')
if path.is_file():
    ...

Answer 15

try/except 和 之间似乎没有有意义的功能差异isfile()，因此您应该使用哪个有意义。

如果要读取文件，如果存在，请执行

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

但是，如果您只想重命名文件（如果存在），因此不需要打开它，请执行

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

如果要写入文件，如果文件不存在，请执行

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

如果您需要文件锁定，那就另当别论了。

Answer 16

TL；DR
答案是：pathlib模块——只有一行代码——

Pathlib可能是几乎所有文件操作的最现代和最方便的方式。对于文件或文件夹的存在，一行代码就足够了。

from pathlib import Path

if Path("myfile.txt").exists(): # works for both file and folders
    # do your cool stuff...

该pathlib模块是在 中引入的Python 3.4，因此您需要拥有 Python 3.4+，这个库使您在处理文件和文件夹时变得更加轻松，而且它很好用，这里有更多关于它的文档（https://docs.python. org/3/library/pathlib.html )。

顺便说一句，如果您要重用路径，那么最好将其分配给变量

所以会变成

from pathlib import Path

p = Path("loc/of/myfile.txt")
if p.exists(): # works for both file and folders
    # do stuffs...
#reuse 'p' if needed.

Answer 17

你可以试试这个（更安全）：

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

输出将是：

（[Errno 2] 没有这样的文件或目录：'whatever.txt'）

然后，根据结果，您的程序可以从那里继续运行，或者您可以根据需要编写代码来停止它。

Answer 18

日期：2017-12-04

每个可能的解决方案都已在其他答案中列出。

检查文件是否存在的一种直观且有争议的方法如下：

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

我制作了一份详尽的备忘单供您参考：

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

Answer 19

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. I hope it helps! :)

Answer 20

最简单的方法是使用

import os

if os.path.exists(FILE):
  # file exists
  pass
else:
  # file does not exists
  pass

来自 os 库，而FILE是相对路径。在 Windows 中，这可能会或很多不起作用，您可能必须通过这样做来使用绝对路径os.path.exists(os.path.join(os.path.abspath('./'), FILE))，其中FILE仍然是相对路径加上文件名

Answer 21

此外，os.access()：

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

存在R_OK,W_OK和X_OK用于测试权限的标志 ( doc )。

Answer 22

如果文件用于打开，您可以使用以下技术之一：

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

---

更新

只是为了避免混淆，根据我得到的答案，当前答案会找到具有给定名称的文件或目录。

Answer 23

您可以使用 os.path.exists() ：

import os
print(os.path.exists("file"))

希望它有帮助：D

Answer 24

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

引发异常被认为是一种可接受的 Pythonic 方法，用于在您的程序中进行流控制。考虑使用 IOErrors 处理丢失的文件。在这种情况下，如果文件存在但用户没有读取权限，则会引发 IOError 异常。

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

Answer 25

如果您已经出于其他目的导入了 NumPy，则无需导入其他库，如pathlib、os、paths等。

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

这将根据其存在返回 true 或 false。

Answer 26

您可以在没有try:.

from contextlib import suppress

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

suppress是 Python 3.4 的一部分。在旧版本中，您可以快速编写自己的抑制：

from contextlib import contextmanager

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

Answer 27

检查文件或目录是否存在

您可以遵循以下三种方式：

注1：os.path.isfile仅用于文件

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

注意2：os.path.exists用于文件和目录

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

该pathlib.Path方法（包含在 Python 3+ 中，可通过 Python 2 的 pip 安装）

from pathlib import Path
Path(filename).exists()

Answer 28

我是一个已经存在了大约 10 年的包的作者，它具有直接解决这个问题的功能。基本上，如果您在非 Windows 系统上，它用于Popen访问find. 但是，如果您在 Windows 上，它会find使用高效的文件系统 walker 进行复制。

代码本身不使用try块......除了确定操作系统并因此引导您使用“Unix”风格find或手工构建的find. 计时测试表明，try确定操作系统的速度更快，所以我确实在那里使用了一个（但没有在其他地方使用）。

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

还有医生……</p>

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

>>>

如果你想看的话，实现在这里： https ://github.com/uqfoundation/pox/blob/89f90fb308f285ca7a62eabe2c38acb87e89dad9/pox/shutils.py#L190

Answer 29

添加一个未完全反映在其他答案中的细微变化。

这将处理file_path存在None或空字符串的情况。

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

根据 Shahbaz 的建议添加变体

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

根据 Peter Wood 的建议添加变体

def file_exists(file_path):
    return file_path and os.path.isfile(file_path):

Answer 30

这是用于 Linux 命令行环境的 1 行 Python 命令。我觉得这很方便，因为我不是那么热的 Bash 人。

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

我希望这是有帮助的。

Answer 31

您可以使用 Python 的“OS”库：

>>> import os
>>> os.path.exists("C:\\Users\\####\\Desktop\\test.txt") 
True
>>> os.path.exists("C:\\Users\\####\\Desktop\\test.tx")
False

Answer 32

如何在不使用 try 语句的情况下检查文件是否存在？

在 2016 年，这仍然可以说是检查文件是否存在以及它是否是文件的最简单方法：

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

isfile实际上只是内部使用os.stat和stat.S_ISREG(mode)底层的辅助方法。这os.stat是一种较低级别的方法，它将为您提供有关文件、目录、套接字、缓冲区等的详细信息。更多关于 os.stat 这里

注意：但是，这种方法不会以任何方式锁定文件，因此您的代码可能容易受到“检查时间到使用时间”（TOCTTOU）错误的影响。

因此，引发异常被认为是一种可接受的 Pythonic 方法，用于在您的程序中进行流控制。并且应该考虑使用 IOErrors 而不是if语句（只是一个建议）来处理丢失的文件。

Answer 33

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)

Answer 34

' Path ' 对象的exists()和is_file()方法可用于检查给定路径是否存在并且是文件。

用于检查文件是否存在的 Python 3 程序：

# File name:  check-if-file-exists.py

from pathlib import Path

filePath = Path(input("Enter path of the file to be found: "))

if filePath.exists() and filePath.is_file():
    print("Success: File exists")
else:
    print("Error: File does not exist")

输出：

$ python3 检查文件是否存在.py

输入要找到的文件的路径：/Users/macuser1/stack-overflow/index.html

成功：文件存在

$ python3 检查文件是否存在.py

输入要查找的文件路径：hghjg jghj

错误：文件不存在

Answer 35

你绝对应该使用这个。

from os.path import exists

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

Answer 36

import os
path = /path/to/dir

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

这在检查多个文件时很有帮助。或者您想对现有列表进行设置交集/减法。

Answer 37

要检查文件是否存在，

from sys import argv

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

Answer 38

您可以使用以下打开方法来检查文件是否存在+可读：

file = open(inputFile, 'r')
file.close()

Answer 39

您可以使用 os.listdir 检查文件是否在某个目录中。

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

Answer 40

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

基本上是文件夹检查，然后使用os.path.join使用适当的目录分隔符进行文件检查。

Answer 41

使用os.path.exists()检查文件是否存在：

def fileAtLocation(filename,path):
    return os.path.exists(path + filename)
 

filename="dummy.txt"
path = "/home/ie/SachinSaga/scripts/subscription_unit_reader_file/"


if fileAtLocation(filename,path):
   print('file found at location..')
else:
   print('file not found at location..')

Answer 42

另一种可能的选择是使用 os.listdir() 检查文件名是否在目录中

import os
if 'foo.txt' in os.listdir():
    # Do things

如果是则返回 true，否则返回 false