检查文件或目录是否存在

Question

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

Answer 1

如果你检查的原因是这样你可以做if file_exists: open_it()之类的事情，那么在尝试打开它时使用try会更安全。检查然后打开文件被删除或移动的风险，或者在您检查和尝试打开文件时之间存在某种风险。

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

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

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

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

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

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()或exists()。这是一个简单的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

Answer 4

import os.path

if os.path.isfile(filepath):

Answer 5

os.path.isfile()使用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"

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 特定内容），但我会尝试将所有内容组合在一起。< / p>

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

问题陈述：

检查文件（可论证的：也是文件夹（＆＃34;特殊＆＃34;文件）？）存在
请勿使用尝试 / ， / else / 最后阻止

可能的解决方案：

[Python 3]: os.path.exists(path)（同时检查其他功能家庭成员，例如os.path.isfile，os.path.isdir，os.path.lexists，行为略有不同）
```
os.path.exists(path)
```
如果 path 引用现有路径或打开文件描述符，则返回True。对于损坏的符号链接，返回False。在某些平台上，如果未授予对所请求文件执行os.stat()的权限，则此函数可能会返回False，即使路径在物理上存在。

一切都很好，但如果遵循导入树：
- 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]: os.stat(path, *, dir_fd=None, follow_symlinks=True)。因此，您的代码尝试 / 除了免费，但在框架中的代码更低（在至少）一个这样的块。这也适用于其他功能（包括 os.path.isfile）。

1.1。 [Python 3]: Path.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
```

[Python 3]: With Statement Context Managers。之一：

创建一个：

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.suppress(*exceptions) - 专门设计用于有选择地抑制异常

但是，它们似乎是尝试 / 的包装，除了 / else / 最后阻止，如[Python 3]: The with statement所述：

这样可以封装常见的try ... except ... finally使用模式，以方便重复使用。

文件系统遍历功能（并搜索匹配项目的结果）
- [Python 3]: os.listdir(path='.')（或<{3>} Python v 3.5 +，backport：[Python 3]: os.scandir(path='.')）
  - 在幕后，两者都使用：
    - Nix ：[PyPI]: scandir / [man7]: OPENDIR(3) / [man7]: READDIR(3)
    - 赢取：[man7]: CLOSEDIR(3) / [MS.Docs]: FindFirstFileW function / [MS.Docs]: FindNextFileW function
    通过[MS.Docs]: FindClose function
  使用[GitHub]: python/cpython - (master) cpython/Modules/posixmodule.c而不是scandir()可以显着提高还需要文件类型或文件属性信息的代码的性能，因为listdir()对象在操作系统提供时会公开此信息扫描目录。所有os.DirEntry方法都可以执行系统调用，但os.DirEntry和is_dir()通常只需要系统调用符号链接; is_file()始终需要在Unix上进行系统调用，但在Windows上只需要一个符号链接。
- os.DirEntry.stat()
  - 它使用os.listdir（os.scandir可用时）
- [Python 3]: os.walk(top, topdown=True, onerror=None, followlinks=False)（或其前身：glob.glob）
  - 似乎不是一个遍历函数本身（至少在某些情况下），但它仍然使用os.listdir
由于这些迭代文件夹，（在大多数情况下）它们对我们的问题效率低（有异常，例如非通配的 glob bing - 正如@ShadowRanger所指出的那样）所以我不会坚持他们。更不用说在某些情况下，可能需要文件名处理。
[Python 3]: glob.iglob(pathname, *, recursive=False)，其行为接近os.path.exists（实际上它更宽，主要是因为2 ^nd参数）
- 用户权限可能会限制文件＆＃34;可见性＆＃34;正如文件所述：
  
  ...测试调用用户是否具有 path 的指定访问权限。模式应为[Python 3]: os.access(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)以测试路径的存在...
os.access("/tmp", os.F_OK)

由于我也在 C 中工作，我也使用这种方法，因为它引用了原生的 API s （同样，通过＆＃34; $ {PYTHON_SRC_DIR} /Modules/posixmodule.c" ），但它也为可能的用户错误打开了一扇门，它就是＆＃39;不像其他变种那样 Python ic。所以，正如@AaronHall正确指出的那样，除非你知道自己在做什么，否则不要使用它：
- Nix ：F_OK（!!!注意关于安全漏洞的说明，其用法可能会介绍!!!）
- 赢取：[man7]: ACCESS(2)
注意：也可以通过[MS.Docs]: GetFileAttributesW function调用原生 API ，但在大多数情况下，它更复杂。

（ Win 具体）：由于 vcruntime * （ msvcr * ） .dll 也导出一个[Python 3]: ctypes - A foreign function library for Python函数系列，这是一个例子：
```
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 < / em>他们之间的相关差异）

