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

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

答案

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

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

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

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

['/home/adam/file1.txt', '/home/adam/file2.txt', .... ]
import os
os.listdir("somedirectory")

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

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


os.listdir()

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

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

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

一种获取文件列表 (不包含子目录)的单行解决方案:

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

或绝对路径名:

paths = [os.path.join(path, fn) for fn in next(os.walk(path))[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.4 版开始,有内置的迭代器 ,比os.listdir()效率更高:

pathlib版本 3.4 中的新增功能。

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

根据PEP 428pathlib库的目的是提供一个简单的类层次结构,以处理文件系统路径以及用户对其进行的常见操作。

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 评论。

初步说明

  • 尽管问题文本中的文件目录术语之间存在明显区别,但有些人可能会认为目录实际上是特殊文件
  • 语句:“ 目录的所有文件 ” 可以用两种方式解释:
    1. 只有所有直接 (或 1 级)的后裔
    2. 整个目录树中的所有子代(包括子目录中的子代)
  • 提出问题时,我认为Python 2LTS版本,但是代码示例将由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]的区别mapfunction,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]:操作系统。 listdirpath ='。'

    返回一个列表,其中包含由 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']


  1. [Python 3]:操作系统。 scandirpath ='。'Python 3.5 +,backport: [PyPI]:scandir

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

    使用scandir()而不是listdir()可以大大提高还需要文件类型或文件属性信息的代码的性能,因为如果操作系统在扫描目录时提供了os.DirEntry对象,则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(在某些情况下还更快)


  1. [Python 3]:操作系统。 步行top,topdown = True,onerror = None,followlinks = False

    通过自上而下或自下而上浏览目录树来生成目录树中的文件名。对于以目录顶部 (包括顶部本身)为根的树中的每个目录,它会生成一个dirpath组( dirpathdirnamesfilenames )。


    >>> 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
    • 通过重复出现子文件夹来完成繁重的工作


  1. [Python 3]:glob。 globpathname,*,recursive = False[Python 3]: glob。iglobpathname,*,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
    • 允许基于名称进行高级过滤(由于通配符)


  1. [Python 3]:类 pathlib。 路径* pathsegmentsPython 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风格
    • 提供许多功能


  1. [Python 2]:dircache.listdir(path) (仅适用于Python 2


    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


  1. [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是从结构 dirent64ctypes 的表示[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']]


  1. [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']

    注意事项


  1. 安装一些(其他)可以解决问题的第三方程序包
    • 最有可能依赖于上述一项(或多项)(可能需要进行一些自定义)


注意事项

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

    • 平台( NixWin ,)
    • Python版本(2、3,)
  • 在上述变体中使用了多种路径样式(绝对路径,相对路径),以说明以下事实:所使用的 “工具” 在此方向上是灵活的

  • os.listdiros.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版本 / 版本之间略有不同,则解析代码也应进行调整;否则,可能会导致错误。更不用说语言环境之间的差异了)。

我真的很喜欢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 库模块中可以找到的一些功能的强大功能。

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