Python 中如何在不抛出异常的情况下检查文件是否存在？

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

import osos.path.exists(path) # Returns whether the path (directory or file) exists or notos.path.isfile(path) # Returns whether the file exists or not

使用#0检查文件和目录：

import os.pathos.path.exists(file_path)

使用#0仅检查文件（注意：如下符号链接）：

os.path.isfile(file_path)

如果您检查的原因是为了执行类似于if file_exists: open_it()的操作，那么在尝试打开它时使用try更安全。检查然后打开可能会在检查和尝试打开之间删除或移动文件或其他内容。

如果您不打算立即打开文件，您可以使用#0

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

import os.pathos.path.isfile(fname)

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

从Python 3.4开始，#0模块提供了一种面向对象的方法（在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

你也可以在try块中使用resolve(strict=True)：

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

此外，os.access()：

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

R_OK、W_OK和X_OK是测试权限的标志（doc）。

与#0不同，#1将返回目录的True。因此，根据您只想要普通文件还是目录，您将使用isfile()或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

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

不要相信我的话。这个理论有很多支持。这里有几个：

• 风格：部分“处理异常条件”这些课程笔记为软件设计（2007）
• 避免竞争条件

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

try:# http://effbot.org/zone/python-with-statement.htm# 'with' is safer to open a filewith open('whatever.txt') as fh:# Do something with 'fh'except IOError as e:print("({})".format(e))

输出将是：

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

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

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

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

使用#0和#1：

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

这是检查文件是否存在的最简单方法。只是因为检查时文件存在，而不是保证需要打开它时它会在那里。

import osfname = "foo.txt"if os.path.isfile(fname):print("file does exist at this time")else:print("no such file exists at this time")

它看起来没有一个有意义的功能差异try/除了和isfile()，所以你应该使用哪一个是有意义的。

如果你想读一个文件，如果它存在，做

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

但是如果你只是想重命名一个文件，如果它存在，因此不需要打开它，做

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

如果你想写一个文件，如果它不存在，做

# Python 2if not os.path.isfile(filepath):f = open(filepath, 'w')
# Python 3: x opens for exclusive creation, failing if the file already existstry:f = open(filepath, 'wx')except IOError:print 'file already exists'

如果您需要文件锁定，那是另一回事。

python3.4+有一个面向对象的path模块：路径库。使用这个新模块，你可以检查一个文件是否存在，如下所示：

import pathlibp = 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 stuffexcept 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 versionsimport pathlib2 as pathlib

你可以写布赖恩的建议没有try:。

from contextlib import suppress
with suppress(IOError), open('filename'):process()

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

from contextlib import contextmanager
@contextmanagerdef suppress(*exceptions):try:yieldexcept exceptions:pass

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

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

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

with open('somefile', 'xt') as f: # Using the x-flag, Python 3.3 and abovef.write('Hello\n')
if not os.path.exists('somefile'):with open('somefile', 'wt') as f:f.write("Hello\n")else:print('File already exists!')

注意：这会找到一个文件或一个具有给定名称的目录。

要检查文件是否存在，

from sys import argv
from os.path import existsscript, filename = argvtarget = open(filename)print "file exists: %r" % exists(filename)

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

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

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

1. 尝试打开文件：

   打开文件将始终验证文件的存在。您可以像这样创建一个函数：

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

   如果它是False，它将停止执行，并返回一个未处理的IOError或更高版本的Python中的OSError。要捕获异常，你必须使用try除了从句。当然，你总是可以像这样使用try除了语句（感谢hsandt）让我思考：

   def File_Existence(filepath):try:f = open(filepath)except IOError, OSError: # Note OSError is for later versions of Pythonreturn 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! :)

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

引发异常被认为是可以接受的，而Pythonic，程序中的流控制方法。考虑处理缺失带有IOError的文件。在这种情况下，IOError异常将是如果文件存在但用户没有读取权限，则引发。

来源：使用Python：如何检查文件是否存在

用途：

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可以更轻松地导航和执行操作系统的标准操作。

另请参阅如何无异常地检查文件是否存在？。

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

import os.path
def isReadableFile(file_path, file_name):full_path = file_path + "/" + file_nametry:if not os.path.exists(file_path):print "File path is invalid."return Falseelif not os.path.isfile(full_path):print "File does not exist."return Falseelif not os.access(full_path, os.R_OK):print "File cannot be read."return Falseelse:print "File can be read."return Trueexcept 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)

