Python进阶指南：如何高效获取目录文件列表及其大小

2026-02-13 12:03:34 0条评论 2次阅读 0人点赞

在日常的开发工作中，我们经常需要处理文件系统相关的任务。比如，你可能需要编写一个脚本来清理某个目录下超过一定大小的日志文件，或者仅仅是想要分析某个项目文件夹的存储占用情况。这时候，仅仅获取文件名是不够的，我们还需要精确地掌握每个文件的大小信息。

在本文中，我们将不仅回顾经典的 OS 模块用法，还将深入探讨如何结合 2026 年的现代 Python 特性、性能优化以及 AI 辅助开发思维，来编写更健壮、更高效的文件处理脚本。准备好，让我们开始这场文件系统的深度探索之旅吧！

为什么我们需要关注文件大小？

在开始写代码之前，让我们先聊聊为什么这个需求在 2026 年依然如此常见且重要。随着数据爆炸和边缘计算的兴起，本地文件系统的管理变得比以往任何时候都关键：

成本与存储优化：在云原生时代，存储虽然便宜，但 I/O 成本依然高昂。快速定位大文件有助于我们优化分层存储策略。
数据清洗与 ETL：在处理数据集时，过滤掉损坏文件（大小为 0）或异常大的离群值是保证 AI 模型训练质量的第一步。
DevSecOps 与审计：监控关键日志文件的大小，防止因日志未轮转导致的磁盘满载引发的宕机事故。

核心工具箱：Python 的 OS 模块与现代替代品

Python 中的 OS 模块（Operating System Interface）是我们与操作系统进行交互的基石。它属于标准库，意味着无需 pip 安装即可开箱即用。然而，在 2026 年的现代开发中，我们更推荐使用 pathlib 模块。

INLINECODEcf8c5eed 是传统的字符串操作，而 INLINECODE03331a8a 则是面向对象的路径操作。我们将对比这两者的使用场景，帮你做出最佳选择。

实战演练 1：基础回顾与 Pythonic 写法

让我们从最基础的场景开始。假设我们有一个文件夹，我们想列出其中所有的文件，并显示它们的大小。在这个例子中，我们将对比传统 INLINECODE5629c0bc 写法与现代 INLINECODE65e5c8b6 写法。

#### 传统写法：使用 OS 模块

这是老一辈 Python 开发者最熟悉的代码风格，虽然在 2026 年略显复古，但在维护遗留系统时你依然随处可见。

import os

# 设定我们要操作的目录路径
path = os.getcwd()

def convert_bytes(size_bytes):
    """辅助函数：将字节数转换为更易读的格式"""
    for unit in [‘B‘, ‘KB‘, ‘MB‘, ‘GB‘, ‘TB‘]:
        if size_bytes < 1024.0:
            return f"{size_bytes:.2f} {unit}"
        size_bytes /= 1024.0
    return f"{size_bytes:.2f} PB"

print(f"正在分析目录: {path}")
print("-" * 50)

for entry in os.listdir(path):
    full_path = os.path.join(path, entry)
    
    # 检查它是否是一个文件
    if os.path.isfile(full_path):
        size = os.path.getsize(full_path)
        print(f"文件: {entry:<30} 大小: {convert_bytes(size)}")

#### 现代写法：使用 Pathlib

在 2026 年，我们更推荐这种写法。代码更易读，且自动处理了操作系统的路径分隔符问题。

from pathlib import Path

# 使用 Path 对象代表目录
path = Path.cwd() 

# Path.glob(‘*‘) 匹配所有文件，.isfile() 依然有效，但我们可以利用 .stat() 获取更多信息
print(f"正在分析目录: {path}")
print("-" * 50)

for file in path.iterdir():
    if file.is_file():
        # file.stat() 返回 os.stat_result 对象
        size = file.stat().st_size
        print(f"文件: {file.name:<30} 大小: {size} bytes")

实战演练 2：高性能并发处理（2026 必备技能）

随着核心数的增加，传统的单线程 I/O 阻塞脚本已经无法满足我们对速度的要求。当我们处理包含数万文件的目录（如对象存储的本地缓存）时，性能是首要考虑因素。

这里我们将使用 concurrent.futures 进行多线程 I/O 密集型操作。这在处理机械硬盘或网络文件系统（NFS/SMB）时效果显著。

import os
import concurrent.futures

def get_file_info(full_path):
    """
    工作线程函数：获取单个文件的大小信息
    包含异常处理，防止单个文件损坏导致整体崩溃
    """
    try:
        if os.path.isfile(full_path):
            size = os.path.getsize(full_path)
            return (full_path, size)
    except (OSError, PermissionError):
        # 在生产环境中，这里应该记录日志而不是静默失败
        return None
    return None