虽然这针对的是一个非常具体的区域，以前的任何答案都没有提及

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 的路径（＆＃34; /lib/x86_64-linux-gnu/libc.so.6" ）可能（并且很可能会）在不同系统之间变化，无（或空字符串）可以传递给 CDLL 构造函数（ {{1} } ）。根据{{3}}：

如果 filename 为NULL，则返回的句柄为main 程序。当赋予 dlsym （）时，此句柄会导致搜索a 主程序中的符号，后跟加载的所有共享对象程序启动，然后由 dlopen （）加载的所有共享对象标志 RTLD_GLOBAL 。

主要（当前）程序（ python ）与 libc 相关联，因此将加载其符号（包括 access ）

必须小心处理，因为 main ， Py_Main 和（所有）其他功能都可用;称他们可能会产生灾难性的影响（在当前的计划中）

这也不适用于 Win （但这并不是什么大问题，因为 msvcrt.dll 位于 ＆＃34;％SystemRoot％\ System32＆＃34; 默认位于％PATH％中）。我想更进一步，并在 Win 上复制此行为（并提交补丁），但事实证明，[MS.Docs]: _access, _waccess只有＆＃34;看到＆＃34; 导出符号，所以除非有人将主要可执行文件中的函数声明为ctypes.CDLL(None).access(b"/tmp", os.F_OK)（为什么地球上常规人会这样做？），主程序是可装载但几乎无法使用

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

最有可能的，将依赖于上述方法之一（可能需要轻微的自定义）。
一个例子是（同样， Win 特定）[man7]: DLOPEN(3)，它是 Python 包装器，通过 WINAPI 。

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

另一个（蹩脚的）解决方法（ gainarie ）是（我喜欢称之为） sysadmin 方法：使用 Python 作为执行shell命令的包装器

运：

__declspec(dllexport)

Nix （ Lnx （ Ubtu ））：

