如何列出目录的所有文件？

import osos.listdir("somedirectory")

将返回一个列表中的所有文件和目录在“某个目录”。

#0返回目录中的所有内容——包括文件和目录。

#0的isfile()只能用于列出文件：

from os import listdirfrom os.path import isfile, joinonlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]

或者，它访问的每个目录都有#0生成两个列表——一个用于文件，一个用于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

我更喜欢使用#0模块，因为它进行模式匹配和扩展。

import globprint(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忽略以点.开头的文件和目录，因为它们被认为是隐藏的文件和目录，除非模式类似于.*。

使用#0来转义不是模式的字符串：

print(glob.glob(glob.escape(directory_name) + "/*.txt"))

的定义是"自2.6版以来已弃用：在Python 3.0中已删除了该模块"。

import dircachelist = dircache.listdir(pathname)i = 0check = 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 + 1count = count - 1
print temp

从目录及其所有子目录获取完整的文件路径

import os
def get_filepaths(directory):"""This function will generate the file names in a directorytree by walking the tree either top-down or bottom-up. For eachdirectory 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']

如果您愿意，您可以打开并阅读内容，或者只关注扩展名为“. dat”的文件，如下面的代码所示：

for f in full_file_paths:if f.endswith(".dat"):print f

/Users/johnny/Desktop/TEST/SUBFOLDER/file3.dat

获取唯一的文件列表（没有子目录）的单行解决方案：

filenames = next(os.walk(path))[2]

或绝对路径名：

paths = [os.path.join(path, fn) for fn in next(os.walk(path))[2]]

如果你正在寻找找到的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包，还有一个github仓库。我希望有人发现它对这段代码可能有用。

def list_files(path):# returns a list of names (with extension, without full path) of all files# in folder pathfiles = []for name in os.listdir(path):if os.path.isfile(os.path.join(path, name)):files.append(name)return files

返回绝对文件路径列表，不会递归到子目录中

L = [os.path.join(os.getcwd(),f) for f in os.listdir('.') if os.path.isfile(os.path.join(os.getcwd(),f))]

我真的很喜欢亚当的回答，建议您使用同名模块中的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 globfrom 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 globfrom os.path import expanduser, join
# Return everything under the user directory that contains a folder called wlp.glob(join(expanduser('~'), '*', 'wlp'))

这在所有平台上都非常有效。

另一个很好的例子，它可以完美地跨平台工作，并且做了一些不同的事情：

from glob    import globfrom os      import getcwdfrom os.path import join
# Return everything under the current directory that contains a folder called wlp.glob(join(getcwd(), '*', 'wlp'))

希望这些示例可以帮助您了解您可以在标准Python库模块中找到的一些函数的强大功能。

从3.4版本开始，有内置的迭代器比#0更有效：

#0：新版本3.4。

>>> import pathlib>>> [p for p in pathlib.Path('.').iterdir() if p.is_file()]

根据PEP 428，#0库的目的是提供一个简单的类层次结构来处理文件系统路径和用户对它们进行的常见操作。

#0：新版本3.5。

>>> import os>>> [entry for entry in os.scandir('.') if entry.is_file()]

请注意，#0使用#1而不是3.5版的#2，根据PEP 471，它的速度提高了2-20倍。

让我也推荐阅读下面的ShadowRanger评论。

使用发电机

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

当前目录中的列表

在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 osfrom os import listdirfrom os.path import isfile, join
cwd = os.getcwd()onlyfiles = [os.path.join(cwd, f) for f in os.listdir(cwd) ifos.path.isfile(os.path.join(cwd, f))]print(onlyfiles)
['G:\\getfilesname\\getfilesname.py', 'G:\\getfilesname\\example.txt']

使用os.path.abspath获取完整的路径名

你会得到完整的路径作为回报

 import osfiles_path = [os.path.abspath(x) for x in os.listdir()]print(files_path) 
['F:\\documenti\applications.txt', 'F:\\documenti\collections.txt']

步行：遍历子目录

os.walk返回根，目录列表和文件列表，这就是为什么我在for循环中将它们解压缩在r，d，f中；然后，它在根的子文件夹中查找其他文件和目录，依此类推，直到没有子文件夹。

import os
# Getting the current work directory (cwd)thisdir = os.getcwd()
# r=root, d=directories, f = filesfor r, d, f in os.walk(thisdir):for file in f:if file.endswith(".docx"):print(os.path.join(r, file))

在目录树中向上

# Method 1x = os.listdir('..')
# Method 2x= os.listdir('/')

使用os.listdir()获取特定子目录的文件

import os
x = os.listdir("./content")

os.walk ('.') - 当前目录

 import osarr = next(os.walk('.'))[2]print(arr) 
>>> ['5bs_Turismo1.pdf', '5bs_Turismo1.pptx', 'esperienza.txt']

Next（os.walk ('.')) 和os.path.join（'dir'，'file'）

 import osarr = []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 pathfrom glob import glob
x = [path(f).abspath() for f in glob("F:\\*.txt")]

使用os.path.isfile避免列表中的目录

import os.pathlistOfFiles = [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()]

在path lib. Path（）中使用全局方法

import pathlib
py = pathlib.Path().glob("*.py")

获取所有且仅具有os.walk的文件：仅检查返回的第三个元素，即文件列表

import osx = [i[2] for i in os.walk('.')]y=[]for t in x:for f in t:y.append(f)

仅获取目录中带有next的文件：仅返回根文件夹中的文件

 import osx = next(os.walk('F://python'))[2]

只获取带有next的目录并在目录中行走，因为在[1]元素中只有文件夹

 import osnext(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 osx = [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 oswith os.scandir() as i:for entry in i:if entry.is_file():print(entry.name)

这是我的通用函数。它返回文件路径列表而不是文件名，因为我发现它更有用。它有一些可选参数，使其通用。例如，我经常将它与pattern='*.txt'或subfolders=True等参数一起使用。

import osimport fnmatch
def list_paths(folder='.', pattern='*', case_sensitive=False, subfolders=False):"""Return a list of the file paths matching the pattern in the specifiedfolder, optionally including files inside subfolders."""match = fnmatch.fnmatchcase if case_sensitive else fnmatch.fnmatchwalked = os.walk(folder) if subfolders else [next(os.walk(folder))]return [os.path.join(root, f)for root, dirnames, filenames in walkedfor 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'))]

根据需要修改文件扩展名和源路径。

初步说明

• 尽管问题文本中的文件和目录术语有明显的区别，但有些人可能会争辩说目录实际上是特殊文件
• 语句：“目录的所有文件”可以用两种方式解释：
  1. 所有直接（或1级）后代只有
  2. 整个目录树中的所有后代（包括子目录中的后代）

• 当问题被问到时，我想象Python2是LTS的版本，然而代码示例将由Python3（.5）运行（我会尽可能让它们符合python2；此外，我要发布的任何属于python的代码，都来自v3.5.4-除非另有说明）。这与问题中的另一个关键字有关：“将它们添加到列表中”：

  • 在python2.2之前的版本中，序列（可迭代的）主要由列表（元组、集合…）表示
  • 在python2.2中，引入了发生器（[Python. Wiki]：生成器）的概念-由[Python 3]：产量语句提供）。随着时间的推移，生成器对应物开始出现在返回/处理列表的函数中
  • 在python3中，生成器是默认行为
  • 不确定返回列表是否仍然是强制性的（或者生成器也可以），但是将生成器传递给列表构造函数，将从中创建一个列表（并使用它）。下面的例子说明了[Python 3]：map（函数，可迭代，…）的区别

  >>> 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])  # Just a dummy lambda function>>> m, type(m)([1, 2, 3], <type 'list'>)>>> len(m)3

  
  

  >>> import sys>>> sys.version'3.5.4 (v3.5.4:3f56838, Aug  8 2017, 02:17:05) [MSC v.1900 64 bit (AMD64)]'>>> m = map(lambda x: x, [1, 2, 3])>>> m, type(m)(<map object at 0x000001B4257342B0>, <class 'map'>)>>> len(m)Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: object of type 'map' has no len()>>> lm0 = list(m)  # Build a list from the generator>>> lm0, type(lm0)([1, 2, 3], <class 'list'>)>>>>>> lm1 = list(m)  # Build a list from the same generator>>> lm1, type(lm1)  # Empty list now - generator already consumed([], <class 'list'>)

• 示例将基于名为root_dir的目录，其结构如下（此示例用于赢，但我在Lnx上也使用相同的树）：

  E:\Work\Dev\StackOverflow\q003207219>tree /f "root_dir"Folder PATH listing for volume WorkVolume serial number is 00000029 3655:6FEDE:\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

解决方案

方案办法：

1. [Python 3]： os.listdir（path='.'）

   返回一个包含path给定目录中条目名称的列表。该列表按任意顺序排列，不包括特殊条目'.'和'..'…

   
   

   >>> import os>>> root_dir = "root_dir"  # Path relative to current dir (os.getcwd())>>>>>> os.listdir(root_dir)  # List all the items in root_dir['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']>>>>>> [item for item in os.listdir(root_dir) if os.path.isfile(os.path.join(root_dir, item))]  # Filter items and only keep files (strip out directories)['file0', 'file1']

   更详细的示例（code_os_listdir.py）：

   import osfrom 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_pathif recursive:for sub_entry in _get_dir_content(entry_with_path, include_folders, recursive):yield sub_entryelse: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)for item in _get_dir_content(path, include_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, prepend_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"<generator object get_dir_content at 0x000001BDDBB3DF10> 22 ['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','root_dir\\dir2\\dir20\\file200','root_dir\\dir2\\file20','root_dir\\dir3','root_dir\\file0','root_dir\\file1']11 ['dir0\\dir00\\dir000\\file0000','dir0\\dir00\\file000','dir0\\dir01\\file010','dir0\\dir01\\file011','dir1\\file10','dir1\\file11','dir1\\file12','dir2\\dir20\\file200','dir2\\file20','file0','file1']

2. [Python 3]： os.scandir（path='.'）（Python3.5+， backport：[PyPI]： scandir）

   返回与路径给出的目录中的条目对应的操作系统对象的迭代器。条目以任意顺序产生，不包括特殊条目'.'和'..'。

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

   
   

   >>> import os>>> root_dir = os.path.join(".", "root_dir")  # Explicitly prepending current directory>>> root_dir'.\\root_dir'>>>>>> scandir_iterator = os.scandir(root_dir)>>> scandir_iterator<nt.ScandirIterator object at 0x00000268CF4BC140>>>> [item.path for item in scandir_iterator]['.\\root_dir\\dir0', '.\\root_dir\\dir1', '.\\root_dir\\dir2', '.\\root_dir\\dir3', '.\\root_dir\\file0', '.\\root_dir\\file1']>>>>>> [item.path for item in scandir_iterator]  # Will yield an empty list as it was consumed by previous iteration (automatically performed by the list comprehension)[]>>>>>> scandir_iterator = os.scandir(root_dir)  # Reinitialize the generator>>> for item in scandir_iterator :...     if os.path.isfile(item.path):...             print(item.name)...file0file1

   备注：

   • 类似于os.listdir
   • 但它也更灵活（并提供更多功能），更多pythonic（在某些情况下，更快）

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

   通过自上而下或自下而上遍历树来生成目录树中的文件名。对于根植于目录顶部（包括顶部本身）的树中的每个目录，它产生一个3元组（dirpath、dirnames、filenames）。

   
   

   >>> import os>>> root_dir = os.path.join(os.getcwd(), "root_dir")  # Specify the full path>>> root_dir'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir'>>>>>> walk_generator = os.walk(root_dir)>>> root_dir_entry = next(walk_generator)  # First entry corresponds to the root dir (passed as an argument)>>> root_dir_entry('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir', ['dir0', 'dir1', 'dir2', 'dir3'], ['file0', 'file1'])>>>>>> root_dir_entry[1] + root_dir_entry[2]  # Display dirs and files (direct descendants) in a single list['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]]  # Display all the entries in the previous list by their full path['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:  # Display the rest of the elements (corresponding to every subdir)...     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:\\Work\\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）
   • 它通过在子文件夹中重复来完成繁重的工作

4. [Python 3]：全称。全称（路径名，*，递归=False）（[Python 3]： Globb.iglob（路径名，*，递归=False））

   返回匹配路径名的可能为空的路径名列表，该列表必须是包含路径规范的字符串。路径名可以是绝对的（如/usr/src/Python-1.5/Makefile）或相对的（如../../Tools/*/*.gif），并且可以包含shell样式的通配符。断开的符号链接包含在结果中（如shell中）。
   …
   在3.5版中更改：支持使用“**”的递归全局。

   
   

   >>> import glob, os>>> wildcard_pattern = "*">>> root_dir = os.path.join("root_dir", wildcard_pattern)  # Match every file/dir name>>> 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]  # Strip the dir name and the path separator from begining['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']>>>>>> for entry in glob.iglob(root_dir + "*", recursive=True):...     print(entry)...root_dir\root_dir\dir0root_dir\dir0\dir00root_dir\dir0\dir00\dir000root_dir\dir0\dir00\dir000\file0000root_dir\dir0\dir00\file000root_dir\dir0\dir01root_dir\dir0\dir01\file010root_dir\dir0\dir01\file011root_dir\dir0\dir02root_dir\dir0\dir02\dir020root_dir\dir0\dir02\dir020\dir0200root_dir\dir1root_dir\dir1\file10root_dir\dir1\file11root_dir\dir1\file12root_dir\dir2root_dir\dir2\dir20root_dir\dir2\dir20\file200root_dir\dir2\file20root_dir\dir3root_dir\file0root_dir\file1

   备注：

   • 使用os.listdir
   • 对于大树（特别是如果递归打开），iglob是首选
   • 允许基于名称的高级过滤（由于通配符）

5. [Python 3]：类路径库。Path（*路径段）（Python3.4+， backport：[PyPI]： Pathlib2）

   >>> import pathlib>>> root_dir = "root_dir">>> root_dir_instance = pathlib.Path(root_dir)>>> root_dir_instanceWindowsPath('root_dir')>>> root_dir_instance.name'root_dir'>>> root_dir_instance.is_dir()True>>>>>> [item.name for item in root_dir_instance.glob("*")]  # Wildcard searching for all direct descendants['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()]  # Display paths (including parent) for files only['root_dir\\file0', 'root_dir\\file1']

   备注：

   • 这是实现我们目标的一个方式
   • 这是处理路径的OOP风格
   • 提供了很多功能

6. [Python 2]：dircache.listdir（路径）（仅限python2）

   • 但是，根据[GitHub]： python/cpython-（2.7）cpython/Lib/dircache.py，它只是os.listdir上带有缓存的（薄）包装器

   
   

   def listdir(path):"""List directory contents, using cache."""try:cached_mtime, list = cache[path]del cache[path]except KeyError:cached_mtime, list = -1, []mtime = os.stat(path).st_mtimeif mtime != cached_mtime:list = os.listdir(path)list.sort()cache[path] = mtime, listreturn list