5 методов итерации по файлам в Python: сравнение и применение

Для кого эта статья:

• Python-разработчики, желающие улучшить свои навыки работы с файлами и директориями
• Студенты и начинающие программисты, изучающие язык Python

• Специалисты, работающие с большими объемами данных и автоматизацией рутинных задач

  Работа с файлами в директориях – фундаментальный навык Python-разработчика. Будь то обработка логов, парсинг данных или управление ресурсами — итерация по файлам является повседневной задачей, решение которой может сэкономить часы рабочего времени. В арсенале Python есть минимум пять мощных методов, каждый с уникальными преимуществами. Правильный выбор между ними определяет эффективность и читаемость кода, а в некоторых случаях – критически влияет на производительность. Давайте разберемся, какой метод когда использовать и почему иногда код с 3 строками работает лучше, чем сложная конструкция. 🐍

Хотите полностью освоить работу с файловой системой в Python? В курсе Обучение Python-разработке от Skypro вы не только изучите все методы итерации по файлам, но и научитесь создавать эффективные скрипты для автоматизации рутинных задач. Наши студенты уже применяют эти навыки в реальных проектах, экономя до 40% рабочего времени на обработке данных. Учитесь у практиков!

Обзор методов итерации по файлам в Python

Python предлагает несколько подходов к итерации по файлам в директориях, каждый из которых имеет свои особенности и преимущества в зависимости от конкретной задачи. Понимание различий между этими методами позволяет выбрать оптимальное решение для вашего проекта.

Основные методы для работы с файлами в директориях включают:

• os.listdir() — базовый метод для получения списка файлов и подкаталогов
• os.walk() — рекурсивное перемещение по дереву каталогов
• glob.glob() — фильтрация файлов по шаблону
• pathlib.Path() — современный объектно-ориентированный подход
• scandir() — высокопроизводительная альтернатива для сложных задач

Когда сравнивать эти методы, важно учитывать несколько ключевых факторов:

Каждый из этих методов имеет свои сильные стороны. Например, os.listdir() является самым простым для понимания, но не предоставляет информацию о типе файла. В то же время pathlib.Path() предлагает элегантный интерфейс, но появился только в Python 3.4.

Теперь давайте рассмотрим каждый из этих методов подробнее, с конкретными примерами кода и сценариями использования. 🔍

os.listdir(): простой способ получения списка файлов

Метод os.listdir() — это самый простой и прямолинейный способ получить список файлов и папок в директории. Он возвращает список строк, содержащий имена всех элементов в указанной директории.

Артём Сидоров, Python-разработчик с 8-летним опытом

Столкнулся с интересным кейсом в проекте для финансового сектора. Нам нужно было обработать тысячи CSV-файлов с транзакциями, которые ежедневно поступали в определенную директорию. Первую версию я реализовал через os.listdir() из-за его простоты:

Python

Скопировать код

import os
import pandas as pd

transaction_dir = "daily_transactions"
for filename in os.listdir(transaction_dir):
if filename.endswith(".csv"):
file_path = os.path.join(transaction_dir, filename)
df = pd.read_csv(file_path)
# Обработка данных

Решение работало отлично при небольшом количестве файлов. Но когда система масштабировалась до обработки 10,000+ файлов ежедневно, стало очевидно, что нам нужен более гибкий подход. Тем не менее, для 90% повседневных задач os.listdir() остается моим go-to решением из-за его лаконичности и понятности.

Вот базовый пример использования os.listdir():

import os

directory = "/path/to/directory"
files = os.listdir(directory)

for file in files:
print(file)

Основные преимущества метода os.listdir():

• Простота использования — интуитивно понятный синтаксис
• Доступность — присутствует во всех версиях Python
• Минимальный код для получения списка файлов

Однако у него есть и ограничения:

• Не предоставляет информацию о типе файла (файл или директория)
• Нет встроенной поддержки рекурсивного обхода
• Необходимо вручную строить полные пути к файлам

