python如何获取一个文件夹下的所有文件名_python os模块遍历目录文件方法

冰火之心

发布时间：2025-09-12 20:10:02

809人浏览过

来源于php中文网

原创

最直接的方法是使用os.listdir()获取指定路径下的文件和子目录名，若需递归遍历则使用os.walk()，结合os.path.join()和os.path.isdir()/isfile()可区分文件与目录，处理权限、隐藏文件等特殊情况时需添加异常捕获和过滤逻辑。

python如何获取一个文件夹下的所有文件名_python os模块遍历目录文件方法

Python中要获取一个文件夹下的所有文件名，最直接的方法通常是使用

os

模块里的

os.listdir()

函数，它能列出指定路径下的所有文件和子目录名。如果需要更深层次的遍历，比如包含子文件夹中的文件，那么

os.walk()

会是你的不二之选，它提供了一个递归遍历目录树的强大机制。

解决方案

说实话，每次遇到这种需求，我脑子里首先跳出来的就是

os

模块。它就像是Python和操作系统文件系统之间的一座桥梁，非常实用。

使用

os.listdir()

获取当前目录下的文件和文件夹名

如果你只需要获取某个特定文件夹（不包括其子文件夹）里的内容，

os.listdir()

是最简单直接的方式。它返回的是一个列表，里面包含了该路径下所有文件和子目录的名字。

import os

def list_files_in_directory(path):
    """
    获取指定路径下的所有文件和子目录名（非递归）。
    """
    if not os.path.exists(path):
        print(f"路径 '{path}' 不存在。")
        return []

    try:
        items = os.listdir(path)
        print(f"'{path}' 下的内容：")
        for item in items:
            print(item)
        return items
    except PermissionError:
        print(f"没有权限访问路径 '{path}'。")
        return []
    except Exception as e:
        print(f"发生错误：{e}")
        return []

# 示例用法
# 假设我们有一个名为 'my_folder' 的文件夹，里面有一些文件和子文件夹
# my_folder/
# ├── file1.txt
# ├── sub_folder_a/
# │   └── file_a1.py
# └── file2.log

# 先创建一个测试目录和文件，方便演示
test_dir = 'temp_test_dir'
if not os.path.exists(test_dir):
    os.makedirs(test_dir)
    with open(os.path.join(test_dir, 'report.txt'), 'w') as f:
        f.write('hello')
    with open(os.path.join(test_dir, 'data.csv'), 'w') as f:
        f.write('1,2,3')
    os.makedirs(os.path.join(test_dir, 'nested_dir'))
    with open(os.path.join(test_dir, 'nested_dir', 'config.json'), 'w') as f:
        f.write('{}')

print("--- 使用 os.listdir() ---")
list_files_in_directory(test_dir)

# 清理测试目录
# import shutil
# if os.path.exists(test_dir):
#     shutil.rmtree(test_dir)

这里需要注意的是，

os.listdir()

返回的只是文件名或目录名，不包含它们的完整路径。如果你想对这些文件做进一步操作，比如读取内容，你就得自己用

os.path.join()

把路径拼接起来。

立即学习“Python免费学习笔记（深入）”；

使用

os.walk()

进行递归遍历

当你的需求是遍历整个目录树，包括所有子目录下的文件时，

os.walk()

就显得无比强大了。它会生成器，每次迭代都会返回一个三元组

(root, dirs, files)

。

```
root
```
：当前正在遍历的目录的路径。
```
dirs
```
：
```
root
```
下所有子目录的列表。
```
files
```
：
```
root
```
下所有文件的列表。

这个设计非常巧妙，它让你能在一个循环里同时处理当前目录、子目录列表和文件列表。

import os

def walk_through_directory(path):
    """
    递归遍历指定路径下的所有文件和目录。
    """
    if not os.path.exists(path):
        print(f"路径 '{path}' 不存在。")
        return

    print(f"\n--- 使用 os.walk() 遍历 '{path}' ---")
    try:
        for root, dirs, files in os.walk(path):
            print(f"\n当前目录: {root}")
            print(f"子目录: {dirs}")
            print(f"文件: {files}")

            # 我们可以这样获取所有文件的完整路径
            for file in files:
                full_file_path = os.path.join(root, file)
                print(f"找到文件: {full_file_path}")
    except PermissionError:
        print(f"没有权限访问路径 '{path}' 或其子目录。")
    except Exception as e:
        print(f"发生错误：{e}")

# 示例用法
walk_through_directory(test_dir)

os.walk()

的强大之处在于，它帮你处理了递归的逻辑，你只需要关注每个层级下的内容即可。

目录遍历时如何区分文件与子目录？——os.path.join与os.path.isdir的妙用

这是个非常常见的问题，

os.listdir()

虽然能列出所有条目，但它不会告诉你哪些是文件，哪些是目录。单纯看名字，你可分不出来。这时候，