(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

底线：

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

最后的注释：

我会尽量保持最新，欢迎提出任何建议，我会将有用的内容纳入到答案中

Answer 8

这是检查文件是否存在的最简单方法。只需因为您选中的文件保证，当您需要打开它时它就会存在。

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 9

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 10

首选try语句。它被认为是更好的风格，避免了竞争条件。

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

样式：http://allendowney.com/sd/notes/notes11.txt
Avoiding Race Conditions

Answer 11

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

现在可用于Python 3.4，导入并使用文件名实例化Path对象，并检查is_file方法（请注意，对于指向常规文件的符号链接，这将返回True）：< / p>

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

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

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

现在上面这可能是最好的实用直接答案，但是存在竞争条件的可能性（取决于你想要完成的事情），以及底层实现使用的事实try，但Python在其实现中到处使用try。

因为Python在任何地方使用try，所以没有理由避免使用它的实现。

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

更长，更迂腐的答案

自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

如果你深入研究the implementation，你会发现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()
... 
>>>

对于早期的Pythons，你可以推出自己的suppress，但如果没有try则会更加冗长。我相信这实际上是唯一没有在Python 中使用try的答案，可以在Python 3.4之前应用，因为它使用了上下文管理器而不是：

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

其他不符合要求的选项＆＃34;没有尝试＆＃34;：

<强> ISFILE

import os
os.path.isfile(path)

来自docs：

os.path.isfile(path)

如果path是现有常规文件，则返回True。这符合象征意义   链接，因此islink()和isfile()对于同一条路径都可以为真。

但是如果你检查这个函数的source，你会发现它确实使用了一个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:
    with open(path) as f:
        f.read()
except OSError:
    pass

<强> os.access

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

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

它也遇到与isfile相同的种族问题。来自docs：

注意：使用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（通过＆＃34; $ {PYTHON_SRC_DIR} /Modules/posixmodule.c"），但它也为可能的用户错误打开了一扇门，并且它不像其他变体那样是Pythonic：

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

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

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

Answer 12

$('#servicesTable').dataTable({
    'aaData': servicesJson['registered_services'],
    'aoColumns': [
        {"sTitle": "Hostname", sName: "host", sWidth: "30%", sClass: 'host', mData:
            function (source) {
                return source.hostname
            }
        },
        {"sTitle": "Service", sName: "service", sWidth: "30%", sClass: 'service', mData: "serviceName"},
        {"sTitle": "Monitored?", sName: "monitored", sWidth: "10%", sClass: 'monitored', mData:
            function (source) {
                if (typeof source.active === 'undefined')
                    return '';
                var monitor = source.active;
                if (monitor == 1)
                    return "<input type='checkbox' class='monitor' name='monitored' checked />";
                else
                    return "<input type='checkbox' class='monitor' name='monitored'/>";
            }
        },
        {"sTitle": "Status", sName: "status", sWidth: "15%", sClass: 'status', mData: "status"},
        {"sTitle": "URL", sName: "url", sWidth: "5%", sClass: 'url right', mData:
            function (source) {
                if (typeof source.url === 'undefined' || source.url == '')
                    return '';
                return "<a class='ui-icon ui-icon-link' href='" + source.url + "'>NAGIOS</a>";
            }
        },
        {"sTitle": "Add/Remove", sName: "add-remove-new", sWidth: "15%", sClass: 'add-remove-new', mData:
            function (source, type, val) {
                if (typeof source.addRemove === 'undefined')
                    return "<button class='add-remove-new' type='button'>Remove</button>";
                else
                    return "<button class='add-remove-new' type='button'>Add</button>";
            }
        },
    ],
    'bJQueryUI': true,
    'bInfo': false,
    'bPaginate': false,
    'bSort': false,
    'bFilter': true,
    'iDisplayLength': 25,
    "fnRowCallback": function (nRow, aData, iDisplayIndex, iDisplayIndexFull) {
        //function that is called everytime an element is added or a redraw is called
        //aData[] is an arraw of the values stored in datatables for the row
        //to change a row's html use $('td:eq('+index+')', nRow).html( html here ); where index is the index of the td element in the row
    }
});

导入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!"可以更轻松地导航并使用您的操作系统执行标准操作。

如需参考，请参阅How to check whether a file exists using Python?

如果您需要高级操作，请使用os。

Answer 13

使用Close High Low Open Time Date %pct 60 5162.448 5165.124 5162.448 5165.057 14:35:00 2016-07-29 -0.000505 138 5181.768 5183.184 5181.193 5181.404 14:35:00 2016-08-01 0.000070 216 5130.514 5131.933 5130.434 5131.893 14:35:00 2016-08-02 -0.000269 294 5146.608 5146.608 5143.827 5144.788 14:35:00 2016-08-03 0.000354 372 5163.854 5164.154 5162.997 5164.021 14:35:00 2016-08-04 -0.000032 450 5221.624 5221.911 5220.658 5220.789 14:35:00 2016-08-05 0.000160 528 5204.111 5204.240 5202.476 5202.865 14:35:00 2016-08-08 0.000239 . . . 3648 5282.999 5283.017 5279.008 5279.340 14:35:00 2016-10-04 0.000693 3726 5324.450 5325.375 5323.628 5324.129 14:35:00 2016-10-05 0.000060 3804 5310.945 5311.454 5310.194 5310.558 14:35:00 2016-10-06 0.000073 3882 5295.064 5295.080 5292.184 5292.327 14:35:00 2016-10-07 0.000517，os.path.isfile()和os.path.isdir()

测试文件和文件夹

假设＆＃34;路径＆＃34;是一个有效的路径，此表显示每个函数为文件和文件夹返回的内容：

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

os.path.splitext()

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

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

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 17

虽然我总是建议您使用try和except语句，但这里有一些可能性（我个人最喜欢使用os.access）：

尝试打开文件：

打开文件将始终验证文件是否存在。你可以像这样制作一个函数：
```
def File_Existence(filepath):
    f = open(filepath)
    return True
```
如果它为False，它将以无错的IOError停止执行或更高版本的Python中的OSError。要抓住异常，你必须使用try except子句。当然，你可以随时像这样使用try除了`语句（感谢hsandt 让我思考）：
```
def File_Existence(filepath):
    try:
        f = open(filepath)
    except IOError, OSError: # Note OSError is for later versions of Python
        return False

    return True
```

使用os.path.exists(path)：

这将检查您指定的内容的存在。但是，它会检查文件和目录，因此请注意您的使用方式。

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

使用os.access(path, mode)：

这将检查您是否有权访问该文件。它将检查权限。根据os.py文档，输入os.F_OK，它将检查路径是否存在。但是，使用此方法会创建一个安全漏洞，因为有人可以使用检查权限和打开文件之间的时间来攻击您的文件。您应该直接打开文件而不是检查其权限。（EAFP vs LBYP）。如果您之后不打算打开文件，只检查其存在，那么您可以使用它。

无论如何，这里：
```
>>> import os
>>> os.access("/is/a/file.txt", os.F_OK)
True
```

我还应该提到，有两种方法可以验证文件是否存在。问题可能是permission denied或no such file or directory。如果您抓到IOError，请设置IOError as e（就像我的第一个选项），然后输入print(e.args)，以便您可以确定您的问题。我希望它有所帮助！：）

Answer 18

日期：2017年12月4日

其他答案中列出了所有可能的解决方案。

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

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

此外，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 20

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

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

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 22

你可以使用 os.path.exists() :

 cout << i+1 << ".) Roll number: " << rollno[i] << "  : ";

希望能帮到你：D

Answer 23

你可以在没有try:的情况下写出Brian的建议。

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 24

如果您已将NumPy用于其他目的，则无需导入其他库，例如pathlib，os，paths等。

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

根据它的存在，这将返回true或false。

Answer 25

最简单的方法是使用

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 26

检查文件或目录是否存在

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

注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+中，可以使用pip for Python 2安装）

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

Answer 27

添加一个不会在其他答案中准确反映的轻微变化。

这将处理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 28

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

代码本身不使用try块...除了确定操作系统，从而引导您进入“Unix”风格的find或手工代理find。时序测试显示try在确定操作系统方面更快，所以我确实在那里使用了一个（但没有其他地方）。

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

而且文件......

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

这是Linux命令行环境的1行Python命令。我发现这非常好，因为我不是那么热门的Bash家伙。

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

我希望这有用。

Answer 30

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

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

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

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

注意：但是，此方法不会以任何方式锁定文件，因此您的代码可能会受到检查时间的影响＆＃34; （ TOCTTOU ）错误。

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

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

TL;DR 用一行代码检查 --- 保持简单

要检查文件或文件夹是否存在，请使用路径模块。这是单行代码（导入后）！

from pathlib import Path

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

pathlib 模块是在 Python 3.4 中引入的，所以你需要有 Python 3.4+，这个库让你的生活更轻松，而且很好用，这里有更多关于它的文档（{ {3}}）。

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

所以会变成

from pathlib import Path

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

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

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

open(inputFile, 'r')

Answer 35

import os
path = /path/to/dir

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

这在检查多个文件时很有用。或者您想要与现有列表进行集合交叉/减法。

Answer 36

检查文件是否存在，

from sys import argv

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

Answer 37

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 check-if-file-exists.py

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

成功： 文件存在

$ python3 check-if-file-exists.py

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

错误： 文件不存在

Answer 38

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

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

Answer 39

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 40

你绝对应该使用这个。

from os.path import exists

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

Answer 41

可能不需要，但是如果有，这是一些代码

import os

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

Answer 42

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

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

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

Answer 43

Python 3 在存在时使用abspath来实现操作系统不可知的检查。

os.path.abspath（path）返回规范化的绝对化版本路径名路径。在大多数平台上，这等效于调用函数normpath（）如下：normpath（join（os.getcwd（），path））。

from os.path import exists, abspath


def is_file_exists(file_path):
    try:
        abs_path = abspath(file_path)
        return exists(abs_path)
    except Exception as e:
        return False, e

Answer 44

使用以下代码：

def findfile(self, filepath)
  flag = false
  for filename in os.listdir(filepath)
    if filename == "your file name"
      flag = true
      break
    else 
      print("no file found")
  if(flag == true)
    return true
  else 
    return false

Answer 45

使用os.path.exists()获取文件是否存在。

path = '/home/ie/SachinSaga/scripts/subscription_unit_reader_file/'
def file_check_at_location(filename):
    return os.path.exists(path + str(filename).replace(' ',''))


file_name="dummy.txt"
responce = file_check_at_location(file_name)

if responce:
   print('file found at location')
else:
   print('file not found at location')

Answer 46

在这种情况下，您可以检查文件名是否存在于listdir中。如果没有，那么只是文件不存在。

import os
filename = 'D:\\Python\\Python27\\prz\\passwords\\alpa.txt'
li = filename.split('\\')
st = ''
for i in range(0, len(li)-1):
    st = st + li[i] + '\\'
dirlist = os.listdir(st)
if(li[len(li)-1] in dirlist):
    fp = open(filename, 'r')
else:
    print "FILE NOT FOUND"

这很有效。

如何检查文件是否存在而没有例外？

46 个答案:

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

更长，更迂腐的答案

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

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

其他不符合要求的选项＆＃34;没有尝试＆＃34;：

批评另一个答案：

检查文件或目录是否存在

如何检查文件是否存在而没有例外？

46 个答案:

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

更长，更迂腐的答案

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

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

其他不符合要求的选项＆＃34;没有尝试＆＃34;：

批评另一个答案：

检查文件或目录是否存在

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