Для фильтрации файлов по расширению с os.listdir() используется следующий паттерн:

import os

directory = "/path/to/directory"
files = os.listdir(directory)

# Фильтрация файлов с расширением .py
python_files = [file for file in files if file.endswith(".py")]

for python_file in python_files:
file_path = os.path.join(directory, python_file)
print(f"Python file: {file_path}")

Для определения типа элемента (файл или директория) необходимо дополнительно использовать функции из модуля os.path:

import os

directory = "/path/to/directory"
items = os.listdir(directory)

for item in items:
item_path = os.path.join(directory, item)
if os.path.isfile(item_path):
print(f"{item} is a file")
elif os.path.isdir(item_path):
print(f"{item} is a directory")

Метод os.listdir() идеально подходит для простых задач, где не требуется рекурсивный обход директорий и где структура каталогов заранее известна. Для более сложных сценариев лучше рассмотреть альтернативные методы. 📁

os.walk(): рекурсивная обработка вложенных директорий

Функция os.walk() представляет собой мощный инструмент для рекурсивного обхода дерева директорий. В отличие от os.listdir(), этот метод автоматически перемещается по всем подкаталогам, генерируя тройки значений: текущий каталог, список подкаталогов и список файлов в текущем каталоге.

Базовый синтаксис использования os.walk():

import os

root_dir = "/path/to/directory"

for dirpath, dirnames, filenames in os.walk(root_dir):
print(f"Текущая директория: {dirpath}")
print(f"Подкаталоги: {dirnames}")
print(f"Файлы: {filenames}")
print("-" * 50)

Основные преимущества os.walk():

• Автоматический рекурсивный обход всей структуры директорий
• Разделение файлов и директорий в результате
• Возможность модификации списка директорий во время обхода для управления процессом
• Предоставление полного пути к текущей директории

Один из типичных сценариев использования — поиск всех файлов определённого типа во всей структуре каталогов:

import os

root_dir = "/path/to/search"
extension = ".log"
result_files = []

for dirpath, dirnames, filenames in os.walk(root_dir):
for filename in filenames:
if filename.endswith(extension):
full_path = os.path.join(dirpath, filename)
result_files.append(full_path)

print(f"Найдено {len(result_files)} файлов с расширением {extension}")
for file_path in result_files:
print(file_path)

os.walk() предоставляет возможность управлять процессом обхода. Например, можно пропустить определённые директории:

import os

root_dir = "/path/to/directory"
dirs_to_skip = [".git", "node_modules", "__pycache__"]

for dirpath, dirnames, filenames in os.walk(root_dir):
# Модификация dirnames изменяет дальнейший обход
# Удаляем директории, которые не хотим обходить
dirnames[:] = [d for d in dirnames if d not in dirs_to_skip]

# Обработка файлов в текущей директории
for file in filenames:
print(os.path.join(dirpath, file))

Марина Ковалёва, Data Engineer

В одном из проектов по анализу логов мне пришлось обрабатывать несколько терабайт данных, распределённых по сложной структуре директорий. Задача: найти все логи с ошибками определённого типа.

Первоначально я использовала простой os.listdir() с вручную написанной рекурсией, но быстро столкнулась с проблемами производительности и понятности кода.

Python

Скопировать код

import os
import re

error_pattern = re.compile(r"ERROR.*Connection refused")
log_files_with_errors = []

def process_directory(directory):
for dirpath, dirnames, filenames in os.walk(directory):
for filename in filenames:
if filename.endswith(".log"):
file_path = os.path.join(dirpath, filename)
try:
with open(file_path, 'r', encoding='utf-8', errors='ignore') as file:
for line in file:
if error_pattern.search(line):
log_files_with_errors.append(file_path)
# Нашли ошибку, не нужно читать дальше
break
except Exception as e:
print(f"Ошибка при чтении {file_path}: {e}")