def analyze_directory_parallel(path="."):
    files_info = []
    entries = os.listdir(path)
    
    # 使用 ThreadPoolExecutor 进行并发 I/O
    # max_workers 建议设置为 CPU 核心数的倍数，或者针对 I/O 密集型任务设置更高
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
        # 提交所有任务
        future_to_path = {executor.submit(get_file_info, os.path.join(path, entry)): entry for entry in entries}
        
        for future in concurrent.futures.as_completed(future_to_path):
            result = future.result()
            if result:
                files_info.append(result)
    
    # 按大小降序排序
    files_info.sort(key=lambda x: x[1], reverse=True)
    
    print(f"{‘文件名‘:10}")
    print("-" * 60)
    for name, size in files_info[:10]: # 只打印前10个最大的文件
        print(f"{name:10.2f} MB")

# 让我们思考一下这个场景：
# 如果你在处理一个包含 100,000 个小图片的数据集文件夹，
# 单线程可能需要 10 秒，而并发处理可能只需要 1.2 秒。
# 这在自动化管线中是巨大的时间节省。
analyze_directory_parallel()

深入理解：为什么并发能加速 IO？

我们来看一个实际的对比案例。我们在最近的一个云原生项目中需要扫描数百万个日志片段。

同步代码：CPU 大部分时间在等待硬盘响应（I/O Wait），利用率极低。
多线程代码：当一个线程在等待硬盘返回数据时，操作系统立即切换到另一个线程请求下一个文件。这使得硬盘的磁头（对于机械硬盘）或总线（对于 SSD）始终保持忙碌。

实战演练 3：实战中的陷阱与工程化解决方案

在生产环境中，代码并不是运行在真空里的。让我们聊聊你可能遇到的“坑”以及我们是如何解决的。

#### 1. 权限错误的优雅处理

直接使用 INLINECODE3c2373a3 遍历根目录 INLINECODEad00582a 或 Windows INLINECODEca10276c 时，遇到系统文件夹往往会导致 INLINECODE35fe734d 直接让脚本崩溃。

解决方案：使用 try...except 包裹具体的操作逻辑，而不是包裹整个循环。

import os

def safe_walk(directory):
    for dirpath, dirnames, filenames in os.walk(directory):
        try:
            for filename in filenames:
                full_path = os.path.join(dirpath, filename)
                # 业务逻辑
                # ...
        except PermissionError:
            # 忽略无权访问的文件，但继续处理下一个
            # 建议：使用 logging 模块记录警告
            print(f"Warning: Permission denied for {dirpath}")
            continue

#### 2. 符号链接的陷阱

如果你不小心，os.walk 可能会顺着符号链接进入无限循环（比如链接到父目录）。

解决方案：在 2026 年，我们利用 INLINECODE991f4722 或 INLINECODEf399c6c0 的参数来处理，或者在代码中显式检测。

# 使用 pathlib 检测是否为链接
from pathlib import Path

p = Path(‘some_link‘)
if p.is_symlink():
    print("这是一个符号链接，跳过以防止循环。")
else:
    print(f"大小: {p.stat().st_size}")

#### 3. 可观测性：不仅是打印结果

在工程化实践中，我们需要结构化输出，而不是 print 字符串。让我们结合 Python 的数据类（Data Class）来构建一个更专业的分析报告。

from dataclasses import dataclass
from typing import List
import os

@dataclass
class FileReport:
    path: str
    size: int
    is_large: bool = False

def generate_report(directory: str, size_threshold_mb: int = 100) -> List[FileReport]:
    reports = []
    for root, _, files in os.walk(directory):
        for file in files:
            full_path = os.path.join(root, file)
            try:
                size = os.path.getsize(full_path)
                is_large = size > (size_threshold_mb * 1024 * 1024)
                reports.append(FileReport(full_path, size, is_large))
            except OSError:
                continue
    return reports

# 使用示例
# 这使得我们可以轻松地将数据传递给前端 API 或者写入 JSON 数据库
repo = generate_report(".")
for r in repo:
    if r.is_large:
        print(f"[Alert] {r.path} is large!")

总结：从脚本到工程

今天，我们不仅回顾了如何使用 Python 获取文件大小，更重要的是，我们探讨了如何像一名 2026 年的资深工程师那样思考：

选择合适的工具：优先使用 pathlib 处理路径，其面向对象的特性让代码更健壮。
性能意识：面对海量文件，不要犹豫，使用 concurrent.futures 进行并发加速。
工程化思维：时刻考虑权限、异常处理以及输出的结构化（JSON/对象），而不是简单的文本打印。
安全第一：注意符号链接陷阱，避免无限循环。

在编写你的下一个磁盘清理脚本或数据预处理管线时，试着应用这些原则。你会发现，你的代码不仅运行得更快，而且在面对复杂的真实环境时更加从容。祝你编码愉快！

投稿给我们	如何建站？
vps是什么？	如何安装宝塔？
如何通过博客赚钱？	便宜wordpress托管方案
免费wordpress主题	这些都是免费方案

豆丁博客