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

这篇文章是社区维基 。 编辑现有答案以改善此职位。 它当前不接受新的答案。 了解更多 。

如何在Python中列出目录的所有文件并将它们添加到list ？

---

#1楼

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

---

#2楼

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

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

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

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

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

---

#3楼

一种仅获取文件列表 （不包含子目录）的单行解决方案：

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

或绝对路径名：

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

---

#4楼

如果您正在寻找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 软件包 ，并且还有一个GitHub存储库 。 我希望有人发现它可能对该代码有用。

---

#5楼

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 

---

#6楼

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

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

---

#7楼

我真的很喜欢adamk的答案 ，建议您使用同名模块中的glob() 。 这使您可以使用* s进行模式匹配。

但是正如其他人在评论中指出的那样， 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'))

上面的方法效果更好，但是它依赖于Windows上常见的文件夹名称Users ，而在其他OS上则不常见。 它还依赖于具有特定名称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库模块中可以找到的一些功能的强大功能。

---

#8楼

从3.4版开始，有内置的迭代器 ，比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()]

请注意，从3.5版开始， os.walk()使用os.scandir()而不是os.listdir() ，根据PEP 471 ，其速度提高了2-20倍。

我也建议您阅读下面的ShadowRanger评论。

---

#9楼

import os
os.listdir("somedirectory")

将返回“ somedirectory”中所有文件和目录的列表。

---

#10楼

os.listdir()将为您提供目录中的所有内容-文件和目录。

如果只需要文件，则可以使用os.path将其过滤掉：

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

或者您可以使用os.walk() ，它将为它访问的每个目录生成两个列表-为您拆分为文件和目录。 如果只需要顶层目录，可以在第一次生成目录时中断

from os import walk

f = []
for (dirpath, dirnames, filenames) in walk(mypath):
    f.extend(filenames)
    break

---

#11楼

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

import glob
print(glob.glob("/home/adam/*.txt"))

它将返回包含查询文件的列表：

['/home/adam/file1.txt', '/home/adam/file2.txt', .... ]

---

#12楼

使用发电机

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)

---

#13楼

使用Python 2和3获取文件列表

---

os.listdir()

如何获取当前目录中的所有文件（和目录）（Python 3）

