Python 遍历目录树的方法是什么？

Question

我觉得分配文件和文件夹并执行 += [item] 部分有点黑客。有什么建议吗？我正在使用Python 3.2

from os import *
from os.path import *

def dir_contents(path):
    contents = listdir(path)
    files = []
    folders = []
    for i, item in enumerate(contents):
        if isfile(contents[i]):
            files += [item]
        elif isdir(contents[i]):
            folders += [item]
    return files, folders

Answer 1

在谷歌搜索相同的信息时，我发现了这个问题。

我在这里发布我在 http://www.pythoncentral.io/how-to-traverse-a-directory-tree-in-python-guide-to-os-walk/ （而不是只是发布 URL，以防链接失效）。

该页面包含一些有用的信息，并且还指向其他一些相关页面。

# Import the os module, for the os.walk function
import os

# Set the directory you want to start from
rootDir = '.'
for dirName, subdirList, fileList in os.walk(rootDir):
    print('Found directory: %s' % dirName)
    for fname in fileList:
        print('\t%s' % fname)

Answer 2

我还没有对此进行广泛的测试，但我相信
这将扩展 os.walk 生成器，将目录名连接到所有文件路径，并展平结果列表；给出搜索路径中具体文件的直接列表。

import itertools
import os

def find(input_path):
    return itertools.chain(
        *list(
            list(os.path.join(dirname, fname) for fname in files)
            for dirname, _, files in os.walk(input_path)
        )
    )

Answer 3

import pathlib
import time

def prune_empty_dirs(path: pathlib.Path):
    for current_path in list(path.rglob("*"))[::-1]:
        if current_path.is_dir() and not any(current_path.iterdir()):
            current_path.rmdir()
            while current_path.exists():
                time.sleep(0.1)

Answer 4

我喜欢 os.walk() 结果的结构，但总体上更喜欢 pathlib。因此，我的懒惰解决方案只是从 os.walk() 返回的每个项目创建一个 Path 。

import os
import pathlib


def walk(path='bin'):
    for root, dirs, files in os.walk(path):
        root = pathlib.Path(root)
        dirs = [root / d for d in dirs]
        files = [root / f for f in files]
        yield root, dirs, files

Answer 5

对于那些想要深度遍历所有嵌套子目录的人来说，复制并粘贴代码：

• 使用 python 的递归调用和 os.listdir() ：

import os

count = 0
def deep_walk(mypath):
    global count
    for file in os.listdir(mypath):
        file_path = os.path.join(mypath, file)
        if os.path.isdir(file_path):
            deep_walk(file_path)
        else:
            count += 1
            print(file_path)

mypath="/tmp"
deep_walk(mypath)
print(f"Total file count: {count}")

• 使用 python 的标准库 os.listdir() 。 walk() ：

import os

def walk_dir(mypath):
    count = 0
    for root, dirs, files in os.walk(mypath):
        for file in files:
            file_path = os.path.join(root, file)
            count += 1
            print(file_path)
    print(f"Total file count: {count}")

mypath = "/tmp"
walk_dir(mypath)

不同之处在于，使用 os.walk() ，您不需要手动遍历每个子目录的每个目录，库会为您做这件事，无论你有多少个嵌套目录。

Answer 6

对于任何正在寻找“路径”行走方式的人：

from pathlib import Path
p=Path("some_path_you_want_to_walk")
for dirName, subdirList, fileList in p.walk():
    print(dirName, subdirList, fileList)

首先在 Python 3.12 中引入：
https://docs.python.org/ zh-cn/3.13/library/pathlib.html#pathlib.Path.walk

Answer 7

尝试使用 append 方法。

Answer 8

os.walk 和 os.scandir 是不错的选择，但是，我已经越来越多地使用 pathlib，并且可以使用 pathlib .glob() 或 .rglob() （递归 glob）方法：

root_directory = Path(".")
for path_object in root_directory.rglob('*'):
    if path_object.is_file():
        print(f"hi, I'm a file: {path_object}")
    elif path_object.is_dir():
        print(f"hi, I'm a dir: {path_object}")

Answer 9

看一下 os.walk 函数返回路径及其包含的目录和文件。这应该会大大缩短你的解决方案。

Answer 10

对于任何使用 pathlib 寻找解决方案的人 (< code>python >= 3.4)

from pathlib import Path

def walk(path): 
    for p in Path(path).iterdir(): 
        if p.is_dir(): 
            yield from walk(p)
            continue
        yield p.resolve()

# recursively traverse all files from current directory
for p in walk(Path('.')): 
    print(p)

