这个问题的答案是社区的努力。编辑现有答案以改进这篇文章。它目前不接受新的答案或交互。
如何在 Python 中列出目录的所有文件并将它们添加到 list？
os.listdir() 返回目录中的所有内容，包括文件和目录。
os.path 的 isfile() 可用于仅列出文件：
from os import listdir
from os.path import isfile, join
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
或者，os.walk() 为它访问的每个目录生成两个列表——一个用于文件，一个用于dirs .如果您只想要顶级目录，则可以在第一次生成时中断：
from os import walk
f = []
for (dirpath, dirnames, filenames) in walk(mypath):
f.extend(filenames)
break
或者，更短：
from os import walk
filenames = next(walk(mypath), (None, None, []))[2] # [] if no file
我更喜欢使用 glob 模块，因为它可以进行模式匹配和扩展。
import glob
print(glob.glob("/home/adam/*"))
它直观地进行模式匹配
import glob
# All files and directories ending with .txt and that don't begin with a dot:
print(glob.glob("/home/adam/*.txt"))
# All files and directories ending with .txt with depth of 2 folders, ignoring names beginning with a dot:
print(glob.glob("/home/adam/*/*.txt"))
它将返回一个包含查询文件和目录的列表：
['/home/adam/file1.txt', '/home/adam/file2.txt', .... ]
请注意，glob 会忽略以点 . 开头的文件和目录，因为它们被视为隐藏文件和目录，除非该模式类似于 .*。
使用 glob.escape 转义不属于模式的字符串：
print(glob.glob(glob.escape(directory_name) + "/*.txt"))
/home/user/foo/bar/hello.txt，如果在目录 foo 中运行，则 glob("bar/*.txt") 将返回 bar/hello.txt。在某些情况下，您实际上确实想要完整（即绝对）路径；对于这些情况，请参阅 stackoverflow.com/questions/51520/…
glob.glob("*") 会。
在当前目录中列出
使用 os 模块中的 listdir，您可以获得当前目录中的文件和文件夹
import os
arr = os.listdir()
在目录中查找
arr = os.listdir('c:\\files')
使用 glob，您可以指定要像这样列出的文件类型
import glob
txtfiles = []
for file in glob.glob("*.txt"):
txtfiles.append(file)
或者
mylist = [f for f in glob.glob("*.txt")]
获取当前目录中唯一文件的完整路径
import os
from os import listdir
from os.path import isfile, join
cwd = os.getcwd()
onlyfiles = [os.path.join(cwd, f) for f in os.listdir(cwd) if
os.path.isfile(os.path.join(cwd, f))]
print(onlyfiles)
['G:\\getfilesname\\getfilesname.py', 'G:\\getfilesname\\example.txt']
使用 os.path.abspath 获取完整路径名
你得到完整的路径作为回报
import os
files_path = [os.path.abspath(x) for x in os.listdir()]
print(files_path)
['F:\\documenti\applications.txt', 'F:\\documenti\collections.txt']
Walk：遍历子目录
os.walk 返回根目录、目录列表和文件列表，这就是为什么我在 for 循环中将它们解压缩到 r、d、f 中的原因；然后，它会在根目录的子文件夹中查找其他文件和目录，依此类推，直到没有子文件夹。
import os
# Getting the current work directory (cwd)
thisdir = os.getcwd()
# r=root, d=directories, f = files
for r, d, f in os.walk(thisdir):
for file in f:
if file.endswith(".docx"):
print(os.path.join(r, file))
在目录树中向上
# Method 1
x = os.listdir('..')
# Method 2
x= os.listdir('/')
使用 os.listdir() 获取特定子目录的文件
import os
x = os.listdir("./content")
os.walk('.') - 当前目录
import os
arr = next(os.walk('.'))[2]
print(arr)
>>> ['5bs_Turismo1.pdf', '5bs_Turismo1.pptx', 'esperienza.txt']
next(os.walk('.')) 和 os.path.join('dir', 'file')
import os
arr = []
for d,r,f in next(os.walk("F:\\_python")):
for file in f:
arr.append(os.path.join(r,file))
for f in arr:
print(files)
>>> F:\\_python\\dict_class.py
>>> F:\\_python\\programmi.txt
接下来……走
[os.path.join(r,file) for r,d,f in next(os.walk("F:\\_python")) for file in f]
>>> ['F:\\_python\\dict_class.py', 'F:\\_python\\programmi.txt']
os.walk
x = [os.path.join(r,file) for r,d,f in os.walk("F:\\_python") for file in f]
print(x)
>>> ['F:\\_python\\dict.py', 'F:\\_python\\progr.txt', 'F:\\_python\\readl.py']
os.listdir() - 只获取 txt 文件
arr_txt = [x for x in os.listdir() if x.endswith(".txt")]
使用 glob 获取文件的完整路径
from path import path
from glob import glob
x = [path(f).abspath() for f in glob("F:\\*.txt")]
使用 os.path.isfile 避免列表中的目录
import os.path
listOfFiles = [f for f in os.listdir() if os.path.isfile(f)]
使用 Python 3.4 中的 pathlib
import pathlib
flist = []
for p in pathlib.Path('.').iterdir():
if p.is_file():
print(p)
flist.append(p)
使用 list comprehension：
flist = [p for p in pathlib.Path('.').iterdir() if p.is_file()]
在 pathlib.Path() 中使用 glob 方法
import pathlib
py = pathlib.Path().glob("*.py")
使用 os.walk 获取所有且唯一的文件：仅检查返回的第三个元素，即文件列表
import os
x = [i[2] for i in os.walk('.')]
y=[]
for t in x:
for f in t:
y.append(f)
仅获取目录中带有下一个的文件：仅返回根文件夹中的文件
import os
x = next(os.walk('F://python'))[2]
仅使用 next 获取目录并进入目录，因为在 [1] 元素中只有文件夹
import os
next(os.walk('F://python'))[1] # for the current dir use ('.')
>>> ['python3','others']
使用 walk 获取所有 subdir 名称
for r,d,f in os.walk("F:\\_python"):
for dirs in d:
print(dirs)
os.scandir() 来自 Python 3.5 及更高版本
import os
x = [f.name for f in os.scandir() if f.is_file()]
# Another example with `scandir` (a little variation from docs.python.org)
# This one is more efficient than `os.listdir`.
# In this case, it shows the files only in the current directory
# where the script is executed.
import os
with os.scandir() as i:
for entry in i:
if entry.is_file():
print(entry.name)
[f for f in glob.glob("*.txt")] 等价于 glob.glob("*.txt") 并且保证在这篇文章中没有额外的部分。它也非常罗嗦，并且有很多间距。可以通过添加解释或指出差异而不是列出另一个变体来进行改进。
import os
os.listdir("somedirectory")
将返回“somedirectory”中所有文件和目录的列表。
glob.glob 返回的完整路径相比，这将返回文件的相对路径
os.listdir() 总是返回仅仅是文件名（不是相对路径）。 glob.glob() 返回的内容由输入模式的路径格式驱动。
仅获取文件列表（无子目录）的单行解决方案：
filenames = next(os.walk(path))[2]
或绝对路径名：
paths = [os.path.join(path, fn) for fn in next(os.walk(path))[2]]
import os，则只有一条线。对我来说似乎不如 glob() 简洁。
glob() 会将其视为文件。您的方法会将其视为目录。
从目录及其所有子目录中获取完整文件路径
import os
def get_filepaths(directory):
"""
This function will generate the file names in a directory
tree by walking the tree either top-down or bottom-up. For each
directory in the tree rooted at directory top (including top itself),
it yields a 3-tuple (dirpath, dirnames, filenames).
"""
file_paths = [] # List which will store all of the full filepaths.
# Walk the tree.
for root, directories, files in os.walk(directory):
for filename in files:
# Join the two strings in order to form the full filepath.
filepath = os.path.join(root, filename)
file_paths.append(filepath) # Add it to the list.
return file_paths # Self-explanatory.
# Run the above function and store its results in a variable.
full_file_paths = get_filepaths("/Users/johnny/Desktop/TEST")
我在上述函数中提供的路径包含 3 个文件——其中两个在根目录中，另一个在名为“SUBFOLDER”的子文件夹中。您现在可以执行以下操作：
print full_file_paths 将打印列表： ['/Users/johnny/Desktop/TEST/file1.txt', '/Users/johnny/Desktop/TEST/file2.txt', '/Users/johnny/Desktop/TEST/SUBFOLDER /file3.dat']
['/Users/johnny/Desktop/TEST/file1.txt', '/Users/johnny/Desktop/TEST/file2.txt', '/Users/johnny/Desktop/TEST/SUBFOLDER/file3.dat']
如果您愿意，您可以打开并阅读内容，或者只关注扩展名为“.dat”的文件，如下面的代码所示：
for f in full_file_paths:
if f.endswith(".dat"):
print f
/Users/johnny/Desktop/TEST/SUBFOLDER/file3.dat
从 3.4 版开始，有内置的 iterators 比 os.listdir() 更有效：
pathlib：3.4 版中的新功能。
>>> import pathlib
>>> [p for p in pathlib.Path('.').iterdir() if p.is_file()]
根据 PEP 428，pathlib 库的目的是提供一个简单的类层次结构来处理文件系统路径和用户对其执行的常见操作。
os.scandir()：3.5 版中的新功能。
>>> import os
>>> [entry for entry in os.scandir('.') if entry.is_file()]
请注意，os.walk() 使用 os.scandir() 而不是 3.5 版本中的 os.listdir()，它的速度根据 PEP 471 提高了 2-20 倍。
让我也推荐阅读下面 ShadowRanger 的评论。
list 的解决方案。如果愿意，可以使用 p.name 而不是第一个 p。
pathlib.Path() 实例，因为它们有许多有用的方法，我不想浪费。您还可以在它们上调用 str(p) 以获取路径名称。
list（因此您不会从惰性迭代中受益），os.scandir 解决方案将比 os.listdir 更有效，因为 os.scandir } 使用操作系统提供的 API，在迭代过程中免费为您提供 is_file 信息，根本不需要每个文件往返磁盘来stat它们（在 Windows 上，DirEntry 让您完成 stat信息免费，在 *NIX 系统上，它需要 stat 来获取 is_file、is_dir 等之外的信息，但为了方便起见，DirEntry 缓存在第一个 stat 上）。
entry.name 仅获取文件名，或使用 entry.path 获取其完整路径。没有更多的 os.path.join() 到处都是。
初步说明
尽管问题文本中的文件和目录术语有明显的区别，但有些人可能会争辩说目录实际上是特殊文件
语句：“目录的所有文件”可以用两种方式解释： 仅所有直接（或级别 1）后代 整个目录树中的所有后代（包括子目录中的后代）
仅限所有直接（或 1 级）后代
整个目录树中的所有后代（包括子目录中的后代）
当问题被问到时，我认为 Python 2 是 LTS 版本，但是代码示例将由 Python 3(.5) 运行（我将尽可能保持它们与 Python 2 兼容；此外，任何属于我要发布的 Python 来自 v3.5.4 - 除非另有说明）。这与问题中的另一个关键字相关：“将它们添加到列表中”：在 Python 2.2 之前的版本中，序列（可迭代对象）主要由列表（元组、集合、...）表示。在 Python 2.2 中，生成器（[Python.Wiki]：生成器）- 由 [Python 3]：yield 语句提供）- 被引入。随着时间的推移，对于返回/使用列表的函数，生成器对应物开始出现在 Python 3 中，生成器是默认行为不确定返回列表是否仍然是强制性的（或者生成器也会这样做），但是将生成器传递给列表构造函数，将使用它创建一个列表（并使用它）。下面的示例说明了 [Python 3] 上的差异： map(function, iterable, ...) >>> import sys >>> sys.version '2.7.10 (default, Mar 8 2016, 15:02:46) [MSC v.1600 64 bit (AMD64)]' >>> m = map(lambda x: x, [1, 2, 3]) # 只是一个虚拟 lambda 函数 >>> m, type(m) ([1 , 2, 3],
在 Python 2.2 之前的版本中，序列（可迭代对象）主要由列表（元组、集合、...）表示
在 Python 2.2 中，引入了生成器的概念（[Python.Wiki]: Generators）——由 [Python 3]: The yield statement 提供）——被引入。随着时间的流逝，生成器对应物开始出现在返回/使用列表的函数中
在 Python 3 中，生成器是默认行为
不确定返回列表是否仍然是强制性的（或者生成器也会这样做），但是将生成器传递给列表构造函数，会从中创建一个列表（并使用它）。下面的示例说明了 [Python 3] 上的差异： map(function, iterable, ...)
这些示例将基于具有以下结构的名为 root_dir 的目录（此示例适用于 Win，但我也在 Lnx 上使用相同的树）： E:\Work\Dev\StackOverflow\q003207219>tree /f " root_dir" 卷工作卷序列号的文件夹路径列表是 00000029 3655:6FED E:\WORK\DEV\STACKOVERFLOW\Q003207219\ROOT_DIR ¦ file0 ¦ file1 ¦ +---dir0 ¦ +---dir00 ¦ ¦ ¦ file000 ¦ ¦ ¦ ¦ ¦ +---dir000 ¦ ¦ file0000 ¦ ¦ ¦ +---dir01 ¦ ¦ file010 ¦ ¦ file011 ¦ ¦ ¦ +---dir02 ¦ +---dir020 ¦ +---dir0200 +---dir1 ¦ file10 ¦ file11 ¦ file12 ¦ +---dir2 ¦ ¦ file20 ¦ ¦ ¦ +---dir20 ¦ file200 ¦ +---dir3
解决方案
程序化方法：
[Python 3]: os.listdir(path='.') 返回一个列表，其中包含路径给定的目录中条目的名称。该列表按任意顺序排列，不包括特殊条目“.”。 and '..' ... >>> import os >>> root_dir = "root_dir" # 相对于当前目录的路径 (os.getcwd()) >>> >>> os.listdir(root_dir) # 列出所有root_dir 中的项目 ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1'] >>> >>> [os.listdir(root_dir) 中的项目如果 os.path。 isfile(os.path.join(root_dir, item))] # 过滤项目，只保留文件（去除目录） ['file0', 'file1'] 一个更详细的例子（code_os_listdir.py）：import os from pprint import pformat def _get_dir_content(path, include_folders, recursive): entries = os.listdir(path) for entry in entries: entry_with_path = os.path.join(path, entry) if os.path.isdir(entry_with_path): if include_folders: yield entry_with_path if recursive: for sub_entry in _get_dir_content(entry_with_path, include_folders, recursive): yield sub_entry else: yield entry_with_path def get_dir_content(path, include_folders=True, recursive=True, prepend_folder_name=True): path_len = len(path) + len(os .path.sep) 用于 _get_dir_content(path, i nclude_folders, recursive): yield item if prepend_folder_name else item[path_len:] def _get_dir_content_old(path, include_folders, recursive): entries = os.listdir(path) ret = list() for entry in entries: entry_with_path = os.path.join (path, entry) if os.path.isdir(entry_with_path): if include_folders: ret.append(entry_with_path) if recursive: ret.extend(_get_dir_content_old(entry_with_path, include_folders, recursive)) else: ret.append(entry_with_path) return ret def get_dir_content_old(path, include_folders=True, recursive=True, prepend_folder_name=True): path_len = len(path) + len(os.path.sep) return [item if prepend_folder_name else item[path_len:] for item in _get_dir_content_old(path , include_folders, recursive)] def main(): root_dir = "root_dir" ret0 = get_dir_content(root_dir, include_folders=True, recursive=True, prepend_folder_name=True) lret0 = list(ret0) print(ret0, len(lret0), pformat (lret0)) ret1 = get_dir_content_old(root_dir, include_folders=False, recursive=True, prepe nd_folder_name=False) print(len(ret1), pformat(ret1)) if __name__ == "__main__": main() 注意：有两种实现： 一种使用生成器（当然这里看起来没用，因为我立即转换结果到一个列表）经典的（函数名称以_old结尾）使用递归（进入子目录）对于每个实现都有两个函数：一个以下划线（_）开头：“私有”（不应该是直接调用） - 完成所有工作 公共的（之前的包装器）：它只是从返回的条目中剥离初始路径（如果需要）。这是一个丑陋的实现，但这是我目前唯一能想到的想法。就性能而言，生成器通常要快一点（考虑到创建和迭代时间），但我没有在递归函数中测试它们，而且我在内部生成器的函数内部进行迭代 - 不知道使用参数来获得不同的结果对性能有多友好 输出：(py35x64_test) E:\Work\Dev\StackOverflow\q003207219>"e:\Work \Dev\VEnvs\py35x64_test\Scripts\python.exe" "code_os_listdir.py"
[Python 3]: os.scandir(path='.') (Python 3.5+, backport: [PyPI]: scandir) 返回 os.DirEntry 对象的迭代器，对应于 path 给定的目录中的条目。条目以任意顺序产生，特殊条目“。”和 '..' 不包括在内。使用 scandir() 代替 listdir() 可以显着提高还需要文件类型或文件属性信息的代码的性能，因为如果操作系统在扫描目录时提供了这些信息，os.DirEntry 对象就会公开这些信息。所有 os.DirEntry 方法都可以执行系统调用，但 is_dir() 和 is_file() 通常只需要对符号链接进行系统调用； os.DirEntry.stat() 在 Unix 上总是需要一个系统调用，但在 Windows 上只需要一个用于符号链接。 >>> import os >>> root_dir = os.path.join(".", "root_dir") # 显式添加当前目录 >>> root_dir '.\\root_dir' >>> >>> scandir_iterator = os.scandir (root_dir) >>> scandir_iterator
[Python 3]: os.walk(top, topdown=True, onerror=None, followlinks=False) 通过自上而下或自下而上遍历树来生成目录树中的文件名。对于以目录 top 为根的树中的每个目录（包括 top 本身），它会产生一个 3 元组（dirpath、dirnames、filenames）。 >>> import os >>> root_dir = os.path.join(os.getcwd(), "root_dir") # 指定完整路径 >>> root_dir 'E:\\Work\\Dev\\StackOverflow\\q003207219 \\root_dir' >>> >>> walk_generator = os.walk(root_dir) >>> root_dir_entry = next(walk_generator) # 第一个条目对应于根目录（作为参数传递） >>> root_dir_entry ('E:\ \Work\\Dev\\StackOverflow\\q003207219\\root_dir', ['dir0', 'dir1', 'dir2', 'dir3'], ['file0', 'file1']) >>> >>> root_dir_entry[1] + root_dir_entry[2] # 在单个列表中显示目录和文件（直接后代） ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1'] >>> >>> [os.path.join(root_dir_entry[0], item) for item in root_dir_entry[1] + root_dir_entry[2]] # 按完整路径显示上一个列表中的所有条目 ['E:\\Work \\Dev\\StackOverflow\\q003207219\\root_dir\\dir0', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir1', 'E:\\Work\\Dev\ \StackOverflow\\q003207219\\root_dir\\dir2', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir3', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\file0', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\file1'] >>> > >> for entry in walk_generator: # 显示其余元素（对应每个子目录） ... print(entry) ... ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\ \dir0', ['dir00', 'dir01', 'dir02'], []) ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir00', [' dir000'], ['file000']) ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir00\\dir000', [], ['file0000']) ( 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir01', [], ['file010', 'file011']) ('E:\\Work\\Dev\ \StackOverflow\\q003207219\\root_dir\\dir0\\dir02', ['dir020'], []) ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir02 \\dir020', ['dir0200'], []) ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir02\\dir020\\dir0200', [], []) ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir1', [], ['file10', 'file11', 'file12']) ('E:\\禾rk\\Dev\\StackOverflow\\q003207219\\root_dir\\dir2', ['dir20'], ['file20']) ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\ \dir2\\dir20', [], ['file200']) ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir3', [], []) 注意：在场景，它使用 os.scandir （旧版本上为 os.listdir） 它通过在子文件夹中重复来完成繁重的工作
[Python 3]: glob.glob(pathname, *, recursive=False) ([Python 3]: glob.iglob(pathname, *, recursive=False)) 返回匹配路径名的可能为空的路径名列表，其中必须是包含路径规范的字符串。路径名可以是绝对的（如 /usr/src/Python-1.5/Makefile）或相对的（如 ../../Tools/*/*.gif），并且可以包含 shell 样式的通配符。结果中包含损坏的符号链接（如在 shell 中）。 ... 在 3.5 版更改：支持使用“**”的递归 glob。 >>> import glob, os >>> wildcard_pattern = "*" >>> root_dir = os.path.join("root_dir", wildcard_pattern) # 匹配每个文件/目录名 >>> root_dir 'root_dir\\*' > >> >>> glob_list = glob.glob(root_dir) >>> glob_list ['root_dir\\dir0', 'root_dir\\dir1', 'root_dir\\dir2', 'root_dir\\dir3', 'root_dir\\ file0', 'root_dir\\file1'] >>> >>> [item.replace("root_dir" + os.path.sep, "") for item in glob_list] # 去掉开头的目录名和路径分隔符['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1'] >>> >>> 进入 glob.iglob(root_dir + "*", recursive=True): . .. 打印（条目） ... root_dir\ root_dir\dir0 root_dir\dir0\dir00 root_dir\dir0\dir00\dir000 root_dir\dir0\dir00\dir000\file0000 root_dir\dir0\dir00\file000 root_dir\dir0\dir01 root_dir\dir0 \dir01\file010 root_dir\dir0\dir01\file011 root_dir\dir0\dir02 root_dir\dir0\dir02\dir020 root_dir\dir0\dir02\dir020\dir0200 root_dir\dir1 root_dir\dir1\file10 root_dir\dir1\file11 root_dir\dir1\file12 root_dir\dir2 root_dir\dir2\dir20 r oot_dir\dir2\dir20\file200 root_dir\dir2\file20 root_dir\dir3 root_dir\file0 root_dir\file1 注意： 使用 os.listdir 对于大树（特别是如果启用递归），首选 iglob 允许基于名称进行高级过滤（由于通配符）
[Python 3]: class pathlib.Path(*pathsegments) (Python 3.4+, backport: [PyPI]: pathlib2) >>> import pathlib >>> root_dir = "root_dir" >>> root_dir_instance = pathlib.Path(root_dir) >>> root_dir_instance WindowsPath('root_dir') >>> root_dir_instance.name 'root_dir' >>> root_dir_instance.is_dir() True >>> >>> [item.name for item in root_dir_instance.glob("*")] # 通配符搜索所有直系后代 ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1'] >>> >>> [os.path.join(item.parent.name , item.name) for item in root_dir_instance.glob("*") if not item.is_dir()] # 仅显示文件的路径（包括父路径） ['root_dir\\file0', 'root_dir\\file1'] ：这是实现我们目标的一种方式 这是处理路径的 OOP 风格 提供许多功能
[Python 2]：dircache.listdir(path)（仅限 Python 2）但是，根据 [GitHub]：python/cpython - (2.7) cpython/Lib/dircache.py，它只是 os.listdir 的一个（薄）包装器带缓存 def listdir(path): """列出目录内容，使用缓存。""" try: cached_mtime, list = cache[path] del cache[path] except KeyError: cached_mtime, list = -1, [] mtime = os.stat(path).st_mtime if mtime != cached_mtime: list = os.listdir(path) list.sort() cache[path] = mtime, list return list
[man7]: OPENDIR(3) / [man7]: READDIR(3) / [man7]: CLOSEDIR(3) via [Python 3]: ctypes - Python 的外部函数库（特定于 POSIX）ctypes 是外部函数库对于 Python。它提供 C 兼容的数据类型，并允许调用 DLL 或共享库中的函数。它可用于将这些库包装在纯 Python 中。 code_ctypes.py: #!/usr/bin/env python3 import sys from ctypes import Structure, \c_ulonglong, c_longlong, c_ushort, c_ubyte, c_char, c_int, \CDLL, POINTER, \create_string_buffer, get_errno, set_errno, cast DT_DIR = 4 DT_REG = 8 char256 = c_char * 256 类 LinuxDirent64（结构）：_fields_ = [ ("d_ino", c_ulonglong), ("d_off", c_longlong), ("d_reclen", c_ushort), ("d_type", c_ubyte), (" d_name", char256), ] LinuxDirent64Ptr = POINTER(LinuxDirent64) libc_dll = this_process = CDLL(None, use_errno=True) # 总是为函数设置 argtypes 和 restype，否则就是 UB！！！ opendir = libc_dll.opendir readdir = libc_dll.readdir closedir = libc_dll.closedir def get_dir_content(path): ret = [path, list(), list()] dir_stream = opendir(create_string_buffer(path.encode())) if (dir_stream == 0): print("opendir 返回 NULL (errno: {:d})".format(get_errno())) return ret set_errno(0) dirent_addr = readdir(dir_stream) while dirent_addr: dirent_ptr = cast(dirent_addr, LinuxDirent64Ptr ) dirent = dirent_ptr.contents name = dirent.d_name.decode() if dirent.d_type & DT_DIR: 如果名称不在 (".", ".."): ret[1].append(name) elif dirent.d_type & DT_REG: ret[2].append(name) dirent_addr = readdir(dir_stream) if get_errno(): print("readdir returned NULL (errno: {:d})".format(get_errno())) closedir(dir_stream) return ret def main(): print("{:s} on {:s}\n".format(sys.version, sys.platform)) root_dir = "root_dir" entries = get_dir_content(root_dir) print(entries) if __name__ == "__main__": main() 注意：它从libc（在当前进程中加载）和c加载三个函数所有这些（有关更多详细信息，请检查 [SO]：如何检查文件是否存在无例外？ （@CristiFati 的回答）- 第 4 项的最后注释。）。这将使这种方法非常接近 Python / C 边缘 LinuxDirent64 是来自 [man7] 的 struct dirent64 的 ctypes 表示：dirent.h(0P)（DT_ 常量也是如此）来自我的机器：Ubtu 16 x64 (4.10.0 -40-generic 和 libc6-dev:amd64)。在其他风格/版本上，结构定义可能会有所不同，如果是这样，则应更新 ctypes 别名，否则将产生未定义行为它以 os.walk 的格式返回数据。我没有费心让它递归，但从现有代码开始，这将是一个相当简单的任务一切在 Win 上也是可行的，数据（库、函数、结构、常量......）不同输出： [cfati@cfati-ubtu16x64-0:~/Work/Dev/StackOverflow/q003207219]> ./code_ctypes.py 3.5.2（默认，2018 年 11 月 12 日，13:43:14）[GCC 5.4.0 20160609] 在 Linux 上['root_dir', ['dir2', 'dir1', 'dir3', 'dir0'], ['file1', 'file0']]
[ActiveState.Docs]：win32file.FindFilesW（Win 特定）使用 Windows Unicode API 检索匹配文件名列表。 API FindFirstFileW/FindNextFileW/Find 关闭函数的接口。 >>> 导入操作系统、win32file、win32con >>> root_dir = "root_dir" >>> 通配符 = "*" >>> root_dir_wildcard = os.path.join(root_dir, wildcard) >>> entry_list = win32file.FindFilesW(root_dir_wildcard ) >>> len(entry_list) # 不显示全部内容，因为它太长了 8 >>> [entry[-2] for entry in entry_list] # 只显示条目名称 ['.', '..' , 'dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1'] >>> >>> [entry[-2] for entry_list if entry[0] & win32con.FILE_ATTRIBUTE_DIRECTORY and entry[-2] not in (".", "..")] # 过滤条目，只显示目录名（self和parent除外） ['dir0', 'dir1', 'dir2', 'dir3'] >>> >>> [os.path.join(root_dir, entry[-2]) for entry in entry_list if entry[0] & (win32con.FILE_ATTRIBUTE_NORMAL | win32con.FILE_ATTRIBUTE_ARCHIVE)] # 只显示文件“完整”名称 [ 'root_dir\\file0', 'root_dir\\file1'] 注意：win32file.FindFilesW 是 [GitHub] 的一部分：mhammond/pywin32 - Python for Windows (pywin32) Extensions，它是 WINAPI 上的 Python 包装器文档链接来自 ActiveState，因为我没有找到任何 PyWin32 官方文档
安装一些（其他）第三方包，很可能会依赖上述一个（或多个）（可能有轻微的定制）
笔记：
代码旨在可移植（针对特定区域的地方除外 - 已标记）或跨平台（Nix、Win、）Python 版本（2、3、）
平台 (Nix, Win, )
Python 版本 (2, 3, )
在上述变体中使用了多种路径样式（绝对、相对），以说明使用的“工具”在这个方向上是灵活的事实
os.listdir 和 os.scandir 使用 opendir / readdir / closedir ([MS.Docs]: FindFirstFileW function / [MS.Docs]: FindNextFileW function / [MS.Docs]: FindClose function) (via [GitHub]: python/cpython - (主) cpython/Modules/posixmodule.c)
win32file.FindFilesW 也使用那些（Win 特定的）函数（通过 [GitHub]：mhammond/pywin32 - (master) pywin32/win32/src/win32file.i）
_get_dir_content（从第 1 点开始。）可以使用这些方法中的任何一种来实现（有些需要更多的工作，有些需要更少的工作）可以完成一些高级过滤（而不仅仅是文件与目录）：例如 include_folders 参数可以替换为另一个（例如 filter_func）将是一个将路径作为参数的函数： filter_func=lambda x: True （这不会删除任何内容）并且在 _get_dir_content 内部类似于：如果不是 filter_func(entry_with_path): continue （如果该函数一次失败，将被跳过），但代码越复杂，执行时间越长
可以进行一些高级过滤（而不仅仅是文件与目录）：例如 include_folders 参数可以替换为另一个参数（例如 filter_func），这将是一个将路径作为参数的函数： filter_func=lambda x: True (这不会删除任何内容）和内部 _get_dir_content 类似： if not filter_func(entry_with_path): continue （如果函数针对一个条目失败，它将被跳过），但代码变得越复杂，需要的时间就越长执行
注意！由于使用了递归，我必须提到我在我的笔记本电脑（Win 10 x64）上做了一些测试，与这个问题完全无关，当递归级别达到（990 .. 1000）范围内的某个值时（recursionlimit - 1000 （默认）），我得到了 StackOverflow :)。如果目录树超过该限制（我不是 FS 专家，所以我不知道这是否可能），这可能是个问题。我还必须提到，我没有尝试增加 recursionlimit，因为我在该领域没有经验（在必须增加操作系统级别的堆栈之前我可以增加多少），但理论上总会有可能失败，如果目录深度大于最高可能的递归限制（在那台机器上）
代码示例仅用于演示目的。这意味着我没有考虑错误处理（我认为没有任何 try / except / else / finally 块），因此代码不健壮（原因是：保持它尽可能简单和简短）。对于生产，还应添加错误处理
其他方法：
仅将 Python 用作包装器 一切都使用另一种技术完成 该技术是从 Python 调用的 我所知道的最著名的风格是我所说的系统管理员方法：使用 Python（或任何编程语言）来执行 shell命令（并解析它们的输出） 有些人认为这是一个巧妙的 hack 我认为它更像是一个蹩脚的解决方法（gainarie），因为操作本身是从 shell 执行的（在这种情况下是 cmd），因此没有任何事情可做用 Python。过滤（grep / findstr）或输出格式可以在双方完成，但我不会坚持。另外，我故意使用 os.system 而不是 subprocess.Popen。 (py35x64_test) E:\Work\Dev\StackOverflow\q003207219>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" -c "import os;os.system(\"dir /b root_dir\" )" dir0 dir1 dir2 dir3 file0 file1 通常应避免这种方法，因为如果某些命令输出格式在操作系统版本/风格之间略有不同，则解析代码也应进行调整；更不用说语言环境之间的差异了）。
我非常喜欢adamk's answer，建议您使用同名模块中的glob()。这允许您与 * 进行模式匹配。
但正如其他人在评论中指出的那样，glob() 可能会因斜线方向不一致而被绊倒。为了解决这个问题，我建议您使用 os.path 模块中的 join() 和 expanduser() 函数，也可以使用 os 模块中的 getcwd() 函数。
例如：
from glob import glob
# Return everything under C:\Users\admin that contains a folder called wlp.
glob('C:\Users\admin\*\wlp')
以上情况很糟糕 - 路径已被硬编码，并且只能在驱动器名称和硬编码到路径中的 \ 之间的 Windows 上工作。
from glob import glob
from os.path import join
# Return everything under Users, admin, that contains a folder called wlp.
glob(join('Users', 'admin', '*', 'wlp'))
上述方法效果更好，但它依赖于文件夹名称 Users，该名称通常在 Windows 上找到，而在其他操作系统上并不常见。它还依赖于具有特定名称 admin 的用户。
from glob import glob
from os.path import expanduser, join
# Return everything under the user directory that contains a folder called wlp.
glob(join(expanduser('~'), '*', 'wlp'))
这适用于所有平台。
另一个很好的例子，它可以完美地跨平台运行并且做一些不同的事情：
from glob import glob
from os import getcwd
from os.path import join
# Return everything under the current directory that contains a folder called wlp.
glob(join(getcwd(), '*', 'wlp'))
希望这些示例可以帮助您了解可以在标准 Python 库模块中找到的一些函数的强大功能。
recursive = True，** 就可以工作。在此处查看文档：docs.python.org/3.5/library/glob.html#glob.glob
def list_files(path):
# returns a list of names (with extension, without full path) of all files
# in folder path
files = []
for name in os.listdir(path):
if os.path.isfile(os.path.join(path, name)):
files.append(name)
return files
如果您正在寻找 find 的 Python 实现，这是我经常使用的配方：
from findtools.find_files import (find_files, Match)
# Recursively find all *.sh files in **/usr/bin**
sh_files_pattern = Match(filetype='f', name='*.sh')
found_files = find_files(path='/usr/bin', match=sh_files_pattern)
for found_file in found_files:
print found_file
所以我用它做了一个 PyPI package，还有一个 GitHub repository。我希望有人发现它可能对这段代码有用。
为了获得更好的结果，您可以将 os 模块的 listdir() 方法与生成器一起使用（生成器是一个强大的迭代器，可以保持其状态，还记得吗？）。以下代码适用于两个版本：Python 2 和 Python 3。
这是一个代码：
import os
def files(path):
for file in os.listdir(path):
if os.path.isfile(os.path.join(path, file)):
yield file
for file in files("."):
print (file)
listdir() 方法返回给定目录的条目列表。如果给定条目是文件，则方法 os.path.isfile() 返回 True。并且 yield 运算符退出 func 但保持其当前状态，并且它仅返回检测为文件的条目的名称。以上所有内容都允许我们循环生成器函数。
返回绝对文件路径列表，不递归到子目录
L = [os.path.join(os.getcwd(),f) for f in os.listdir('.') if os.path.isfile(os.path.join(os.getcwd(),f))]
os.path.abspath(f) 会比 os.path.join(os.getcwd(),f) 便宜一些。
cwd = os.path.abspath('.') 开始，然后在整个过程中使用 cwd 而不是 '.' 和 os.getcwd()，我会更有效率，以避免加载冗余系统调用。
一位睿智的老师曾经告诉我：
当有几种既定的方法来做某事时，它们中的任何一种都不适用于所有情况。
因此，我将为问题的一个子集添加一个解决方案：通常，我们只想检查文件是否匹配开始字符串和结束字符串，而不需要进入子目录。因此，我们想要一个返回文件名列表的函数，例如：
filenames = dir_filter('foo/baz', radical='radical', extension='.txt')
如果您想先声明两个函数，可以这样做：
def file_filter(filename, radical='', extension=''):
"Check if a filename matches a radical and extension"
if not filename:
return False
filename = filename.strip()
return(filename.startswith(radical) and filename.endswith(extension))
def dir_filter(dirname='', radical='', extension=''):
"Filter filenames in directory according to radical and extension"
if not dirname:
dirname = '.'
return [filename for filename in os.listdir(dirname)
if file_filter(filename, radical, extension)]
这个解决方案可以很容易地用正则表达式来概括（如果你不希望你的模式总是粘在文件名的开头或结尾，你可能想要添加一个 pattern 参数）。
import os
import os.path
def get_files(target_dir):
item_list = os.listdir(target_dir)
file_list = list()
for item in item_list:
item_dir = os.path.join(target_dir,item)
if os.path.isdir(item_dir):
file_list += get_files(item_dir)
else:
file_list.append(item_dir)
return file_list
这里我使用递归结构。
pathlib 只需一行即可实现相同的目的：filter(Path.is_file, Path().rglob('*'))
使用生成器
import os
def get_files(search_path):
for (dirpath, _, filenames) in os.walk(search_path):
for filename in filenames:
yield os.path.join(dirpath, filename)
list_files = get_files('.')
for filename in list_files:
print(filename)
Python 3.4+ 的另一个非常易读的变体是使用 pathlib.Path.glob：
from pathlib import Path
folder = '/foo'
[f for f in Path(folder).glob('*') if f.is_file()]
更具体很简单，例如只在所有子目录中查找不是符号链接的 Python 源文件：
[f for f in Path(folder).glob('**/*.py') if not f.is_symlink()]
对于 Python 2：
pip install rglob
然后做
import rglob
file_list = rglob.rglob("/home/base/dir/", "*")
print file_list
这是我的通用功能。它返回文件路径列表而不是文件名，因为我发现它更有用。它有一些可选参数，使其具有通用性。例如，我经常将它与 pattern='*.txt' 或 subfolders=True 等参数一起使用。
import os
import fnmatch
def list_paths(folder='.', pattern='*', case_sensitive=False, subfolders=False):
"""Return a list of the file paths matching the pattern in the specified
folder, optionally including files inside subfolders.
"""
match = fnmatch.fnmatchcase if case_sensitive else fnmatch.fnmatch
walked = os.walk(folder) if subfolders else [next(os.walk(folder))]
return [os.path.join(root, f)
for root, dirnames, filenames in walked
for f in filenames if match(f, pattern)]
我将提供一个示例，其中可以提供源路径和文件类型作为输入。该代码返回带有 csv 扩展名的文件名列表。利用 。以防所有文件都需要返回。这也将递归地扫描子目录。
[y for x in os.walk(sourcePath) for y in glob(os.path.join(x[0], '*.csv'))]
根据需要修改文件扩展名和源路径。
glob，则只需使用 glob('**/*.csv', recursive=True)。无需将此与 os.walk() 结合起来进行递归（自 Python 3.5 起支持 recursive 和 **）。
dircache 是“自 2.6 版起已弃用：dircache 模块已在 Python 3.0 中删除。”
import dircache
list = dircache.listdir(pathname)
i = 0
check = len(list[0])
temp = []
count = len(list)
while count != 0:
if len(list[i]) != check:
temp.append(list[i-1])
check = len(list[i])
else:
i = i + 1
count = count - 1
print temp
(_, _, filenames) = walk(mypath).next()（如果您确信 walk 将返回至少一个值，它应该返回。）f.extend(filenames)实际上并不等同于f = f + filenames。extend将就地修改f，而添加会在新的内存位置创建一个新列表。这意味着extend通常比+更有效，但如果多个对象持有对列表的引用，它有时会导致混淆。最后，值得注意的是，f += filenames等同于f.extend(filenames)，notf = f + filenames。_, _, filenames = next(walk(mypath), (None, None, []))f += filenames等同于扩展，而不是相反？？？天哪。