5 способов получить список подкаталогов в Python: обзор методов

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

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

• Изучающие Python и желающие улучшить свои знания о работе с файловыми системами

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

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

5 способов получения списка подкаталогов в Python

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

Давайте рассмотрим пять основных методов, которые можно использовать для получения списка подкаталогов:

• Классический подход с использованием os.listdir() и os.path.isdir()
• Современный объектно-ориентированный метод с pathlib
• Рекурсивный обход с помощью os.walk()
• Использование glob-шаблонов для фильтрации
• Применение scandir() для повышенной производительности

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

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

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

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

Переход на os.scandir() дал нам прирост производительности в 2-3 раза, поскольку этот метод за один системный вызов получает как имена файлов, так и их мета-информацию. Для некоторых критичных компонентов мы даже написали расширение на C, но в большинстве случаев встроенных средств Python было достаточно при правильном выборе метода.

Базовый метод: os.listdir() и os.path.isdir() в связке

Самый классический и понятный способ получения списка подкаталогов в Python — использовать комбинацию функций os.listdir() и os.path.isdir(). Этот метод доступен во всех версиях Python и обеспечивает высокую переносимость кода.

Основной принцип работы:

1. Получаем список всех элементов в директории с помощью os.listdir()
2. Фильтруем только те элементы, которые являются директориями, используя os.path.isdir()

Реализация этого подхода выглядит следующим образом:

import os

def get_subdirectories(path):
"""
Получает список всех подкаталогов в указанной директории.

Args:
path (str): Путь к директории для поиска подкаталогов

Returns:
list: Список имен подкаталогов
"""
# Получаем список всех элементов в директории
all_items = os.listdir(path)

# Фильтруем только директории
subdirectories = []
for item in all_items:
item_path = os.path.join(path, item)
if os.path.isdir(item_path):
subdirectories.append(item)

return subdirectories

# Пример использования
directories = get_subdirectories('/path/to/directory')
print(directories)

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

import os

def get_subdirectories_compact(path):
return [item for item in os.listdir(path) 
if os.path.isdir(os.path.join(path, item))]

Преимущества этого метода:

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

Недостатки:

• Требует двух отдельных вызовов для каждого элемента (получение списка и проверка типа)
• Может быть неэффективным при работе с большими директориями
• Не самое элегантное решение с точки зрения современного Python

Этот метод хорошо подходит для скриптов, которые должны работать в различных средах, включая устаревшие версии Python, а также для случаев, когда простота кода важнее производительности. 🔧

Современное решение: pathlib для работы с подкаталогами

С выходом Python 3.4 появилась библиотека pathlib, которая предоставляет объектно-ориентированный интерфейс для работы с путями файловой системы. Это более современный и элегантный способ работы с директориями, который существенно упрощает код и делает его более читаемым. 🚀

Модуль pathlib представляет пути как объекты, а не как строки, что позволяет выполнять операции с путями более интуитивно. Для получения списка подкаталогов можно использовать метод iterdir() в сочетании с методом is_dir():

from pathlib import Path

def get_subdirectories_pathlib(directory):
"""
Получает список всех подкаталогов в указанной директории используя pathlib.

Args:
directory (str): Путь к директории для поиска подкаталогов

Returns:
list: Список объектов Path, представляющих подкаталоги
"""
# Создаем объект Path
path = Path(directory)

# Получаем только поддиректории
subdirectories = [item for item in path.iterdir() if item.is_dir()]

return subdirectories

# Пример использования
directories = get_subdirectories_pathlib('/path/to/directory')
for directory in directories:
print(directory.name) # Выводим только имена директорий

Если требуется получить только имена директорий, а не полные пути:

def get_subdirectory_names(directory):
path = Path(directory)
return [item.name for item in path.iterdir() if item.is_dir()]

Мария Сидорова, тимлид команды бэкенд-разработки

В нашем проекте мы обрабатывали пользовательские загрузки — фотографии, документы и видео, структурируя их по категориям в отдельных подкаталогах. Изначально для работы с директориями мы использовали функции из модуля os.

Код быстро превратился в запутанную массу конкатенаций строк и проверок. Обслуживать такой код становилось всё сложнее — каждое изменение требовало тщательного тестирования из-за потенциальных ошибок с разделителями путей на разных ОС.

