Python find directory: системное администрирование файловых каталогов

Расширенные примеры поиска директорий с пояснениями

1. Поиск с ограничением глубины рекурсии

Иногда нужно искать только на определённой глубине, например, не глубже 3 уровней. Реализация на pathlib:

from pathlib import Path

def find_dirs_depth_limit(root_path, target_name, max_depth):
    root = Path(root_path)
    result = []
    for p in root.rglob("*"):
        # относительный путь от root, считаем глубину по количеству разделителей
        rel = p.relative_to(root)
        depth = len(rel.parts)
        if depth > max_depth:
            continue
        if p.is_dir() and p.name == target_name:
            result.append(p)
    return result

print(find_dirs_depth_limit("/tmp", "data", 2))

[PosixPath('/tmp/data'), PosixPath('/tmp/sub/data')] # не глубже 2

2. Поиск с исключением скрытых каталогов (начинающихся с точки)

В Unix-системах скрытые папки начинаются с точки. Их можно исключить:

from pathlib import Path

def find_visible_dirs(root, name):
    result = []
    for p in Path(root).rglob("*"):
        # Проверяем каждый компонент пути на скрытость
        if any(part.startswith('.') for part in p.parts):
            continue
        if p.is_dir() and p.name == name:
            result.append(p)
    return result

print(find_visible_dirs("/home/user", "projects"))

[PosixPath('/home/user/projects')]

3. Поиск директорий с наибольшим размером (через os.walk)

Иногда нужно найти самые «тяжёлые» каталоги. Собираем размер всех папок рекурсивно:

import os

def get_directory_size(path):
    total = 0
    for dirpath, dirnames, filenames in os.walk(path):
        for f in filenames:
            fp = os.path.join(dirpath, f)
            try:
                total += os.path.getsize(fp)
            except OSError:
                pass
    return total

def largest_dirs(root, top_n=5):
    dirs = []
    for entry in os.scandir(root):
        if entry.is_dir():
            try:
                size = get_directory_size(entry.path)
                dirs.append((entry.path, size))
            except PermissionError:
                continue
    dirs.sort(key=lambda x: x[1], reverse=True)
    return dirs[:top_n]

for path, size in largest_dirs("/var", 3):
    print(f"{path}: {size / (1024**3):.2f} GB")

/var/log: 1.23 GB
/var/cache: 0.87 GB
/var/lib: 0.45 GB

4. Параллельный поиск с использованием ThreadPoolExecutor

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

from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path

def search_in_subdir(subdir, target_name):
    return [p for p in subdir.rglob("*") if p.is_dir() and p.name == target_name]

def parallel_find(root, target_name, max_workers=4):
    root_path = Path(root)
    subdirs = [d for d in root_path.iterdir() if d.is_dir()]
    results = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = {executor.submit(search_in_subdir, d, target_name): d for d in subdirs}
        for future in as_completed(futures):
            results.extend(future.result())
    return results

print(parallel_find("/home", "backup"))

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

5. Поиск директорий с помощью os.scandir и ручной рекурсии

Использование os.scandir даёт более эффективный обход, чем os.walk, поскольку не загружает сразу все имена:

import os

def find_dirs_scandir_recursive(root, target_name):
    result = []
    try:
        with os.scandir(root) as it:
            for entry in it:
                if entry.is_dir(follow_symlinks=False):
                    if entry.name == target_name:
                        result.append(entry.path)
                    # рекурсивный вызов
                    result.extend(find_dirs_scandir_recursive(entry.path, target_name))
    except PermissionError:
        pass
    return result

print(find_dirs_scandir_recursive("/opt", "config"))

['/opt/app/config', '/opt/app2/config']

6. Поиск с учётом времени последнего изменения (mtime)

Найти папки, изменённые за последние N дней:

from pathlib import Path
import time

def find_dirs_modified_recently(root, days):
    cutoff = time.time() - days * 86400
    result = []
    for p in Path(root).rglob("*"):
        if p.is_dir():
            stat = p.stat()
            if stat.st_mtime > cutoff:
                result.append(p)
    return result

print(find_dirs_modified_recently("/tmp", 7))

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

7. Поиск и вывод полного пути с форматированием

Вывод результатов в удобном виде для системного администратора:

from pathlib import Path

def find_and_format(root, name):
    found = [str(p) for p in Path(root).rglob("*") if p.is_dir() and p.name == name]
    if not found:
        return "Ничего не найдено"
    lines = ["Найденные директории:"]
    for i, path in enumerate(found, 1):
        lines.append(f"{i}. {path}")
    return '\n'.join(lines)

print(find_and_format("/home", "logs"))

Найденные директории:
1. /home/user/logs
2. /home/user/project/logs