process_directory("/var/log/applications")
print(f"Найдено {len(log_files_with_errors)} файлов с искомой ошибкой")

Благодаря os.walk() код стал не только более элегантным, но и масштабируемым. Я смогла обработать всю структуру каталогов за один проход, не беспокоясь о глубине вложенности, а также легко добавить игнорирование определённых директорий (например, архивов).

Функция os.walk() имеет дополнительные параметры для тонкой настройки:

Пример использования параметров:

import os

root_dir = "/path/to/directory"

# Обработчик ошибок доступа
def handle_error(error):
print(f"Ошибка доступа: {error}")

# Обход снизу вверх с обработкой ошибок и следованием по символическим ссылкам
for dirpath, dirnames, filenames in os.walk(root_dir, topdown=False, 
onerror=handle_error, 
followlinks=True):
print(f"Обработка директории: {dirpath}")
# Дальнейшая обработка

os.walk() является идеальным выбором, когда нужно выполнить рекурсивный обход всей иерархии директорий с минимальным объемом кода. Это один из наиболее часто используемых методов для обработки файлов в сложных структурах каталогов. 🌲

glob.glob(): фильтрация файлов по шаблону имени

Модуль glob предоставляет функцию для поиска файлов по шаблонам, аналогичным тем, что используются в командной строке Unix. Это делает glob.glob() чрезвычайно удобным для поиска файлов с определёнными расширениями или соответствующих конкретным шаблонам именования.

Базовый синтаксис использования glob.glob():

import glob

# Найти все файлы Python в текущей директории
python_files = glob.glob("*.py")

# Вывести найденные файлы
for file_path in python_files:
print(file_path)

Модуль glob использует следующие специальные символы для построения шаблонов:

• * — соответствует любой последовательности символов
• ? — соответствует любому одиночному символу
• [seq] — соответствует любому символу из последовательности
• [!seq] — соответствует любому символу, не входящему в последовательность

Вот несколько примеров использования различных шаблонов:

import glob

# Все файлы с расширением .txt
text_files = glob.glob("*.txt")

# Файлы, имена которых состоят из одного символа с расширением .log
one_char_logs = glob.glob("?.log")

# Файлы, имена которых начинаются с 'data' и имеют любое расширение
data_files = glob.glob("data.*")

# Файлы, имена которых начинаются с 'log_' и содержат цифру
log_digit_files = glob.glob("log_*[0-9]*")

Для рекурсивного поиска файлов по шаблону во всех подкаталогах (начиная с Python 3.5) используется шаблон **:

import glob

# Рекурсивный поиск всех .jpg файлов в текущей директории и всех поддиректориях
all_jpg_files = glob.glob("**/*.jpg", recursive=True)

for file_path in all_jpg_files:
print(file_path)

glob.glob() особенно полезен в сценариях, где нужно быстро найти файлы по шаблону, например, при обработке всех файлов определенного типа:

import glob
import os

# Найти все файлы CSV в директории data и ее поддиректориях
csv_files = glob.glob("data/**/*.csv", recursive=True)

total_size = 0
for file_path in csv_files:
size = os.path.getsize(file_path)
total_size += size
print(f"{file_path}: {size} bytes")

print(f"Общий размер CSV файлов: {total_size} bytes")

Если вам нужен итератор вместо списка (для экономии памяти при работе с большим количеством файлов), можно использовать glob.iglob():

import glob

# Итератор для всех файлов .log во всех поддиректориях
log_files_iterator = glob.iglob("**/*.log", recursive=True)

# Обработка файлов по одному, без загрузки всех имен в память
for file_path in log_files_iterator:
with open(file_path, 'r') as file:
# Обработка содержимого файла
pass

Сравнение glob.glob() с другими методами:

• По сравнению с os.listdir(): проще фильтровать файлы по шаблону имени
• По сравнению с os.walk(): более компактный код для поиска конкретных типов файлов
• По сравнению с pathlib: более старый и широко поддерживаемый интерфейс, хотя менее объектно-ориентированный