Когда мы мигрировали на Python 3.6, я предложила переписать всю логику работы с файловой системой на pathlib. Результаты превзошли ожидания: код сократился почти на 40%, стал намного понятнее и, что важно, более устойчивым к ошибкам. Объектно-ориентированный подход pathlib позволил нам легко добавлять новые операции с файлами, не боясь нарушить существующую функциональность.

Особенно заметной разница стала, когда мы расширили поддержку на Windows-серверы — ни одной проблемы с разделителями путей, всё работало из коробки!

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

• Объектно-ориентированный интерфейс, который делает код более чистым
• Кроссплатформенность — автоматическая обработка различий путей в разных ОС
• Богатый API с множеством полезных методов (glob, suffixes, parents и т.д.)
• Более понятный и современный стиль кода

Для более сложных случаев pathlib предоставляет дополнительные возможности. Например, можно получить подкаталоги, соответствующие определенному шаблону:

# Получить все директории, начинающиеся с 'data_'
def get_data_directories(directory):
path = Path(directory)
return [item for item in path.glob('data_*') if item.is_dir()]

Также можно рекурсивно получить все подкаталоги на всех уровнях вложенности:

# Получить все поддиректории рекурсивно
def get_all_subdirectories_recursive(directory):
path = Path(directory)
return [item for item in path.glob('**/*') if item.is_dir()]

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

Рекурсивный обход директорий с помощью os.walk()

Функция os.walk() — мощный инструмент для рекурсивного обхода дерева каталогов. Она особенно полезна, когда необходимо получить не только подкаталоги первого уровня, но и все вложенные директории на любой глубине. 📂

Принцип работы os.walk() заключается в последовательном обходе каталогов, начиная с корневого. Для каждого каталога функция возвращает кортеж из трех элементов:

1. Текущий путь (строка)
2. Список подкаталогов в текущем пути (имена, не полные пути)
3. Список файлов в текущем пути (имена, не полные пути)

Базовый пример использования os.walk() для получения всех подкаталогов:

import os

def get_all_subdirectories(path):
"""
Получает список всех подкаталогов (включая вложенные) в указанной директории.

Args:
path (str): Путь к корневой директории

Returns:
list: Список полных путей ко всем подкаталогам
"""
all_subdirs = []

# Обходим дерево каталогов
for dirpath, dirnames, filenames in os.walk(path):
# dirpath – текущий путь
# dirnames – список подкаталогов в текущем пути
# filenames – список файлов в текущем пути

for dirname in dirnames:
# Создаем полный путь для каждого подкаталога
full_path = os.path.join(dirpath, dirname)
all_subdirs.append(full_path)

return all_subdirs

# Пример использования
directories = get_all_subdirectories('/path/to/directory')
for directory in directories:
print(directory)

Если требуется получить только подкаталоги первого уровня (без рекурсии), можно модифицировать функцию:

def get_first_level_subdirs(path):
"""
Получает только подкаталоги первого уровня с помощью os.walk()
"""
first_level_dirs = next(os.walk(path))[1]
return [os.path.join(path, dirname) for dirname in first_level_dirs]

Преимущества os.walk():

• Встроенная поддержка рекурсивного обхода директорий
• Эффективность — не требуется писать собственные рекурсивные функции
• Разделение списков директорий и файлов уже в результате работы функции
• Возможность управлять обходом (например, пропускать определенные директории)

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

import os

def get_filtered_subdirs(path):
"""
Обходит дерево директорий, исключая скрытые каталоги и папки с именем 'temp'
"""
all_subdirs = []

for dirpath, dirnames, filenames in os.walk(path):
# Модифицируем dirnames "на месте" для исключения нежелательных каталогов
# Важно: это влияет на последующие итерации os.walk()
dirnames[:] = [d for d in dirnames if not d.startswith('.') and d != 'temp']

for dirname in dirnames:
full_path = os.path.join(dirpath, dirname)
all_subdirs.append(full_path)

return all_subdirs

Дополнительные возможности os.walk():

1. Параметр topdown – определяет порядок обхода (сверху вниз или снизу вверх)
2. Параметр onerror – позволяет указать функцию обработки ошибок
3. Параметр followlinks – определяет, нужно ли следовать по символическим ссылкам

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

def get_subdirs_with_options(path):
"""
Получение подкаталогов с дополнительными настройками os.walk()
"""
all_subdirs = []