os.path

模块就派上用场了，特别是

os.path.join()

、

os.path.isdir()

和

os.path.isfile()

这几个函数。

首先，

os.listdir()

返回的只是一个相对名字，比如

file1.txt

或

sub_folder_a

。要判断它们的类型，你必须先得到它们的完整路径。

os.path.join()

就是用来干这个的，它能智能地拼接路径，自动处理不同操作系统下的路径分隔符（比如Windows的

和Linux的

）。

import os

def distinguish_files_and_dirs(path):
    """
    遍历指定路径，并区分文件和子目录。
    """
    if not os.path.exists(path):
        print(f"路径 '{path}' 不存在。")
        return

    print(f"\n--- 区分 '{path}' 下的文件和目录 ---")
    try:
        items = os.listdir(path)
        for item in items:
            full_path = os.path.join(path, item) # 拼接成完整路径
            if os.path.isdir(full_path):
                print(f"[目录]: {full_path}")
            elif os.path.isfile(full_path):
                print(f"[文件]: {full_path}")
            else:
                print(f"[其他]: {full_path}") # 比如软链接、管道等
    except PermissionError:
        print(f"没有权限访问路径 '{path}'。")
    except Exception as e:
        print(f"发生错误：{e}")

# 示例用法
distinguish_files_and_dirs(test_dir)

os.path.isdir(full_path)

会检查

full_path

是否指向一个目录，而

os.path.isfile(full_path)

则检查它是否指向一个普通文件。这样一来，即使

os.listdir()

只给了你名字，你也能通过这些辅助函数，准确地识别出它们的“身份”。这个组合拳，在处理文件系统操作时，简直是家常便饭。

递归遍历目录：os.walk()的深度解析与实践

前面简单提到了

os.walk()

，但它的强大远不止于此。我个人觉得，如果你需要处理的目录结构比较复杂，或者你压根不知道目录有多深，

os.walk()

几乎是唯一的、最优雅的选择。它不像你手动写递归函数那样容易出错，而且性能也相当不错。

os.walk()

的核心思想是“自顶向下”（top-down）遍历，默认情况下是这样。它会先访问父目录，然后是其子目录，再到子目录的子目录，以此类推。每次迭代返回的

(root, dirs, files)

三元组，给了你极大的控制权。

Short AI

AI短视频生成器，轻松创作爆款短视频！

下载

root
: 当前正在访问的目录的完整路径。
dirs
:
```
root
```
目录下的所有子目录的名称列表。这个列表是可修改的！这是
```
os.walk()
```
最酷的地方之一。如果你修改了这个列表（比如删除某个子目录名），
```
os.walk()
```
就不会再进入那个子目录进行遍历。这对于“剪枝”操作非常有用，比如你只想遍历某些特定类型的目录，或者跳过一些你知道不需要处理的目录。
files
:
```
root
```
目录下的所有文件的名称列表。

让我们看一个更实际的例子：如何找到一个目录下所有扩展名为

.txt

的文件，并且跳过任何名为

temp

的子目录。

import os

def find_txt_files_and_prune(start_path):
    """
    递归查找所有 .txt 文件，并跳过名为 'temp' 的子目录。
    """
    if not os.path.exists(start_path):
        print(f"起始路径 '{start_path}' 不存在。")
        return []

    found_txt_files = []
    print(f"\n--- 深度解析 os.walk()：查找 .txt 文件并剪枝 ---")
    try:
        for root, dirs, files in os.walk(start_path):
            # 这是一个关键点：修改 dirs 列表来剪枝
            # 创建一个临时列表来存储需要继续遍历的目录
            dirs_to_keep = [d for d in dirs if d != 'temp'] 
            # 清空原始 dirs 列表，然后用我们筛选过的列表填充
            dirs[:] = dirs_to_keep # 注意这里是原地修改，非常重要！

            print(f"\n当前遍历到: {root}")
            print(f"将要遍历的子目录: {dirs}") # 打印修改后的 dirs

            for file in files:
                if file.endswith('.txt'):
                    full_path = os.path.join(root, file)
                    found_txt_files.append(full_path)
                    print(f"发现 .txt 文件: {full_path}")
        return found_txt_files
    except PermissionError:
        print(f"没有权限访问路径 '{start_path}' 或其子目录。")
        return []
    except Exception as e:
        print(f"发生错误：{e}")
        return []

# 额外创建一些测试文件和目录来演示剪枝
temp_dir_to_skip = os.path.join(test_dir, 'temp')
if not os.path.exists(temp_dir_to_skip):
    os.makedirs(temp_dir_to_skip)
    with open(os.path.join(temp_dir_to_skip, 'ignore_me.txt'), 'w') as f:
        f.write('This should not be found.')
with open(os.path.join(test_dir, 'another.txt'), 'w') as f:
    f.write('Another text file.')