Метод glob.glob() идеально подходит для сценариев, где требуется быстро найти файлы, соответствующие определенному шаблону имени, особенно когда структура шаблонов сложная или включает специальные символы. 🔍

pathlib.Path(): объектно-ориентированный подход к файлам

Модуль pathlib, введенный в Python 3.4, предлагает объектно-ориентированный подход к работе с файловыми путями. Класс Path представляет путь в файловой системе и предоставляет методы для удобной навигации, создания, изменения и анализа путей.

Базовое использование pathlib.Path() для итерации по файлам:

from pathlib import Path

# Создаем объект пути
directory = Path("/path/to/directory")

# Итерация по всем файлам в директории
for file_path in directory.iterdir():
if file_path.is_file():
print(f"Файл: {file_path.name}")
elif file_path.is_dir():
print(f"Директория: {file_path.name}")

Ключевые преимущества использования pathlib включают:

• Объектно-ориентированный дизайн, упрощающий работу с путями
• Операции с путями становятся более интуитивными (использование оператора /)
• Встроенные методы для проверки типа файла (isfile(), isdir())
• Методы для работы с расширениями и частями имен файлов (suffix, stem)
• Кросс-платформенная работа без необходимости использовать os.path.join

Для фильтрации файлов по расширению с помощью pathlib:

from pathlib import Path

directory = Path("/path/to/directory")

# Найти все Python файлы
python_files = list(directory.glob("*.py"))

for py_file in python_files:
print(f"Python файл: {py_file.name}")
print(f"Размер: {py_file.stat().st_size} bytes")

Для рекурсивного обхода директорий используется метод glob() с шаблоном **:

from pathlib import Path

directory = Path("/path/to/directory")

# Рекурсивно найти все JSON файлы
json_files = list(directory.glob("**/*.json"))

print(f"Найдено {len(json_files)} JSON файлов:")
for json_file in json_files:
print(json_file)

pathlib также предоставляет удобные методы для работы с содержимым файлов:

from pathlib import Path

# Чтение содержимого файла
file_path = Path("example.txt")
content = file_path.read_text()
print(content)

# Запись в файл
new_file = Path("new_file.txt")
new_file.write_text("Это содержимое нового файла")

# Добавление к существующему файлу
with new_file.open("a") as f:
f.write("\nЭта строка добавлена в конец файла")

Одно из главных преимуществ pathlib — работа с компонентами пути:

from pathlib import Path

file_path = Path("/home/user/documents/report.pdf")

print(f"Имя файла: {file_path.name}") # report.pdf
print(f"Расширение: {file_path.suffix}") # .pdf
print(f"Имя без расширения: {file_path.stem}") # report
print(f"Родительская директория: {file_path.parent}") # /home/user/documents

# Проверка существования
if file_path.exists():
print("Файл существует")
else:
print("Файл не существует")

# Создание новой директории
new_dir = Path("/home/user/new_directory")
new_dir.mkdir(exist_ok=True)

pathlib упрощает манипуляции с путями, которые были бы громоздкими с использованием модулей os.path:

from pathlib import Path

# Объединение путей с помощью оператора /
base_dir = Path("/home/user")
config_file = base_dir / "config" / "settings.json"

print(config_file) # /home/user/config/settings.json

# Поиск всех файлов с определенным именем
for config in Path("/etc").glob("**/config.ini"):
print(f"Найден конфигурационный файл: {config}")

Сравнение производительности pathlib и традиционных методов показывает, что для большинства повседневных задач pathlib обеспечивает сопоставимую производительность, предлагая при этом более чистый и понятный код.

pathlib.Path() является рекомендуемым способом работы с файловой системой для новых проектов на Python 3.4+, объединяя лучшие функции различных модулей работы с файлами в единый, последовательный интерфейс. 🔄

Сравнение производительности методов итерации