# Обход снизу вверх с обработкой символических ссылок
for dirpath, dirnames, filenames in os.walk(
path, 
topdown=False,
followlinks=True,
onerror=lambda e: print(f"Ошибка: {e}")
):
for dirname in dirnames:
full_path = os.path.join(dirpath, dirname)
all_subdirs.append(full_path)

return all_subdirs

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

Использование scandir для эффективного получения подкаталогов

Начиная с Python 3.5, доступна функция os.scandir(), которая обеспечивает значительно более высокую производительность по сравнению с традиционным os.listdir(). Основное преимущество scandir в том, что он возвращает итератор, содержащий объекты DirEntry, которые кэшируют информацию о файлах и директориях, что позволяет избежать дополнительных системных вызовов. 🚀

Этот метод особенно полезен при работе с большими директориями, где производительность критически важна.

import os

def get_subdirectories_scandir(path):
"""
Получает список подкаталогов с использованием os.scandir().

Args:
path (str): Путь к директории для поиска

Returns:
list: Список имен подкаталогов
"""
subdirectories = []

# scandir() возвращает итератор объектов DirEntry
with os.scandir(path) as entries:
for entry in entries:
# is_dir() – метод объекта DirEntry, не требующий дополнительных вызовов к ОС
if entry.is_dir():
subdirectories.append(entry.name)

return subdirectories

# Пример использования
directories = get_subdirectories_scandir('/path/to/directory')
print(directories)

Для получения полных путей можно модифицировать функцию:

def get_subdirectories_fullpath(path):
"""
Получает полные пути подкаталогов с использованием os.scandir()
"""
with os.scandir(path) as entries:
return [entry.path for entry in entries if entry.is_dir()]

Преимущества использования os.scandir():

• Значительно выше производительность по сравнению с os.listdir() + os.path.isdir()
• Меньше системных вызовов благодаря кэшированию информации о файлах
• Удобный интерфейс через объекты DirEntry
• Поддержка контекстного менеджера (with statement)

Для рекурсивного обхода можно реализовать свою функцию с использованием scandir:

import os

def get_all_subdirs_recursively(path):
"""
Рекурсивно обходит дерево каталогов с использованием scandir
"""
subdirs = []

# Обходим текущую директорию
with os.scandir(path) as entries:
for entry in entries:
if entry.is_dir():
subdirs.append(entry.path)
# Рекурсивный вызов для каждого подкаталога
subdirs.extend(get_all_subdirs_recursively(entry.path))

return subdirs

Объект DirEntry предоставляет несколько полезных методов и атрибутов:

• name: имя файла или директории
• path: полный путь к файлу или директории
• is_dir(): проверяет, является ли элемент директорией
• is_file(): проверяет, является ли элемент файлом
• is_symlink(): проверяет, является ли элемент символической ссылкой
• stat(): возвращает информацию о файле, аналогично os.stat()

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

Теоретические преимущества различных методов важны, но еще важнее понимать, как они проявляются на практике. Давайте сравним производительность всех описанных методов на реальных примерах. 📊

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

import os
import time
from pathlib import Path

def benchmark_directory_methods(directory_path, runs=5):
"""
Сравнивает производительность различных методов получения подкаталогов.

Args:
directory_path (str): Путь к тестовой директории
runs (int): Количество запусков для усреднения результатов
"""
methods = {
'os.listdir + os.path.isdir': lambda: [
d for d in os.listdir(directory_path) 
if os.path.isdir(os.path.join(directory_path, d))
],
'os.scandir': lambda: [
entry.name for entry in os.scandir(directory_path) 
if entry.is_dir()
],
'pathlib.Path': lambda: [
item.name for item in Path(directory_path).iterdir() 
if item.is_dir()
],
'os.walk (первый уровень)': lambda: next(os.walk(directory_path))[1],
'glob (только подкаталоги)': lambda: [
os.path.basename(p) for p in glob.glob(os.path.join(directory_path, '*/'))
]
}

results = {}

for method_name, method_func in methods.items():
total_time = 0

for _ in range(runs):
start_time = time.time()
result = method_func()
end_time = time.time()
total_time += (end_time – start_time)

avg_time = total_time / runs
results[method_name] = {
'time': avg_time,
'count': len(result)
}

return results

Результаты тестирования на различных директориях показывают значительные различия в производительности:

Выводы из тестирования:

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

Для реальных проектов важно учитывать не только чистую производительность, но и другие факторы:

• Читаемость кода: pathlib.Path часто делает код более понятным
• Кроссплатформенность: современные методы лучше обрабатывают различия между ОС
• Функциональные требования: необходимость рекурсии, фильтрации, обработки ошибок
• Версия Python: для старых версий некоторые методы недоступны

Рекомендации по выбору метода в зависимости от сценария:

1. Для максимальной производительности: os.scandir()
2. Для современного чистого кода: pathlib.Path
3. Для рекурсивного обхода: os.walk()
4. Для максимальной совместимости: os.listdir() + os.path.isdir()
5. Для сложных шаблонов фильтрации: glob или pathlib.Path.glob()

Использование glob для фильтрации подкаталогов по шаблону

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

Вот как можно использовать glob для получения списка подкаталогов:

import glob
import os

def get_directories_by_pattern(directory, pattern="*"):
"""
Получает список подкаталогов, соответствующих заданному шаблону.

Args:
directory (str): Путь к директории для поиска
pattern (str): Шаблон для фильтрации (по умолчанию "*" – все директории)

Returns:
list: Список путей к подкаталогам
"""
# Формируем шаблон поиска для директорий
# Обратите внимание на "/" в конце – это указывает, что мы ищем директории
search_pattern = os.path.join(directory, pattern, "")

# glob.glob возвращает список путей, соответствующих шаблону
matching_dirs = glob.glob(search_pattern)

# Убираем завершающий разделитель
return [os.path.dirname(d) for d in matching_dirs]

# Примеры использования
all_dirs = get_directories_by_pattern('/path/to/directory')
data_dirs = get_directories_by_pattern('/path/to/directory', 'data*')
numbered_dirs = get_directories_by_pattern('/path/to/directory', '[0-9]*')

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

def get_directories_iterator(directory, pattern="*"):
"""
Возвращает итератор для подкаталогов, соответствующих шаблону.
"""
search_pattern = os.path.join(directory, pattern, "")
for dir_path in glob.iglob(search_pattern):
yield os.path.dirname(dir_path)

Для рекурсивного поиска подкаталогов можно использовать специальный синтаксис ** (доступен в Python 3.5+):

def get_all_subdirs_recursive_glob(directory, pattern="*"):
"""
Рекурсивно находит все подкаталоги, соответствующие шаблону.
"""
# "**" означает рекурсивный поиск во всех подкаталогах
search_pattern = os.path.join(directory, "**", pattern, "")
return [os.path.dirname(d) for d in glob.glob(search_pattern, recursive=True)]

Glob поддерживает различные шаблоны для фильтрации:

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

Примеры полезных шаблонов:

# Директории, начинающиеся с "log" или "data"
log_and_data_dirs = get_directories_by_pattern('/path', '{log,data}*')

# Директории с цифрами в названии
dirs_with_numbers = get_directories_by_pattern('/path', '*[0-9]*')

# Директории, начинающиеся с буквы (a-z или A-Z)
alpha_dirs = get_directories_by_pattern('/path', '[a-zA-Z]*')

Модуль pathlib также предоставляет возможности для использования glob-шаблонов, что делает код еще более читаемым:

from pathlib import Path

def get_dirs_with_pathlib_glob(directory, pattern="*"):
"""
Получает подкаталоги, соответствующие шаблону, используя pathlib.
"""
path = Path(directory)
return [item for item in path.glob(pattern) if item.is_dir()]

# Пример рекурсивного поиска с pathlib
def get_recursive_dirs_pathlib(directory, pattern="*"):
"""
Рекурсивный поиск директорий с pathlib
"""
path = Path(directory)
return [item for item in path.glob("**/" + pattern) if item.is_dir()]

Использование glob особенно полезно, когда требуется более сложная фильтрация, чем просто получение всех подкаталогов. Это позволяет существенно сократить код и сделать его более понятным.

Выбор метода получения списка подкаталогов в Python существенно влияет на производительность и читаемость вашего кода. Из пяти рассмотренных методов scandir() демонстрирует лучшую скорость работы, pathlib обеспечивает наиболее современный и читаемый код, а os.walk() превосходит остальные в задачах рекурсивного обхода. При выборе метода всегда учитывайте масштаб задачи и требования проекта — для небольших директорий подойдет любой подход, но при работе с тысячами файлов правильный выбор может сэкономить вам часы процессорного времени.