如何在不使用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、#0反向移植Pathlib模块，或者从os.path模块检查isfile：

>>> 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开始可用，请在pathlib中使用新的Path对象。请注意，.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 pointingto 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 pointingto 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，您只需尝试读取您的文件，期望它在那里，如果没有，您将捕获异常并执行任何有意义的回退行为。

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

竞争条件很难调试，因为它们可能导致程序失败的窗口非常小。

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

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

Python 3.4为我们提供了#0上下文管理器（以前是#1上下文管理器），它用更少的行在语义上完全相同，同时（至少表面上）满足原始请求以避免try语句：

from contextlib import suppressfrom 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，但没有try会比使用try更冗长。我相信这实际上是Python中任何级别都不使用#1的唯一答案可以应用于Python 3.4之前，因为它使用了上下文管理器：

class suppress(object):def __init__(self, *exceptions):self.exceptions = exceptionsdef __enter__(self):return selfdef __exit__(self, exc_type, exc_value, traceback):if exc_type is not None:return issubclass(exc_type, self.exceptions)

也许更容易尝试：

from contextlib import contextmanager
@contextmanagerdef suppress(*exceptions):try:yieldexcept exceptions:pass

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

isfile

import osos.path.isfile(path)

从文档：

os.path.isfile(path)

如果path是一个现有的常规文件，则返回Trueislink()和isfile()对于同一路径都可以为true。

但是如果你检查这个函数的来源，你会发现它实际上使用了一个try语句：

# This follows symbolic links, so both islink() and isdir() can be true# for the same path on systems that support symlinksdef isfile(path):"""Test whether a path is a regular file"""try:st = os.stat(path)except os.error:return Falsereturn stat.S_ISREG(st.st_mode)

>>> OSError is os.errorTrue

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

如果你打算对文件做些什么，我建议直接用try尝试它——除了避免竞争条件：

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

os.access

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

import osos.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.raiseelse:with fp:return fp.read()

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

另一个答案的批评：

另一个答案是关于os.access的：

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

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

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

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

这是一个用于Linux命令行环境的单行Python命令。我发现这个非常方便，因为我不是那么热的Bash家伙。

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

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

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

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

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

我是一个包的作者，这个包已经存在了大约10年，它有一个直接解决这个问题的功能。基本上，如果你在非Windows系统上，它使用Popen访问find。然而，如果你在Windows上，它会使用高效的文件系统步行者复制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 forroot: path string of top-level directory to searchrecurse: if True, recurse down from root directorytype: 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

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

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

再增加一个细微的变化，这在其他答案中没有完全反映出来。

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

def file_exists(file_path):if not file_path:return Falseelif not os.path.isfile(file_path):return Falseelse:return True

根据Shahbaz的建议添加变体

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

根据Peter Wood的建议添加变体

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

测试os.path.isfile()、os.path.isdir()和os.path.exists()的文件和文件夹

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

您还可以使用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 .docxTrue

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

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

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

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

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

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

尽管几乎所有可能的方法都已在（至少一个）现有答案中列出（例如添加了python3.4特定内容），但我会尝试将所有内容组合在一起。

说明：我要发布的每一段python标准库代码都属于版本3.5.3。

问题陈述：

1. 检查文件（有争议：还有文件夹（“特殊”文件）？）存在
2. 不要使用<强>尝试/<强>除/<强>其他/<强>终于块

可能的解决方案：