以下是在Python 3中使用os和listdir()函数仅检索当前目录中文件的简单方法。进一步的探索将演示如何返回目录中的文件夹，但子目录中没有文件，为此您可以使用步行-稍后讨论）。

 import os
 arr = os.listdir()
 print(arr)

 >>> ['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

glob

我发现glob更容易选择相同类型或有共同点的文件。 看下面的例子：

import glob

txtfiles = []
for file in glob.glob("*.txt"):
    txtfiles.append(file)

具有列表理解的glob

import glob

mylist = [f for f in glob.glob("*.txt")]

具有功能的glob

import glob

def filebrowser():
    return [f for f in glob.glob("*")]

x = filebrowser()
print(x)

>>> ['example.txt', 'fb.py', 'filebrowser.py', 'help']

扩展先前代码的glob

该函数现在返回与您作为参数传递的字符串匹配的文件列表

import glob

def filebrowser(word=""):
    """Returns a list with all files with the word/extension in it"""
    file = []
    for f in glob.glob("*"):
        if word in f:
            file.append(f)
            return file

flist = filebrowser("example")
print(flist)
flist = filebrowser(".py")
print(flist)

>>> ['example.txt']
>>> ['fb.py', 'filebrowser.py']

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

正如您所注意到的，上面的代码中没有文件的完整路径。 如果需要绝对路径，则可以使用os.path模块的另一个函数_getfullpathname ，将从os.listdir()获得的文件作为参数。 还有其他完整路径的方法，稍后我们将进行检查（如mexmex所建议，我将_getfullpathname替换为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获取所有子目录中文件类型的完整路径名

我发现在很多目录中查找内容非常有用，它有助于我找到一个我不记得其名称的文件：

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 ".docx" in file:
            print(os.path.join(r, file))

os.listdir() ：获取当前目录中的文件（Python 2）

在Python 2中，如果要在当前目录中列出文件列表，则必须将参数指定为“。”。 或os.listdir方法中的os.getcwd（）。

 import os
 arr = os.listdir('.')
 print(arr)

 >>> ['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

进入目录树

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

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

获取文件：特定目录中的os.listdir() （Python 2和3）

 import os
 arr = os.listdir('F:\\python')
 print(arr)

 >>> ['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

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

next(os.walk('F:\\\\') -获取完整路径-列表理解

 [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获取完整路径-sub dirs中的所有文件**

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")]
 print(arr_txt)

 >>> ['work.txt', '3ebooks.txt']

使用glob获取文件的完整路径

如果我需要文件的绝对路径：

from path import path
from glob import glob
x = [path(f).abspath() for f in glob("F:\\*.txt")]
for f in x:
    print(f)

>>> F:\acquistionline.txt
>>> F:\acquisti_2018.txt
>>> F:\bootstrap_jquery_ecc.txt

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

import os.path
listOfFiles = [f for f in os.listdir() if os.path.isfile(f)]
print(listOfFiles)

>>> ['a simple game.py', 'data.txt', 'decorator.py']

从Python 3.4使用pathlib

import pathlib

flist = []
for p in pathlib.Path('.').iterdir():
    if p.is_file():
        print(p)
        flist.append(p)

 >>> error.PNG
 >>> exemaker.bat
 >>> guiprova.mp3
 >>> setup.py
 >>> speak_gui2.py
 >>> thumb.PNG

具有list comprehension ：

flist = [p for p in pathlib.Path('.').iterdir() if p.is_file()]

或者，使用pathlib.Path()代替pathlib.Path(".")

在pathlib.Path（）中使用glob方法

import pathlib

py = pathlib.Path().glob("*.py")
for file in py:
    print(file)

>>> stack_overflow_list.py
>>> stack_overflow_list_tkinter.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)
print(y)

>>> ['append_to_list.py', 'data.txt', 'data1.txt', 'data2.txt', 'data_180617', 'os_walk.py', 'READ2.py', 'read_data.py', 'somma_defaltdic.py', 'substitute_words.py', 'sum_data.py', 'data.txt', 'data1.txt', 'data_180617']

仅获取具有next的文件并进入目录

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

 >>> ['calculator.bat','calculator.py']

仅获取具有next的目录并进入目录

 import os
 next(os.walk('F://python'))[1] # for the current dir use ('.')

 >>> ['python3','others']

使用walk获取所有子目录名称

for r,d,f in os.walk("F:\\_python"):
    for dirs in d:
        print(dirs)

>>> .vscode
>>> pyexcel
>>> pyschool.py
>>> subtitles
>>> _metaprogramming
>>> .ipynb_checkpoints

python 3.5及更高版本中的os.scandir()

import os
x = [f.name for f in os.scandir() if f.is_file()]
print(x)

>>> ['calculator.bat','calculator.py']

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

>>> ebookmaker.py
>>> error.PNG
>>> exemaker.bat
>>> guiprova.mp3
>>> setup.py
>>> speakgui4.py
>>> speak_gui2.py
>>> speak_gui3.py
>>> thumb.PNG

例子：

例如 1：子目录中有多少个文件？

在此示例中，我们查找所有目录及其子目录中包含的文件数。

import os

def count(dir, counter=0):
    "returns number of files in dir and subdirs"
    for pack in os.walk(dir):
        for f in pack[2]:
            counter += 1
    return dir + " : " + str(counter) + "files"

print(count("F:\\python"))

>>> 'F:\\\python' : 12057 files'

例2：如何将所有文件从一个目录复制到另一个目录？

用于在计算机中排序的脚本，以查找一种类型的所有文件（默认值：pptx）并将其复制到新文件夹中。

import os
import shutil
from path import path

destination = "F:\\file_copied"
# os.makedirs(destination)

def copyfile(dir, filetype='pptx', counter=0):
    "Searches for pptx (or other - pptx is the default) files and copies them"
    for pack in os.walk(dir):
        for f in pack[2]:
            if f.endswith(filetype):
                fullpath = pack[0] + "\\" + f
                print(fullpath)
                shutil.copy(fullpath, destination)
                counter += 1
    if counter > 0:
        print('-' * 30)
        print("\t==> Found in: `" + dir + "` : " + str(counter) + " files\n")

for dir in os.listdir():
    "searches for folders that starts with `_`"
    if dir[0] == '_':
        # copyfile(dir, filetype='pdf')
        copyfile(dir, filetype='txt')


>>> _compiti18\Compito Contabilità 1\conti.txt
>>> _compiti18\Compito Contabilità 1\modula4.txt
>>> _compiti18\Compito Contabilità 1\moduloa4.txt
>>> ------------------------
>>> ==> Found in: `_compiti18` : 3 files

例如 3：如何获取txt文件中的所有文件

如果要使用所有文件名创建一个txt文件，请执行以下操作：

import os
mylist = ""
with open("filelist.txt", "w", encoding="utf-8") as file:
    for eachfile in os.listdir():
        mylist += eachfile + "\n"
    file.write(mylist)

示例：包含硬盘驱动器所有文件的txt

"""
We are going to save a txt file with all the files in your directory.
We will use the function walk()
"""

import os

# see all the methods of os
# print(*dir(os), sep=", ")
listafile = []
percorso = []
with open("lista_file.txt", "w", encoding='utf-8') as testo:
    for root, dirs, files in os.walk("D:\\"):
        for file in files:
            listafile.append(file)
            percorso.append(root + "\\" + file)
            testo.write(file + "\n")
listafile.sort()
print("N. of files", len(listafile))
with open("lista_file_ordinata.txt", "w", encoding="utf-8") as testo_ordinato:
    for file in listafile:
        testo_ordinato.write(file + "\n")

with open("percorso.txt", "w", encoding="utf-8") as file_percorso:
    for file in percorso:
        file_percorso.write(file + "\n")

os.system("lista_file.txt")
os.system("lista_file_ordinata.txt")
os.system("percorso.txt")

C：\\的所有文件都在一个文本文件中

这是先前代码的简短版本。 如果您需要从另一个位置开始，请更改开始查找文件的文件夹。 这段代码在我的计算机上的文本文件上生成了50 mb的内容，其中包含完整路径的文件少于500.000行。

import os

with open("file.txt", "w", encoding="utf-8") as filewrite:
    for r, d, f in os.walk("C:\\"):
        for file in f:
            filewrite.write(f"{r + file}\n")

如何在一个类型的文件夹中写入所有路径的文件

使用此功能，您可以创建一个txt文件，该文件将具有您要查找的文件类型的名称（例如pngfile.txt），并带有该类型所有文件的所有完整路径。 我认为有时候它会很有用。

import os

def searchfiles(extension='.ttf', folder='H:\\'):
    "Create a txt file with all the file of a type"
    with open(extension[1:] + "file.txt", "w", encoding="utf-8") as filewrite:
        for r, d, f in os.walk(folder):
            for file in f:
                if file.endswith(extension):
                    filewrite.write(f"{r + file}\n")

# looking for png file (fonts) in the hard disk H:\
searchfiles('.png', 'H:\\')

>>> H:\4bs_18\Dolphins5.png
>>> H:\4bs_18\Dolphins6.png
>>> H:\4bs_18\Dolphins7.png
>>> H:\5_18\marketing html\assets\imageslogo2.png
>>> H:\7z001.png
>>> H:\7z002.png

（新）找到所有文件并使用tkinter GUI打开它们

我只是想在这个2019年添加一个小应用程序来搜索目录中的所有文件，并能够通过双击列表中文件的名称来打开它们。

import tkinter as tk
import os

def searchfiles(extension='.txt', folder='H:\\'):
    "insert all files in the listbox"
    for r, d, f in os.walk(folder):
        for file in f:
            if file.endswith(extension):
                lb.insert(0, r + "\\" + file)

def open_file():
    os.startfile(lb.get(lb.curselection()[0]))

root = tk.Tk()
root.geometry("400x400")
bt = tk.Button(root, text="Search", command=lambda:searchfiles('.png', 'H:\\'))
bt.pack()
lb = tk.Listbox(root)
lb.pack(fill="both", expand=1)
lb.bind("<Double-Button>", lambda x: open_file())
root.mainloop()

---

#14楼

这是我的通用功能。 它返回文件路径而不是文件名的列表，因为我发现它更有用。 它具有一些可选参数，使其具有通用性。 例如，我经常将其与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)]

---

#15楼

我将提供一个示例liner，其中可以提供sourcepath和文件类型作为输入。 该代码返回带有csv扩展名的文件名列表。 使用。 万一需要返回所有文件。 这还将递归扫描子目录。

[y for x in os.walk(sourcePath) for y in glob(os.path.join(x[0], '*.csv'))]

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

---

#16楼

初步说明

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

• 提出问题时，我认为Python 2是LTS版本，但是代码示例将由Python 3 （ .5 ）运行 （我将使其尽可能与Python 2兼容；此外，属于我要发布的Python来自v3.5.4-除非另有说明）。 结果与问题中的另一个关键字相关：“ 将它们添加到列表中 ”：

  • 在Python 2.2之前的版本中，序列（可迭代）主要由列表（元组，集合等）表示。
  • 在Python 2.2中 ， 引入了生成器 （ [Python.Wiki]：Generators ）的概念-由[Python 3]：yield语句提供 。 随着时间的流逝，对于返回/使用列表的函数，生成器对应对象开始出现
  • 在Python 3中 ，generator是默认行为
  • 不知道返回列表是否仍然是强制性的（或者生成器也可以执行），但是将生成器传递给列表构造函数会从列表构造器中创建列表（并消耗列表）。 以下示例说明了[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]) # 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的目录（此示例适用于Win ，但我也在Lnx上使用同一棵树）：

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

解决方案

程序化方法：

1. [Python 3]：操作系统。 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 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) 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结尾）
   • 使用递归（进入子目录）
   • 对于每种实现，都有两个功能：
     • 以下划线 （ _ ） 开头的代码 ：“ private”（不应直接调用）-完成所有工作
     • 公共的（包装上一个）：它只是从返回的条目中剥离出初始路径（如果需要）。 这是一个丑陋的实现，但这是我目前唯一能想到的想法
   • 在性能方面，生成器通常要快一些（考虑创建和迭代时间），但是我没有在递归函数中对其进行测试，而且我还在内部生成器上迭代函数内部-不知道性能如何友好的是
   • 玩弄参数以获得不同的结果

   
   

   输出 ：

    (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]：操作系统。 scandir （ path ='。' ） （ Python 3.5 +，backport： [PyPI]：scandir ）

   返回与path指定的目录中的条目相对应的os.DirEntry对象的迭代器。 条目以任意顺序产生，特殊条目为'.' 和'..'不包括在内。

   使用scandir（）而不是listdir（）可以显着提高还需要文件类型或文件属性信息的代码的性能，因为如果操作系统在扫描目录时提供了os.DirEntry对象，则该信息会公开。 所有的os.DirEntry方法都可以执行系统调用，但是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) ... file0 file1 

   注意事项 ：

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