При выборе метода итерации по файлам важно учитывать не только удобство использования, но и производительность, особенно при работе с большими директориями или глубоко вложенной структурой каталогов. Давайте сравним производительность разных методов на практических примерах.

Для объективного сравнения я провел тестирование пяти методов на директории с различным количеством файлов и уровнями вложенности. Результаты представлены ниже:

Для тестирования использовался следующий код:

import os
import glob
import time
from pathlib import Path

def test_listdir(directory):
start_time = time.time()
files = []
for item in os.listdir(directory):
path = os.path.join(directory, item)
if os.path.isfile(path):
files.append(path)
end_time = time.time()
return end_time – start_time, len(files)

def test_walk(directory):
start_time = time.time()
files = []
for root, dirs, filenames in os.walk(directory):
for filename in filenames:
files.append(os.path.join(root, filename))
end_time = time.time()
return end_time – start_time, len(files)

def test_glob(directory):
start_time = time.time()
files = glob.glob(os.path.join(directory, "**"), recursive=True)
files = [f for f in files if os.path.isfile(f)]
end_time = time.time()
return end_time – start_time, len(files)

def test_pathlib(directory):
start_time = time.time()
p = Path(directory)
files = [f for f in p.glob("**/*") if f.is_file()]
end_time = time.time()
return end_time – start_time, len(files)

def test_scandir(directory):
start_time = time.time()
files = []
for entry in os.scandir(directory):
if entry.is_file():
files.append(entry.path)
end_time = time.time()
return end_time – start_time, len(files)

Ключевые выводы из анализа производительности:

1. os.scandir() демонстрирует наивысшую производительность за счет оптимизированного доступа к метаданным файлов.
2. os.listdir() показывает хорошие результаты для простого получения списка файлов, но требует дополнительных вызовов для проверки типа файла.
3. pathlib.Path().iterdir() имеет небольшие накладные расходы из-за создания объектов Path, но обеспечивает более удобный интерфейс.
4. os.walk() является наиболее медленным для простой итерации, но эффективен при необходимости рекурсивного обхода вложенных директорий.
5. glob.glob() показывает среднюю производительность, но добавляет ценную возможность фильтрации по шаблону.

При выборе метода итерации стоит учитывать специфику задачи:

• Для максимальной производительности при работе с крупными директориями: os.scandir()
• Для простого перебора файлов в одной директории: os.listdir()
• Для рекурсивного обхода со сложной логикой: os.walk()
• Для фильтрации по шаблону имени файла: glob.glob()
• Для современного, объектно-ориентированного кода: pathlib.Path()

Интересный факт: производительность методов может существенно различаться в зависимости от операционной системы. Например, os.walk() на Windows может работать медленнее, чем на Linux из-за различий в реализации файловой системы.

Практические рекомендации по оптимизации производительности:

# Оптимизированная функция для подсчета файлов определенного типа
def count_files_by_extension(directory, extension):
count = 0
# Используем самый быстрый метод
for entry in os.scandir(directory):
if entry.is_file() and entry.name.endswith(extension):
count += 1
return count

# Пример использования
py_files_count = count_files_by_extension("/path/to/project", ".py")
print(f"Python файлов: {py_files_count}")

Помните, что производительность — это только один из факторов при выборе метода итерации. Для большинства повседневных задач разница в миллисекундах не имеет значения, и более важными становятся читаемость кода и удобство использования. 🚀

Разобрав пять методов итерации по файлам в директориях на Python, можно сделать важный вывод: универсального решения не существует. Каждый метод имеет свою область применения, сильные и слабые стороны. Для небольших задач os.listdir() и glob.glob() предлагают простоту и понятность. При работе со сложными иерархиями файлов os.walk() незаменим. Для современных проектов pathlib.Path() обеспечивает элегантность и выразительность кода. Что действительно важно — это осознанный выбор инструмента, соответствующего конкретной задаче, и понимание принципов его работы.