# the function returns a generator so if you need a list you need to build one
all_files = list(walk(Path('.'))) 

但是，如上所述，这不会保留 os.walk 给出的自上而下的顺序

Answer 11

自 Python >= 3.4 起，存在生成器方法 Path.rglob。
因此，要处理 some/starting/path 下的所有路径，只需执行以下操作：

from pathlib import Path

path = Path('some/starting/path') 
for subpath in path.rglob('*'):
    # do something with subpath

To get all subpaths in a list do list(path.rglob('*')) 。
要仅获取带有 sql 扩展名的文件，请执行 list(path.rglob('*.sql'))。

Answer 12

如果你想递归地遍历所有文件，包括子文件夹中的所有文件，我相信这是最好的方法。

import os

def get_files(input):
    for fd, subfds, fns in os.walk(input):
       for fn in fns:
            yield os.path.join(fd, fn)

## now this will print all full paths

for fn in get_files(fd):
    print(fn)

Answer 13

另一个解决方案如何使用 pathlib 模块：

from pathlib import Path

for directory in Path('.').glob('**'):
    for item in directory.iterdir():
        print(item)

模式 ** 匹配当前目录并且所有子目录，递归地，以及方法 iterdir然后迭代每个目录的内容。当您在遍历目录树时需要更多控制时很有用。

Answer 14

def dir_contents(path):
    files,folders = [],[]
    for p in listdir(path):
        if isfile(p): files.append(p)
        else: folders.append(p)
    return files, folders

Answer 15

使用

items += [item]

事实上，由于多种原因，

1. 是不好的......

   append 方法已经完全为此而设计（将一个元素附加到列表末尾）

2. 您正在创建一个包含一个元素的临时列表，只是为了抛出把它带走。虽然在使用 Python 时，原始速度不应该是您首先关心的问题（否则您使用的是错误的语言），但无缘无故地浪费速度似乎并不正确。

3. 您使用的 Python 语言有点不对称...对于列表对象，编写 a += b 与编写 a = a + b 不同，因为前者修改对象，而第二个则分配一个新列表，如果对象 a 也可以使用其他方式访问，则这可以具有不同的语义。在您的特定代码中，情况似乎并非如此，但当其他人（或几年后您自己，同样）必须修改代码时，它可能会成为一个问题。 Python 甚至有一个方法 extend ，其语法不太微妙，专门用于处理您想要通过在末尾添加另一个列表的元素来就地修改列表对象的情况。

另外，正如其他人指出的那样，您的代码似乎正在尝试执行 os.walk 已经执行的操作...

Answer 16

从 Python 3.4 开始，出现了新模块 pathlib。因此，要获取所有目录和文件，可以执行以下操作：

from pathlib import Path

dirs = [str(item) for item in Path(path).iterdir() if item.is_dir()]
files = [str(item) for item in Path(path).iterdir() if item.is_file()]

Answer 17

我没有使用内置的 os.walk 和 os.path.walk，而是使用从我在其他地方建议的这段代码派生的代码，我最初链接到该代码，但已将其替换为内联源：

import os
import stat

class DirectoryStatWalker:
    # a forward iterator that traverses a directory tree, and
    # returns the filename and additional file information

    def __init__(self, directory):
        self.stack = [directory]
        self.files = []
        self.index = 0

    def __getitem__(self, index):
        while 1:
            try:
                file = self.files[self.index]
                self.index = self.index + 1
            except IndexError:
                # pop next directory from stack
                self.directory = self.stack.pop()
                self.files = os.listdir(self.directory)
                self.index = 0
            else:
                # got a filename
                fullname = os.path.join(self.directory, file)
                st = os.stat(fullname)
                mode = st[stat.ST_MODE]
                if stat.S_ISDIR(mode) and not stat.S_ISLNK(mode):
                    self.stack.append(fullname)
                return fullname, st

if __name__ == '__main__':
    for file, st in DirectoryStatWalker("/usr/include"):
        print file, st[stat.ST_SIZE]

它递归地遍历目录并且相当高效且易于阅读。

Answer 18

这是一个使用 os.scandir 并返回树结构的版本。使用 os.scandir 将返回 os.DirEntry 对象，该对象保存有关内存中路径对象的信息，允许在不调用文件系统的情况下查询有关项目的信息。

import os

def treedir(path):
    files = []
    folders = {}
    for entry in os.scandir(path):
        if entry.is_file():
            files.append(entry)
        elif entry.is_dir():
            folders[entry.name] = treedir(entry)
    result = {}
    if files:
        result['files'] = files
    if folders:
        result['folders'] = folders
    return result