3. [Python 3]：操作系统。 步行 （ top，topdown = True，onerror = None，followlinks = False ）

   通过自上而下或自下而上移动目录树来生成文件名。 对于以目录顶部 （包括顶部本身）为根的树中的每个目录，它都会生成一个dirpath组（ 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]：glob。 glob （ pathname，*，recursive = False ） （ [Python 3]： glob。iglob （ pathname，*，recursive = False ） ）

   返回与pathname匹配的路径名的可能为空的列表，该列表必须是包含路径说明的字符串。 路径名可以是绝对路径 （例如/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) # 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\\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 

   注意事项 ：

   • 使用os.listdir
   • 对于大树（尤其是在启用递归的情况下），首选iglob
   • 允许基于名称进行高级过滤（由于通配符）

5. [Python 3]：类pathlib。 路径 （ * 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("*")] # 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（path） （仅Python 2 ）

   • 但是，根据[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_mtime if mtime != cached_mtime: list = os.listdir(path) list.sort() cache[path] = mtime, list return list 

7. [man7]：OPENDIR（3） / [man7]：READDIR（3） / [man7]：CLOSEDIR（3）通过[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 class LinuxDirent64(Structure): _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) # ALWAYS set argtypes and restype for functions, otherwise it's 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 returned 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: if name not in (".", ".."): 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加载三个函数（在当前进程中加载​​）并调用它们（有关更多详细信息，请检查[SO]：如何检查文件是否存在无异常？（@ CristiFati的回答） - 第4项的最后说明。 ）。 这将使这种方法非常接近Python / C边缘
   • LinuxDirent64是从结构dirent64的ctypes的表示[man7]：dirent.h（0P）从我的机器（等等都是DT_常数）：Ubtu 16 64（4.10.0-40 泛型和libc6的-dev的：AMD64）。 在其他风味/版本上，结构定义可能会有所不同，如果有，则应更新ctypes别名，否则将产生未定义行为
   • 它以os.walk的格式返回数据。 我没有麻烦使其递归，但是从现有代码开始，这将是一个相当琐碎的任务
   • 一切在Win上也都可行，数据（库，函数，结构，常量等）不同

   
   

   输出 ：

    [cfati@cfati-ubtu16x64-0:~/Work/Dev/StackOverflow/q003207219]> ./code_ctypes.py 3.5.2 (default, Nov 12 2018, 13:43:14) [GCC 5.4.0 20160609] on linux ['root_dir', ['dir2', 'dir1', 'dir3', 'dir0'], ['file1', 'file0']] 

8. [ActiveState.Docs]：win32file.FindFilesW （特定于 Win ）

   使用Windows Unicode API检索匹配文件名的列表。 API FindFirstFileW / FindNextFileW / Find关闭函数的接口。

   
   

    >>> import os, win32file, win32con >>> root_dir = "root_dir" >>> wildcard = "*" >>> root_dir_wildcard = os.path.join(root_dir, wildcard) >>> entry_list = win32file.FindFilesW(root_dir_wildcard) >>> len(entry_list) # Don't display the whole content as it's too long 8 >>> [entry[-2] for entry in entry_list] # Only display the entry names ['.', '..', 'dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1'] >>> >>> [entry[-2] for entry in entry_list if entry[0] & win32con.FILE_ATTRIBUTE_DIRECTORY and entry[-2] not in (".", "..")] # Filter entries and only display dir names (except self and 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)] # Only display file "full" names ['root_dir\\\\file0', 'root_dir\\\\file1'] 

   注意事项 ：

   • win32file.FindFilesW是[GitHub]的一部分：mhammond / pywin32-Windows的Python（pywin32）扩展 ，它是WINAPI的Python包装器
   • 文档链接来自ActiveState ，因为我没有找到任何PyWin32官方文档

9. 安装一些（其他）第三方软件包即可
   • 最有可能会依赖于上述一项（或多项）（可能需要进行一些自定义）

注意事项 ：

• 代码应具有可移植性（针对特定区域的地方-带有标记的地方除外）或交叉的：

  • 平台（ Nix ， Win ，）
  • Python版本（2、3，）

• 在上述变体中使用了多种路径样式（绝对路径，相对路径），以说明以下事实：所使用的“工具”在此方向上是灵活的

• os.listdir和os.scandir使用opendir / readdir / closedir （ [MS.Docs]：FindFirstFileW函数 / [MS.Docs]：FindNextFileW函数 / [MS.Docs]：FindClose函数 ）（通过[GitHub]：python / cpython -（主）cpython / Modules / posixmodule.c ）

• win32file.FindFilesW使用这些（特定于Win的 ）函数（通过[GitHub]：mhammond / pywin32-（主）pywin32 / win32 / src / win32file.i ）

• _get_dir_content （从第1点开始）可以使用以下任何一种方法来实现（有些需要更多的工作，有些需要更少的工作）

  • 一些先进的过滤（而不仅仅是文件与目录）可以做：由另一个例如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专家，所以我什至不知道那是否可能），那可能是个问题。
  我还必须提到，我没有尝试增加递归限制，因为我没有该领域的经验（在必须同时在OS级别上增加堆栈之前，我可以增加多少），​​但是从理论上讲，总有可能如果dir深度大于最大可能的递归限制 （在该计算机上），则失败

• 代码示例仅用于说明目的。 这意味着我没有考虑错误处理（我不认为有任何try / 除了 / else / finally块），因此代码并不健壮（原因是：使其尽可能简单和简短） ）。 对于生产 ，还应添加错误处理

其他方法：

1. 仅将Python用作包装器

   • 一切都使用另一种技术完成
   • 该技术是从Python调用的

   • 我所知道的最著名的味道是我所说的系统管理员方法：

     • 使用Python （或与此相关的任何编程语言）执行Shell命令（并解析其输出）
     • 有人认为这是一个很好的技巧
     • 我认为这更像是一种me脚的解决方法（ 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 

   通常应避免这种方法，因为如果某些命令输出格式在OS版本/风格之间略有不同，则解析代码也应进行调整；例如， 更不用说语言环境之间的差异了）。

---

#17楼

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

---

#18楼

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

在这里，我使用递归结构。

---

#19楼

对于python2：pip install rglob

import rglob
file_list=rglob.rglob("/home/base/dir/", "*")
print file_list

---

#20楼

为了获得更好的结果，可以将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运算符退出功能但保持其当前状态，并且仅返回检测为文件的条目的名称。 以上所有内容使我们可以循环生成器功能。

---

#21楼

一位聪明的老师曾经告诉我：

当有几种确定的方法可以做某事时，没有一种方法适合所有情况。

因此，我将为问题的一个子集添加一个解决方案：很多时候，我们只想检查文件是否匹配开始字符串和结束字符串，而无需进入子目录。 因此，我们想要一个返回文件名列表的函数，例如：

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参数）。

---

#22楼

从指定的文件夹（包括子目录）获取所有文件。

import glob
import os

print([entry for entry in glob.iglob("{}/**".format("DIRECTORY_PATH"), recursive=True) if os.path.isfile(entry) == True])