Python: эффективная работа с глубокими вложенностями

Дополнительные расширенные примеры

Обход вложенных списков разных типов

Комбинированная структура может содержать как списки, так и словари. Функция рекурсивно обрабатывает оба типа, возвращая все пути к листовым значениям.

def flatten_mixed(obj, path=''):
    if isinstance(obj, dict):
        for k, v in obj.items():
            new_path = f'{path}.{k}' if path else str(k)
            yield from flatten_mixed(v, new_path)
    elif isinstance(obj, list):
        for idx, item in enumerate(obj):
            new_path = f'{path}[{idx}]'
            yield from flatten_mixed(item, new_path)
    else:
        yield path, obj

data = {
    'users': [
        {'name': 'Alice', 'age': 30},
        {'name': 'Bob', 'age': 25}
    ],
    'config': {'debug': True}
}
for k, v in flatten_mixed(data):
    print(f'{k} = {v}')

users[0].name = Alice
users[0].age = 30
users[1].name = Bob
users[1].age = 25
config.debug = True

Пояснение: для словарей добавляется ключ, для списков – индекс в квадратных скобках. Такой универсальный обход полезен при анализе JSON или YAML.

Фильтрация вложенных данных с сохранением структуры

Требуется удалить все элементы, значение которых равно None, сохранив пустые словари/списки, если они не пусты после удаления.

def clean_none(obj):
    if isinstance(obj, dict):
        return {k: clean_none(v) for k, v in obj.items() if v is not None or isinstance(v, (dict, list)) and clean_none(v)}
    elif isinstance(obj, list):
        return [clean_none(item) for item in obj if item is not None or isinstance(item, (dict, list)) and clean_none(item)]
    else:
        return obj

data = {'a': None, 'b': {'c': None, 'd': 1}, 'e': [None, {'f': None}]}
cleaned = clean_none(data)
print(cleaned)  # {'b': {'d': 1}, 'e': []}

Пояснение: рекурсия обрабатывает каждый уровень, удаляя ключи или элементы со значением None. Если после очистки вложенной структуры не остаётся элементов, она тоже удаляется.

Итеративный обход с явным стеком (без рекурсии)

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

def find_strings_iter(data):
    stack = [(data, '')]
    while stack:
        node, path = stack.pop()
        if isinstance(node, dict):
            for k, v in node.items():
                new_path = f'{path}.{k}' if path else k
                stack.append((v, new_path))
        elif isinstance(node, list):
            for idx, item in enumerate(node):
                new_path = f'{path}[{idx}]'
                stack.append((item, new_path))
        else:
            if isinstance(node, str):
                yield path, node

data = {'a': 1, 'b': 'hello', 'c': {'d': 'world', 'e': [1, '!']}}
for path, val in find_strings_iter(data):
    print(path, ':', val)

c.e[1] : !
c.d : world
b : hello

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

Преобразование вложенной структуры в SQL-подобный плоский вид

Иногда требуется представить вложенные данные как таблицу с колонками, соответствующими путям. Пример для списка пользователей.

users = [
    {'id': 1, 'name': 'Alice', 'scores': {'math': 90, 'eng': 85}},
    {'id': 2, 'name': 'Bob', 'scores': {'math': 78, 'eng': 92}},
]
flat_rows = []
for u in users:
    row = {}
    for path, val in flatten_dict(u):
        row[path] = val
    flat_rows.append(row)
import pandas as pd
df = pd.DataFrame(flat_rows)
print(df)

   id   name  scores.math  scores.eng
0   1  Alice           90          85
1   2    Bob           78          92

Пояснение: функция flatten_dict из первого примера превращает каждый вложенный словарь в плоские колонки. Затем DataFrame даёт удобное табличное представление.

Слияние двух вложенных словарей

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

def merge_deep(d1, d2):
    result = d1.copy()
    for key, val in d2.items():
        if key in result and isinstance(result[key], dict) and isinstance(val, dict):
            result[key] = merge_deep(result[key], val)
        else:
            result[key] = val
    return result

d1 = {'a': {'b': 1, 'c': 2}, 'd': 3}
d2 = {'a': {'b': 10, 'e': 4}, 'f': 5}
merged = merge_deep(d1, d2)
print(merged)  # {'a': {'b': 10, 'c': 2, 'e': 4}, 'd': 3, 'f': 5}

{'a': {'b': 10, 'c': 2, 'e': 4}, 'd': 3, 'f': 5}

Пояснение: рекурсивно обходится второй словарь. Если ключ есть в обоих и оба значения – словари, происходит глубокое слияние, иначе значение из второго заменяет первое.

Поиск всех ключей с заданным значением

Задача: найти все пути, где листовое значение равно заданному. Используем рекурсию с накоплением пути.

def find_value(data, target, path=''):
    results = []
    if isinstance(data, dict):
        for k, v in data.items():
            new_path = f'{path}.{k}' if path else k
            results.extend(find_value(v, target, new_path))
    elif isinstance(data, list):
        for idx, item in enumerate(data):
            new_path = f'{path}[{idx}]'
            results.extend(find_value(item, target, new_path))
    else:
        if data == target:
            results.append(path)
    return results

data = {'a': 1, 'b': [1, 2, {'c': 1}]}
print(find_value(data, 1))  # ['a', 'b[0]', 'b[2].c']

['a', 'b[0]', 'b[2].c']

Этот подход легко адаптировать для поиска по условию (например, все числа больше 10).