1. [Python 3]：os.path.存在（path）（还要检查其他函数族成员，如os.path.isfile、os.path.isdir、os.path.lexists是否有略微不同的行为）

    os.path.exists(path)

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

   很好，但如果遵循导入树：

   • os.path-posixpath.py（ntpath.py）

     • genericpath.py，第1行

         def exists(path):"""Test whether a path exists.  Returns False for broken symbolic links"""try:st = os.stat(path)except os.error:return Falsereturn True

   它只是[Python 3]： os.stat（路径，*，dir_fd=无，follow_symlinks=True）周围的<强>尝试/<强>除块。所以，你的代码是<强>尝试/<强>除免费的，但是在帧堆栈的较低位置有（至少）一个这样的块。这也适用于其他函数（包括os.path.isfile）。

   1.1.[Python 3]： Path.is_file（）

   • 这是处理路径的更高级（和更多Pythonic）的方式，但

   • 在引擎盖下，它做了完全同样的事情（pathlib.py，行~#1330）：

       def is_file(self):"""Whether this path is a regular file (also True for symlinks pointingto 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 exampleswallowed_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 osimport stat
       
       def isfile_seaman(path):  # Dummy funcresult = Falsewith Swallow():result = stat.S_ISREG(os.stat(path).st_mode)return result

   • 使用[Python 3]： contextlib。抑制（*异常）-这是特别是为选择性抑制异常而设计的

   
   但是，它们似乎是<强>尝试/<强>除/<强>其他/<强>终于块的包装器，如[Python 3]：with语句所述：

   这允许封装常见的尝试…除了…最后使用模式以方便重用。

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

   • [Python 3]： os.listdir（path='.'）（或Python v3.5+上的[Python 3]： os.scandir（path='.'），backport：[PyPI]： scandir）

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

       • 类unix：[man7]：开放（3）/[man7]： READDIR（3）/[man7]：关闭（3）
       • windows：[MS. Docs]： FindFirstFileW函数/[MS. Docs]： FindNextFileW函数/[MS. Docs]： Find关闭函数

       via[GitHub]： Python/CPython-（master）cpython/Modules/posxmod. c

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

   • [Python 3]： os.walk（top， topdown=True， onerror=无，关注链接=False）

     • 它使用os.listdir（可用时为os.scandir）

   • [Python 3]： Globb.iglob（路径名，*，递归=False）（或其前身：glob.glob）

     • 看起来不像遍历函数本身（至少在某些情况下），但它仍然使用os.listdir

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

4. [Python 3]： os.access（路径，模式，*，dir_fd=无，effective_ids=False，follow_symlinks=True），其行为接近os.path.exists（实际上它更宽，主要是因为2^nd参数）

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

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

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

   由于我也在C中工作，我也使用这个方法，因为在引擎盖下，它调用原生APIs（再次通过"${PYTHON_SRC_DIR}/Modules/Posix. c"），但它也为可能的用户错误打开了大门，而且它不像其他变体那样Pythonic。所以，正如@AaronHall正确指出的那样，除非你知道自己在做什么，否则不要使用它：

   • 类unix：[man7]：访问（2）（！！！注意安全漏洞的用法可能会引入的注释！！！）
   • windows：[MS. Docs]： GetFileAtbuntesW函数

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

   （Windows特定）：由于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，但这只是为了清晰（它的值是）
   • 我使用_waccess，以便相同的代码适用于python3和python2（尽管它们之间存在Unicode相关的差异）
   • 虽然这针对一个非常具体的领域，在之前的回答中没有提到

   
   Linux（Ubuntu（16x64））对应：

   Python 3.5.2 (default, Nov 17 2016, 17:05:23)

    [GCC 5.4.0 20160609] on linuxType "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构造函数（#0）。根据[man7]：（3）：

     如果文件名为NULL，则返回的句柄是主句柄程序。当给定dlsym（）时，此句柄会导致搜索主程序中的符号，后跟加载的所有共享对象程序启动，然后dlopen（）加载的所有共享对象标志RTLD_GLOBAL.

   • 主（当前）程序（python）链接到libc，因此它的符号（包括访问）将被加载

   • 这必须小心处理，因为像主要、Py_Main和（所有）其他函数都是可用的；调用它们可能会产生灾难性的影响（对当前程序）

   • 这并不适用于windows（但这没什么大不了的，因为msvcrt.dll位于"%System Root%\System 32"中，默认情况下位于%路径%中）。我想更进一步，在windows上复制这种行为（并提交补丁），但事实证明，[MS. Docs]： GetProcAddress函数只“看到”出口个符号，所以除非有人将主可执行文件中的函数声明为__declspec(dllexport)（为什么定期的人会这样做？），主程序是可加载的，但它几乎不可用

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

   
   一个例子是（再次，windows特定）[GitHub]： mhammond/pywin32-Python for Windows（pywin32）扩展，它是WINAPI上的python包装器。

   但是，因为这更像是一个解决方案，我在这里停下来。

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

   • windows：

     (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

   • 类unix（Linux（ubuntu））：

     [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

底线是：

• 做使用<强>尝试/<强>除/<强>其他/<强>终于块，因为它们可以防止你遇到一系列讨厌的问题。我能想到的一个反例是性能：这样的块成本很高，所以尽量不要把它们放在应该每秒运行数十万次的代码中（但由于（在大多数情况下）它涉及磁盘访问，所以情况并非如此）。

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

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

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

日期：2017-12-04

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

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

import os
os.path.isfile('~/file.md')  # Returns True if exists, else False
# Additionally, check a directoryos.path.isdir('~/folder')  # Returns True if the folder exists, else False
# Check either a directory or a fileos.path.exists('~/file')

我做了一个详尽的备忘单供您参考：

# os.path methods in exhaustive cheat sheet{'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']}

检查文件或目录是否存在

你可以遵循这三种方法：

1.使用isfile（）

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

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

2.使用存在

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

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

3.pathlib.Path方法（包含在Python 3+中，可与Python 2的pip一起安装）

from pathlib import PathPath(filename).exists()

用途：

import os
# For testing purposes the arguments defaulted to the current folder and file.# returns True if file founddef 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使用正确的目录分隔符进行文件检查。

'路径'对象的存在（）和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")

输出：

$python3check-if-file-exists.py

输入要找到的文件的路径：/用户/macuser1/堆栈溢出/index.html

成功：文件存在

$python3check-if-file-exists.py

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

错误：文件不存在

使用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..')

太长别读
答案是：使用#0模块

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+。这个库在处理文件和文件夹时让您的生活变得更加轻松，而且它很好用。这里有更多关于它的留档：Pathlib-面向对象的文件系统路径。

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

它将成为：

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.

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

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

如果是，则返回true，如果不是，则返回false。

这就是我在一个文件夹中找到文件列表（在这些图像中）并在一个文件夹（带有子文件夹）中搜索它的方式：

# This script concatenates JavaScript files into a unified JavaScript file to reduce server round-trips
import osimport stringimport mathimport ntpathimport sys
#import pyodbc
import gzipimport shutil
import hashlib
# BUF_SIZE is totally arbitrary, change for your app!BUF_SIZE = 65536  # Let’s read stuff in 64 kilobyte chunks
# Iterate over all JavaScript files in the folder and combine themfilenames = []shortfilenames = []
imgfilenames = []imgshortfilenames = []
# Get a unified path so we can stop dancing with user paths.# Determine where files are on this machine (%TEMP% directory and application installation directory)if '.exe' in sys.argv[0]: # if getattr(sys, 'frozen', False):RootPath = os.path.abspath(os.path.join(__file__, "..\\"))
elif __file__:RootPath = os.path.abspath(os.path.join(__file__, "..\\"))
print ("\n storage of image files RootPath: %s\n" %RootPath)
FolderPath = "D:\\TFS-FARM1\\StoneSoup_STS\\SDLC\\Build\\Code\\StoneSoup_Refactor\\StoneSoupUI\\Images"print ("\n storage of image files in folder to search: %s\n" %FolderPath)
for root, directories, filenames2 in os.walk(FolderPath):for filename in filenames2:fullname = os.path.join(root, filename)filenames.append(fullname)shortfilenames.append(filename)
for i, fname in enumerate(shortfilenames):print("%s - %s" % (i+1, fname))
for root, directories, filenames2 in os.walk(RootPath):for filename in filenames2:fullname = os.path.join(root, filename)imgfilenames.append(fullname)imgshortfilenames.append(filename)
for i, fname in enumerate(imgshortfilenames):print("%s - %s" % (i+1, fname))
for i, fname in enumerate(imgshortfilenames):if fname in shortfilenames:print("%s - %s exists" % (i+1, fname))else:print("%s - %s ABSENT" % (i+1, fname))

import os
filename = "myfile.txt"
if os.path.exists(filename):print(f"The file {filename} exists.")else:print(f"The file {filename} does not exist.")

请注意，此方法仅检查文件是否存在，而不检查文件是否可访问或它是否是常规文件（即不是目录或符号链接等）。要检查这些东西，您可以分别使用os.access（）和os.path.isfile（）方法。

有关os.path模块及其提供的方法的更多信息，您可以查看官方Python留档：https://docs.python.org/3/library/os.path.html。