# 示例用法
find_txt_files_and_prune(test_dir)

# 清理测试目录
import shutil
if os.path.exists(test_dir):
    shutil.rmtree(test_dir)

通过修改

dirs

列表，我们有效地控制了

os.walk()

的遍历路径，这比在循环内部做复杂的条件判断要高效和直观得多。此外，

os.walk()

还有一个

topdown

参数，设置为

False

时，它会先遍历子目录中的内容，再回到父目录，这在某些需要先处理叶子节点（比如删除文件）的场景下很有用。

处理特殊情况与常见陷阱：权限问题、隐藏文件与编码

文件系统操作从来都不是一帆风顺的，总会遇到一些“小麻烦”。作为一名真实的作者，我深知这些坑，所以在这里分享一些经验，希望能帮你少踩雷。

1. 权限问题（PermissionError）

这是最常见的错误之一。当你尝试访问一个没有读取权限的目录或文件时，Python会抛出

PermissionError

。比如，在Linux或macOS上，有些系统目录（如

/proc

、

/sys

）就不能随便访问。

解决方案： 最直接有效的方法就是使用

try-except

块来捕获这个错误。当你遍历目录时，如果遇到权限问题，可以简单地跳过那个目录，或者记录下来以便后续处理。

import os

def handle_permission_error(path):
    print(f"\n--- 处理权限错误示例 ---")
    try:
        # 尝试访问一个可能没有权限的目录，这里用一个不存在的路径模拟
        # 在实际环境中，你可能需要尝试访问如 '/root' (Linux) 或其他受限目录
        # 这里为了演示，我们假设 test_dir 中的某个子目录会触发权限错误
        # 实际上，os.walk 会在遇到无法访问的目录时抛出错误

        for root, dirs, files in os.walk(path):
            print(f"正在访问: {root}")
            # 模拟一个子目录没有权限，把它从 dirs 中移除，这样 os.walk 就不会尝试进入
            # 实际场景中，错误会在 os.walk 尝试进入该目录时抛出
            if 'restricted_dir' in dirs:
                print(f"发现受限目录 'restricted_dir'，跳过。")
                dirs.remove('restricted_dir') # 这样 os.walk 就不会进入这个目录了

            for file in files:
                full_path = os.path.join(root, file)
                # 尝试对文件进行操作，这里可能会触发权限错误
                # 比如 os.remove(full_path)
                pass

    except PermissionError as e:
        print(f"捕获到权限错误: {e}")
        print(f"无法访问路径 '{e.filename}'，请检查权限。")
    except Exception as e:
        print(f"发生其他错误: {e}")

# handle_permission_error('/root') # 实际测试时，请用你系统上一个你知道没权限的目录
# 这里我们用一个普通目录来演示 try-except 结构
# 为了演示，我们不真的去制造权限错误，而是展示如何捕获

2. 隐藏文件和目录

不同操作系统对隐藏文件有不同的约定。在Linux和macOS上，以

开头的目录或文件通常是隐藏的（比如

.bashrc

.git

）。在Windows上，文件或目录可能被设置了“隐藏”属性。

解决方案：

os.listdir()

和

os.walk()

默认都会列出这些隐藏文件。如果你想过滤掉它们，就需要自己写逻辑。

import os

def filter_hidden_items(path):
    """
    过滤掉以 '.' 开头的隐藏文件和目录。
    """
    print(f"\n--- 过滤隐藏文件和目录 ---")
    try:
        for root, dirs, files in os.walk(path):
            # 过滤隐藏目录
            dirs[:] = [d for d in dirs if not d.startswith('.')]

            print(f"\n当前目录 (非隐藏): {root}")
            print(f"子目录 (非隐藏): {dirs}")

            # 过滤隐藏文件
            non_hidden_files = [f for f in files if not f.startswith('.')]
            for file in non_hidden_files:
                full_path = os.path.join(root, file)
                print(f"发现非隐藏文件: {full_path}")
    except Exception as e:
        print(f"发生错误：{e}")

# 创建一个隐藏文件和目录来测试
test_dir_hidden = 'temp_test_dir_with_hidden'
if not os.path.exists(test_dir_hidden):
    os.makedirs(test_dir_hidden)
    with open(os.path.join(test_dir_hidden, 'visible.txt'), 'w') as f:
        f.write('visible')
    with open(os.path.join(test_dir_hidden, '.hidden_file.txt'), 'w') as f:
        f.write('hidden')
    os.makedirs(os.path.join(test_dir_hidden, '.hidden_dir'))
    with open(os.path.join(test_dir_hidden, '.hidden_dir', 'inside_hidden.txt'), 'w') as f:
        f.write('inside hidden')

filter_hidden_items(test_dir_hidden)

# 清理
import shutil
if os.path.exists(test_dir_hidden):
    shutil.rmtree(test_dir_hidden)

对于Windows的隐藏属性，你需要使用