Словари в Python: методы работы, оптимизация, сериализация

Запись от py-thonny размещена 19.03.2025 в 08:23

Метки python

Нажмите на изображение для увеличения
Название: d03fba32-aae8-4e96-b0e7-c5c271ed3aea.jpg
Просмотров: 79
Размер: 205.7 Кб
ID: 10455

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

Python
1
2
3
4
5
6
7
8
9
# Простой пример словаря
погода = {
    "Москва": "+5°C",
    "Санкт-Петербург": "+2°C",
    "Казань": "+4°C"
}
 
# Доступ к значению через ключ
print(погода["Москва"]) # Вывод: +5°C

Такой подход к хранению данных делает словари незаменимыми в сценариях, где приходится работать с именоваными данными — конфигурация программ, хранение свойств объектов, обработка JSON из API, кэширование результатов функций.

Интересно, что история словарей в Python началась ещё с первых версий языка. Гвидо ван Россум, создатель Python, с самого начала понимал важность этой структуры данных. Изначально они назывались associative arrays (ассоциативные массивы), что отражало их суть — ассоциация ключей со значениями. Позже, с выходом Python 2.2, эта структура получила название dictionaries (словари), которое прижилось и используется до сих пор. Со временем словари эволюционировали — менялась их внутренняя реализация, улучшалась производительность, добавлялись новые методы. Одно из крупнейших изменений произошло в Python 3.7, когда словари официально стали упорядоченными контейнерами, сохраняющими порядок вставки элементов. Эта кардинальная перемена открыла новые возможности, позволяя полагаться на порядок элементов, что раньше было невозможно.

Погружаясь глубже в мир Python, невозможно переоценить значение словарей — они буквально встроены в сердцевину языка. Глобальные и локальные пространства имен, атрибуты классов и объектов — всё это реализовано с помощью словарей. Не зря опытные Python-разрабы часто говорят: "Если не знаешь, какую структуру данных использовать — начни со словаря".

Основы работы со словарями

Работа со словарями в Python начинается с их создания, и тут есть несколько подходов, каждый со своими нюансами. Самый распространённый способ — использование литералов, то есть заключение пар ключ-значение в фигурные скобки:

Python
1
2
3
4
5
6
студент = {
    "имя": "Анна",
    "возраст": 21,
    "курс": 3,
    "средний_балл": 4.7
}

Обратите внимание: ключи и значения разделяются двоеточием, а пары — запятыми. Пустой словарь можно создать просто как {}. Простота и наглядность — главные преимущества такого подхода.
Альтернативный способ — использование конструктора dict(). Он может принимать различные аргументы:

Python
1
2
3
4
5
6
7
8
# Из списка кортежей
студент = dict([("имя", "Анна"), ("возраст", 21), ("курс", 3)])
 
# Из именованных аргументов (только если ключи — допустимые имена переменных)
студент = dict(имя="Анна", возраст=21, курс=3)
 
# С помощью метода fromkeys (одинаковые значения для разных ключей)
предметы = dict.fromkeys(["математика", "физика", "история"], "не сдано")

Для чего же нужны два способа создания словарей? Литералы ({}) хороши, когда вы заранее знаете содержимое словаря. Конструктор dict() незаменим, когда нужно создать словарь динамически, причем из разных источников данных.
Интересная техника — использование функции zip() для объединения двух списков в словарь:

Python
1
2
3
4
города = ["Москва", "Казань", "Сочи"]
население = [12.6, 1.2, 0.4]
города_население = dict(zip(города, население))
# Результат: {"Москва": 12.6, "Казань": 1.2, "Сочи": 0.4}

Когда словарь создан, самая частая операция — доступ к значениям по ключам. Это выполняется с помощью квадратных скобок:

Python
1
имя = студент["имя"]  # "Анна"

Но что, если ключа нет в словаре? Тогда Python выбросит исключение KeyError. Чтобы этого избежать, можно использовать метод .get():

Python
1
2
3
# Безопасный доступ к элементам
телефон = студент.get("телефон")  # None, если нет такого ключа
телефон = студент.get("телефон", "неизвестно")  # Указываем значение по умолчанию

Изменение элементов словаря выполняется так же, как и доступ — через квадратные скобки:

Python
1
2
студент["средний_балл"] = 4.8  # Изменение существующего значения
студент["стипендия"] = True  # Добавление нового ключа

Для удаления элементов у нас есть несколько инструментов:

Python
1
2
3
4
5
6
7
8
9
10
11
# Удаляем элемент и возвращаем его значение
возраст = студент.pop("возраст")  
 
# Удаляем случайный элемент (последний добавленный в Python 3.7+)
последний_элемент = студент.popitem()  
 
# Удаление через оператор del
del студент["курс"]
 
# Очистка всего словаря
студент.clear()

Метод .pop() особенно полезен, когда нужно одновременно получить значение и удалить ключ. А .popitem() до Python 3.7 удалял произвольный элемент, но теперь поведение изменилось — метод всегда удаляет последний добавленный элемент, что сделало его полезным для реализации паттерна LIFO (last in, first out).
В Python 3.7 появилось важное изменение: словари стали хранить элементы в порядке их вставки. Это решило многолетнюю проблему, когда программисты не могли полагаться на порядок элементов при итерации.

Python
1
2
3
4
5
6
7
8
9
цвета = {}
цвета["красный"] = "#FF0000"
цвета["зеленый"] = "#00FF00"
цвета["синий"] = "#0000FF"
 
# До Python 3.7 порядок мог быть любым
# В Python 3.7+ порядок гарантированно соответствует порядку вставки
for цвет in цвета:
    print(цвет)  # "красный", "зеленый", "синий"

Теперь можно не использовать дополнительные структуры вроде collections.OrderedDict, если нужен только фиксированный порядок элементов.

Работа со словарями не обходится без понимания основных методов. Кроме уже упомянутых .get(), .pop(), .popitem() и .clear(), стоит знать:

Python
1
2
3
4
5
6
7
8
9
10
11
# Добавление значения по умолчанию, если ключа нет
логи_ошибок = {}
логи_ошибок.setdefault("сетевые", []).append("Таймаут соединения")
# Если ключа "сетевые" не было, создаст его со значением []
[H2]Затем добавит в список элемент[/H2]
 
# Объединение словарей
настройки = {"тема": "тёмная", "шрифт": "Arial"}
пользовательские = {"тема": "светлая", "масштаб": 1.2}
настройки.update(пользовательские)
# Результат: {"тема": "светлая", "шрифт": "Arial", "масштаб": 1.2}

Метод .setdefault() — неоценимый помощник, когда вы работаете с вложенными структурами данных. Без него приходится писать что-то вроде:

Python
1
2
3
if "сетевые" not in логи_ошибок:
    логи_ошибок["сетевые"] = []
логи_ошибок["сетевые"].append("Таймаут соединения")

А с setdefault всё решается в одну строку!

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

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Итерация по ключам (поведение по умолчанию)
for ключ in студент:
    print(ключ)
 
# Явная итерация по ключам
for ключ in студент.keys():
    print(ключ)
 
# Итерация по значениям
for значение in студент.values():
    print(значение)
 
# Итерация по парам ключ-значение
for ключ, значение in студент.items():
    print(f"{ключ}: {значение}")

Методы .keys(), .values() и .items() возвращают специальные объекты-представления словаря. Главная особенность этих представлений — они динамические, то есть отражают актуальное состояние словаря даже при его изменении.

Python
1
2
3
4
5
ключи = студент.keys()
print(ключи)  # dict_keys(['имя', 'средний_балл', 'стипендия'])
 
студент["город"] = "Москва"
print(ключи)  # dict_keys(['имя', 'средний_балл', 'стипендия', 'город'])

Эта динамическая природа представлений экономит память и обеспечивает согласованное состояние. Если вам нужна статическая копия, преобразуйте представление в список: list(студент.keys()).

Любопытный факт: несмотря на то, что словари в Python часто называют хеш-таблицами, термин "хеш" нигде не фигурирует в официальном API. Однако за кулисами именно хеширование обеспечивает быстрый доступ к элементам словаря — операция поиска имеет сложность O(1) в среднем случае.

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

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Числа в качестве ключей
координаты = {
    (0, 0): "Старт",
    (5, 5): "Финиш",
    (3, 2): "Контрольная точка"
}
 
# Булевые значения как ключи
настройки = {
    True: "Включено",
    False: "Выключено"
}
 
# Даже типы данных и функции могут быть ключами!
странный_словарь = {
    int: "Это целый тип",
    str: "Это строковый тип",
    float: "Это тип с плавающей точкой"
}
 
print(странный_словарь[int])  # "Это целый тип"

Единственное требование к ключам — они должны быть хешируемыми объектами. Простое правило: если объект неизменяемый (строки, числа, кортежи с неизменяемыми элементами), то его можно использовать как ключ. А вот списки и другие словари в качестве ключей использовать нельзя:

Python
1
2
3
4
# Это вызовет ошибку TypeError: unhashable type: 'list'
ошибочный_словарь = {
    [1, 2, 3]: "Список как ключ"
}

Но кортежи вполне подойдут:

Python
1
2
3
нормальный_словарь = {
    (1, 2, 3): "Кортеж как ключ"
}

Ещё одна особенность словарей — они поддерживают операции сравнения. Два словаря считаются равными, если содержат одинаковые пары ключ-значение, независимо от порядка их расположения:

Python
1
2
3
словарь1 = {"a": 1, "b": 2}
словарь2 = {"b": 2, "a": 1}
print(словарь1 == словарь2)  # True

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

Python
1
2
3
4
5
6
7
настройки = {"звук": True, "уведомления": False}
 
if "звук" in настройки:
    print("Настройки звука найдены")
    
if "яркость" not in настройки:
    print("Настройки яркости не найдены")

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

В Python 3.9 появились новые операторы для работы со словарями: оператор объединения | и оператор обновления |=. Они делают код более лаконичным:

Python
1
2
3
4
5
6
7
8
9
10
# До Python 3.9
словарь1 = {"a": 1, "b": 2}
словарь2 = {"c": 3, "d": 4}
объединенный = {**словарь1, **словарь2}  # {"a": 1, "b": 2, "c": 3, "d": 4}
 
# С Python 3.9
объединенный = словарь1 | словарь2  # {"a": 1, "b": 2, "c": 3, "d": 4}
 
# Обновление словаря
словарь1 |= словарь2  # словарь1 теперь содержит {"a": 1, "b": 2, "c": 3, "d": 4}

Эти операторы сильно повысили читаемость кода, особенно при слиянии нескольких словарей.
Важный аспект, о котором стоит упомянуть — словари в Python хранятся в памяти как ссылки. Это значит, что при присваивании одного словаря другому, создаётся не копия, а ещё одна ссылка на тот же объект:

Python
1
2
3
4
5
6
оригинал = {"яблоки": 5, "груши": 3}
копия = оригинал  # Это не создаёт новый словарь!
 
# Изменение "копии" затронет и оригинал
копия["яблоки"] = 10
print(оригинал["яблоки"])  # 10

Если вам нужна настоящая копия, используйте метод .copy() для поверхностного копирования или copy.deepcopy() для глубокого:

Python
1
2
3
4
5
6
7
8
9
# Поверхностное копирование
настоящая_копия = оригинал.copy()
настоящая_копия["яблоки"] = 7
print(оригинал["яблоки"])  # Останется 10
 
# Для вложенных структур нужно глубокое копирование
import copy
вложенный = {"фрукты": {"яблоки": 5, "груши": 3}}
глубокая_копия = copy.deepcopy(вложенный)

Работа со вложенными словарями — отдельное искусство. Когда нужно обратиться к глубоко вложенным данным, код может стать громоздким и подверженным ошибкам:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
конфиг = {
    "база_данных": {
        "основная": {
            "хост": "localhost",
            "порт": 5432
        }
    }
}
 
# Небезопасный доступ - может вызвать KeyError
порт = конфиг["база_данных"]["основная"]["порт"]
 
# Защитный подход с проверками
порт = None
if "база_данных" in конфиг:
    if "основная" in конфиг["база_данных"]:
        if "порт" in конфиг["база_данных"]["основная"]:
            порт = конфиг["база_данных"]["основная"]["порт"]

Этот громоздкий код можно упростить с помощью функционального подхода:

Python
1
2
3
4
5
6
7
8
9
10
11
def безопасный_доступ(словарь, путь, по_умолчанию=None):
    """Безопасно получает значение по пути из вложенного словаря"""
    для_проверки = словарь
    for ключ in путь:
        if not isinstance(для_проверки, dict) or ключ not in для_проверки:
            return по_умолчанию
        для_проверки = для_проверки[ключ]
    return для_проверки
 
# Теперь код выглядит гораздо чище
порт = безопасный_доступ(конфиг, ["база_данных", "основная", "порт"], 5432)

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

Python
1
2
3
4
5
6
7
8
9
10
результаты = {"Иван": 85, "Мария": 92, "Петр": 78, "Анна": 95}
 
# Сортировка по ключам (именам)
отсортированные_по_имени = dict(sorted(результаты.items()))
 
# Сортировка по значениям (оценкам)
отсортированные_по_оценкам = dict(sorted(результаты.items(), key=lambda x: x[1]))
 
# Сортировка по значениям в обратном порядке
лучшие_результаты = dict(sorted(результаты.items(), key=lambda x: x[1], reverse=True))

Обратите внимание, что sorted() возвращает список, поэтому мы оборачиваем результат в dict(), чтобы снова получить словарь.

Словари и методы
Добрый вечер. Помогите пожалуйста решить данную задачу: Создать словарь (Число, Корень). Создать метод appt, который должен возвращать...

Словари в Python
Здравствуйте. Помогите, пожалуйста, с задачей: 1. Надо реализовать фун-ию make_user, которая должна принимать два параметра - имя и...

Словари в Python
Помогите пожалуйста! Имена и адреса электронной почты. Напишите программу, которая сохраняет имена и адреса электронной почты в словаре в виде пар...

Словари Python
В список data вложено n словарей с двумя парами ключ-значение. Пример, где количество словарей n = 3: Из этих этих словарей при помощи циклов...

Продвинутые техники

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

Начнём с вложенных словарей. Это структура данных, где значениями для ключей выступают другие словари. Такой подход позволяет моделировать иерархические отношения:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
сотрудники = {
    "отдел_разработки": {
        "Иванов": {
            "должность": "Lead Developer",
            "стаж": 5,
            "проекты": ["API", "Микросервисы"]
        },
        "Петрова": {
            "должность": "Backend Developer",
            "стаж": 3,
            "проекты": ["База данных", "API"]
        }
    },
    "отдел_маркетинга": {
        "Сидоров": {
            "должность": "Marketing Manager",
            "стаж": 4,
            "кампании": ["Летняя", "Новогодняя"]
        }
    }
}

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

Python
1
2
3
4
5
6
7
8
9
10
11
def получить_вложенное(словарь, *ключи):
    """Получает значение из вложенного словаря по последовательности ключей"""
    текущий = словарь
    for ключ in ключи:
        if ключ not in текущий:
            return None
        текущий = текущий[ключ]
    return текущий
 
# Пример использования
стаж_иванова = получить_вложенное(сотрудники, "отдел_разработки", "Иванов", "стаж")  # 5

Другой мощный инструмент — словарные включения (dict comprehensions). Это аналог списковых включений, но для создания словарей:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Преобразование списка в словарь
имена = ["Анна", "Борис", "Виктория"]
длины_имен = {имя: len(имя) for имя in имена}
[H2]{'Анна': 4, 'Борис': 5, 'Виктория': 8}[/H2]
 
# Фильтрация словаря
оценки = {"Математика": 5, "История": 3, "Физика": 4, "Литература": 2}
хорошие_оценки = {предмет: оценка for предмет, оценка in оценки.items() if оценка > 3}
[H2]{'Математика': 5, 'Физика': 4}[/H2]
 
# Преобразование значений
цены_в_рублях = {"Яблоки": 100, "Бананы": 75, "Апельсины": 120}
цены_в_долларах = {товар: цена/100 for товар, цена in цены_в_рублях.items()}
# {'Яблоки': 1.0, 'Бананы': 0.75, 'Апельсины': 1.2}

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

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

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
from collections import defaultdict
 
# Обычный словарь выбросит KeyError
обычный = {}
try:
    обычный["несуществующий"] += 1
except KeyError:
    print("Ключа нет!")  # Сработает это
 
# defaultdict автоматически создаст запись со значением по умолчанию
счетчик = defaultdict(int)  # Значение по умолчанию будет 0
счетчик["слово"] += 1  # Увеличит счетчик до 1
счетчик["другое_слово"] += 1  # И тут тоже
print(счетчик)  # defaultdict(<class 'int'>, {'слово': 1, 'другое_слово': 1})
 
# Полезно при группировке данных
журнал_посещений = [
    ("Иванов", "2023-01-15"),
    ("Петров", "2023-01-16"),
    ("Иванов", "2023-01-17"),
    ("Сидоров", "2023-01-15"),
    ("Иванов", "2023-01-18")
]
 
посещения_по_людям = defaultdict(list)
for человек, дата in журнал_посещений:
    посещения_по_людям[человек].append(дата)
 
print(посещения_по_людям["Иванов"])  # ['2023-01-15', '2023-01-17', '2023-01-18']

Еще одно сокровище из collections — это Counter, который упрощает подсчёт элементов:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from collections import Counter
 
текст = "Python - это язык программирования, который часто используется для анализа данных"
слова = текст.lower().split()
частота_слов = Counter(слова)
print(частота_слов.most_common(3))  # [('python', 1), ('это', 1), ('язык', 1)]
 
# Counter поддерживает математические операции
другой_текст = "Python используется в веб-разработке и машинном обучении"
другие_слова = другой_текст.lower().split()
другая_частота = Counter(другие_слова)
 
# Объединение счетчиков
общая_частота = частота_слов + другая_частота
print(общая_частота["python"])  # 2

Интересно, что Counter не только упрощает подсчёт, но и автоматически сортирует элементы по их частоте при вызове метода most_common(), что делает его незаменимым при анализе данных и текста.
Для работы с множественными словарями модуль collections предлагает ChainMap — структуру данных, которая объединяет несколько словарей в одно логическое представление:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
from collections import ChainMap
 
базовые_настройки = {"цвет": "синий", "размер": "средний", "тема": "светлая"}
пользовательские = {"цвет": "красный", "шрифт": "Arial"}
 
# ChainMap ищет ключи слева направо в переданных словарях
настройки = ChainMap(пользовательские, базовые_настройки)
print(настройки["цвет"])    # "красный" (из пользовательских настроек)
print(настройки["размер"])  # "средний" (из базовых настроек)
print(настройки["шрифт"])   # "Arial" (из пользовательских настроек)
 
# При изменении ChainMap меняется первый словарь
настройки["цвет"] = "зелёный"
print(пользовательские)  # {"цвет": "зелёный", "шрифт": "Arial"}

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

Паттерн "защитное программирование" часто используется при работе со словарями. Цель — избежать исключений при отсутствии ключей. Мы уже видели метод .get(), но иногда нужно не только получить значение по умолчанию, но и выполнить сложную логику:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Проверка и обработка значений словаря
def обработать_заказ(заказ):
    # Явная проверка обязательных полей
    if не_все_поля_присутствуют(заказ, ["id", "товары", "адрес"]):
        raise ValueError("Неполные данные заказа")
    
    # Безопасное получение опциональных полей
    комментарий = заказ.get("комментарий", "")
    способ_доставки = заказ.get("доставка", "стандартная")
    
    # Глубокая проверка вложенных данных
    if "контакты" in заказ:
        телефон = заказ["контакты"].get("телефон")
        email = заказ["контакты"].get("email")
        # ...

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

С выходом Python 3.9 появились новые операторы для слияния словарей, которые делают код еще более читаемым:

Python
1
2
3
4
5
6
7
8
9
10
# Слияние словарей оператором |
настройки_системы = {"тема": "тёмная", "язык": "русский"}
настройки_пользователя = {"тема": "светлая", "показывать_уведомления": True}
 
# В Python 3.9+
итоговые_настройки = настройки_системы | настройки_пользователя
[H2]{"тема": "светлая", "язык": "русский", "показывать_уведомления": True}[/H2]
 
# Обновление словаря на месте
настройки_системы |= {"язык": "английский", "анимации": False}

Разбираясь с методами словарей, особое внимание стоит уделить .keys(), .values() и .items(). Они возвращают не просто списки, а специальные объекты-представления, которые динамически связаны с исходным словарем. Это позволяет сократить потребление памяти и обеспечить актуальность данных:

Python
1
2
3
4
5
6
7
8
9
10
11
12
статистика = {"просмотры": 100, "клики": 20}
значения = статистика.values()
print(значения)  # dict_values([100, 20])
 
# Представление отражает изменения в словаре
статистика["клики"] = 25
print(значения)  # dict_values([100, 25])
 
# В некоторых ситуациях нужна статическая копия
список_значений = list(статистика.values())  # [100, 25]
статистика["клики"] = 30
print(список_значений)  # Остался [100, 25]

Объекты-представления словарей также поддерживают операции множеств, что делает их еще более гибкими:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
# Использование представлений в операциях с множествами
словарь1 = {"a": 1, "b": 2, "c": 3}
словарь2 = {"b": 20, "c": 30, "d": 40}
 
# Находим общие ключи
общие_ключи = словарь1.keys() & словарь2.keys()  # {'b', 'c'}
 
# Находим ключи, которые есть в словарь1, но нет в словарь2
уникальные_ключи = словарь1.keys() - словарь2.keys()  # {'a'}
 
# Можно проверить, являются ли значения первого словаря подмножеством другого
if set(словарь1.values()) <= set(словарь2.values()):
    print("Все значения словаря1 есть в словаре2")

Ещё одна интересная техника — чтение вложенных структур с проверкой существования ключей. Представим, что у нас есть API, возвращающее JSON с глубоко вложенной структурой. Традиционный подход чреват KeyError:

Python
1
2
3
4
try:
    регион = данные["местоположение"]["город"]["регион"]["название"]
except KeyError:
    регион = "Неизвестно"

Более элегантное решение — функция, которая пробирается через вложенную структуру, проверяя каждый уровень:

Python
1
2
3
4
5
6
7
8
9
10
11
12
def deep_get(словарь, путь, по_умолчанию=None):
    """Безопасно извлекает значение из вложенного словаря по пути из ключей"""
    копия = словарь
    for часть in путь.split('.'):
        if isinstance(копия, dict) and часть in копия:
            копия = копия[часть]
        else:
            return по_умолчанию
    return копия
 
# Теперь безопасное обращение к вложенным ключам выглядит так:
регион = deep_get(данные, "местоположение.город.регион.название", "Неизвестно")

Такая функция экономит кучу кода и делает его более читабельным. А если заморочиться, можно реализовать поддержку индексов списков в пути!

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

Python
1
2
3
словарь1 = {"a": 1, "b": {"c": 2}}
словарь2 = {"a": 1, "b": {"c": 3}}
словарь1 == словарь2  # False, но только потому, что вложенные словари отличаются

Для глубокого сравнения часто пишут рекурсивные функции:

Python
1
2
3
4
5
6
7
8
def глубокое_равенство(д1, д2):
    """Сравнивает два словаря, включая вложенные структуры"""
    if isinstance(д1, dict) and isinstance(д2, dict):
        if set(д1.keys()) != set(д2.keys()):
            return False
        return all(глубокое_равенство(д1[k], д2[k]) for k in д1)
    else:
        return д1 == д2

Еще один трюк, который может пригодиться — "рекурсивное" обновление словарей. Стандартный метод .update() заменяет вложенные словари целиком, вместо слияния их содержимого:

Python
1
2
3
4
база = {"настройки": {"звук": 80, "графика": "высокая"}}
обновление = {"настройки": {"звук": 50}}
 
база.update(обновление)  # {'настройки': {'звук': 50}} — настройка графики потеряна

Рекурсивное обновление сохранит все несовпадающие ключи:

Python
1
2
3
4
5
6
7
def рекурсивное_обновление(база, обновление):
    """Рекурсивно обновляет вложенные словари"""
    for ключ, значение in обновление.items():
        if ключ in база and isinstance(база[ключ], dict) and isinstance(значение, dict):
            рекурсивное_обновление(база[ключ], значение)
        else:
            база[ключ] = значение

В мире Python существует ещё один мощный инструмент для обработки словарей — функциональное программирование. Библиотека functools предоставляет декоратор @lru_cache, который может кэшировать результаты функций, используя словари под капотом:

Python
1
2
3
4
5
6
7
8
9
10
11
12
from functools import lru_cache
 
@lru_cache(maxsize=128)
def вычислить_что_то_сложное(x, y):
    print(f"Вычисление для {x}, {y}")
    # Представим, что это тяжёлая операция
    return x * y + x**2
 
# Первый вызов выполнит расчёты
результат1 = вычислить_что_то_сложное(5, 3)  # Напечатает "Вычисление для 5, 3"
# Повторный вызов возьмёт результат из кэша
результат2 = вычислить_что_то_сложное(5, 3)  # Ничего не напечатает

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

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

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class ИсторияИзменений(dict):
    """Словарь, хранящий историю изменений каждого ключа"""
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.история = {ключ: [значение] for ключ, значение in self.items()}
    
    def __setitem__(self, ключ, значение):
        super().__setitem__(ключ, значение)
        if ключ not in self.история:
            self.история[ключ] = []
        self.история[ключ].append(значение)
    
    def get_история(self, ключ):
        return self.история.get(ключ, [])
 
# Использование:
настройки = ИсторияИзменений(громкость=50, яркость=80)
настройки["громкость"] = 60
настройки["громкость"] = 70
print(настройки.get_история("громкость"))  # [50, 60, 70]

Этот пример демонстрирует, насколько гибкими могут быть словари в Python, особенно когда мы расширяем их функциональность.

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

Понимание внутреннего устройства словарей Python критически важно для написания оптимального кода. Мало кто задумывается, что скрывается за привычными фигурными скобками, когда мы создаём {}. А ведь там настоящее инженерное чудо!

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

Python
1
2
3
4
5
6
7
# Демонстрация хеширования
print(hash("привет"))  # Например: 8428377149842025573
print(hash("мир"))     # Например: -8061799805522776528
 
# Интересно, что числа - их собственные хеши
print(hash(42))      # 42
print(hash(3.14))    # 322818021289917443

Эта схема обеспечивает потрясающую производительность: операции поиска, вставки и удаления имеют сложность O(1) в среднем случае. Это значит, что время выполнения операции практически не зависит от размера словаря. Хоть 10 элементов, хоть миллион — поиск по ключу займёт примерно одинаковое время. Однако в реальном мире не всё так радужно. Иногда разные ключи дают одинаковый хеш (коллизия), и тогда Python должен искать значение среди всех элементов с этим хешем. В худшем случае, если все ключи имеют одинаковый хеш, словарь деградирует до связного списка, и сложность поиска становится O(n). К счастью, хеш-функции в Python спроектированы так, чтобы минимизировать вероятность коллизий.

Интересный факт: начиная с Python 3.6, словари стали упорядоченными не просто так — разработчики изменили внутреннюю реализацию, чтобы сократить потребление памяти! Раньше словарь хранил и массив "вёдер" для хеш-значений, и отдельный массив для пар ключ-значение. Теперь же используется только один массив с более компактным представлением данных.

Когда словарь начинает расти, Python периодически увеличивает размер внутреннего массива и перераспределяет элементы. Это амортизирует стоимость операции вставки, но иногда может привести к неожиданным задержкам:

Python
1
2
3
4
5
6
7
8
9
10
11
import time
 
большой_словарь = {}
for i in range(10_000_000):  # Добавляем 10 миллионов элементов
    если i % 1_000_000 == 0:
        начало = time.time()
        большой_словарь[i] = i
        конец = time.time()
        print(f"Добавление {i}-го элемента: {(конец - начало)*1000:.5f} мс")
    иначе:
        большой_словарь[i] = i

Запустив этот код, вы иногда увидите "скачки" во времени выполнения — это моменты, когда словарь перераспределяет внутренний массив. Также стоит учесть, что память, выделенная для словаря, не освобождается автоматически при удалении элементов. Словарь сохраняет свою ёмкость до тех пор, пока не будет создан новый или не произойдет явное сжатие:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
import sys
 
d = {}
for i in range(1000):
    d[i] = i
    
print(f"Размер словаря с 1000 элементами: {sys.getsizeof(d)} байт")
 
# Удаляем большинство элементов
for i in range(900):
    del d[i]
    
print(f"Размер словаря со 100 элементами: {sys.getsizeof(d)} байт")  # Почти не изменится!

Сравнение производительности словарей с другими структурами данных показывает их превосходство в ряде сценариев. Рассмотрим пример поиска элементов:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import time
 
# Подготовка данных
элементов = 10000000
поисков = 1000000
ключи_для_поиска = [i for i in range(0, элементов, элементов // поисков)]
 
# Словарь
словарь = {i: i for i in range(элементов)}
начало = time.time()
for ключ in ключи_для_поиска:
    значение = словарь[ключ]
время_словаря = time.time() - начало
 
# Список (линейный поиск)
список = [(i, i) for i in range(элементов)]
начало = time.time()
for ключ in ключи_для_поиска:
    for k, v in список:
        if k == ключ:
            значение = v
            break
время_списка = time.time() - начало
 
print(f"Словарь: {время_словаря:.5f} сек")
print(f"Список: {время_списка:.5f} сек")
print(f"Словарь быстрее в {время_списка/время_словаря:.2f} раз")

Результаты ошеломляют: словарь может быть быстрее списка в тысячи раз для операций поиска!
Интересная особенность словарей: хотя они очень эффективны, они требуют больше памяти из-за необходимости хранить структуры хеш-таблицы. Сравним потребление памяти разными структурами:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import sys
 
количество = 1000000
 
# Список кортежей (ключ-значение)
список = [(i, i) for i in range(количество)]
память_списка = sys.getsizeof(список) + sum(sys.getsizeof(x) for x in список)
 
# Словарь
словарь = {i: i for i in range(количество)}
память_словаря = sys.getsizeof(словарь)
 
print(f"Список: {память_списка / 1024 / 1024:.2f} МБ")
print(f"Словарь: {память_словаря / 1024 / 1024:.2f} МБ")
print(f"Соотношение: {память_словаря / память_списка:.2f}")

Обычно словари потребляют в 2-4 раза больше памяти, чем эквивалентная информация в списке. Это та цена, которую мы платим за скорость.

Оптимизация работы со словарями часто сводится к выбору правильных методов. Например, метод .get() работает быстрее, чем конструкция if ключ in словарь: значение = словарь[ключ], поскольку второй вариант дважды вычисляет хеш ключа:

Python
1
2
3
4
5
6
7
8
9
10
11
12
import timeit
 
словарь = {i: i for i in range(1000)}
 
# Измеряем время выполнения разных подходов
время1 = timeit.timeit('if 500 in словарь: значение = словарь[500]', globals=globals(), number=1000000)
время2 = timeit.timeit('значение = словарь.get(500)', globals=globals(), number=1000000)
время3 = timeit.timeit('try: значение = словарь[500]\nexcept KeyError: pass', globals=globals(), number=1000000)
 
print(f"if in + индекс: {время1:.5f} сек")
print(f".get(): {время2:.5f} сек")
print(f"try-except: {время3:.5f} сек")

Часто .get() оказывается быстрее, особенно когда вы ожидаете, что ключ обычно присутствует. Если вы часто проверяете наличие ключей и, при отсутствии, создаёте сложные структуры данных, используйте .setdefault() вместо условных проверок:

Python
1
2
3
4
5
6
7
# Менее эффективно
if ключ not in словарь:
    словарь[ключ] = []
словарь[ключ].append(значение)
 
# Более эффективно
словарь.setdefault(ключ, []).append(значение)

Для ещё большей экономии времени и кода используйте defaultdict:

Python
1
2
3
4
5
from collections import defaultdict
 
счётчики = defaultdict(int)
for слово in текст.split():
    счётчики[слово] += 1

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

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import array
import time
 
# Сравнение скорости доступа
количество = 10_000_000
ключи_для_доступа = list(range(0, количество, 100))
 
# Словарь
словарь = {i: i * 2 for i in range(количество)}
начало = time.time()
for ключ in ключи_для_доступа:
    значение = словарь[ключ]
время_словаря = time.time() - начало
 
# Список
список = [i * 2 for i in range(количество)]
начало = time.time()
for ключ in ключи_для_доступа:
    значение = список[ключ]
время_списка = time.time() - начало
 
# Массив
массив = array.array('i', (i * 2 for i in range(количество)))
начало = time.time()
for ключ in ключи_для_доступа:
    значение = массив[ключ]
время_массива = time.time() - начало
 
print(f"Словарь: {время_словаря:.5f} сек")
print(f"Список: {время_списка:.5f} сек")  # Обычно быстрее словаря
print(f"Массив: {время_массива:.5f} сек")  # Ещё быстрее для примитивных типов

Тут работает простое правило: если ключи — непрерывные целые числа, начинающиеся с нуля или близкого к нему значения, список или массив часто будут более эффективными как по памяти, так и по скорости доступа.

Практическое применение

Начнём с обработки данных из внешних источников, например, JSON-файлов из API. Работа с JSON — один из самых распространённых сценариев использования словарей:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import json
import requests
 
# Получение данных из API
response = requests.get("https://api.openweathermap.org/data/2.5/weather", 
                        params={"q": "Moscow", "appid": "ваш_ключ", "units": "metric"})
данные = response.json()
 
# Извлечение информации из вложенной структуры
температура = данные["main"]["temp"]
ощущается_как = данные["main"]["feels_like"]
влажность = данные["main"]["humidity"]
 
# Безопасное извлечение опциональных данных
описание = данные.get("weather", [{}])[0].get("description", "Нет данных")
 
print(f"Погода: {температура}°C, ощущается как {ощущается_как}°C")
print(f"Влажность: {влажность}%")
print(f"Описание: {описание}")

Заметьте интересный трюк при извлечении описания погоды. Поле weather — это список словарей, и мы берём первый элемент, если он есть, или пустой словарь {} в противном случае. Затем извлекаем description с запасным значением "Нет данных". Это отличный пример защитного программирования при работе с непредсказуемыми структурами данных.

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

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# Простой кеш для дорогостоящих вычислений
кеш_результатов = {}
 
def вычислить_факториал(n):
    # Проверка, есть ли результат в кеше
    if n in кеш_результатов:
        print(f"Возвращаю кешированный результат для {n}!")
        return кеш_результатов[n]
    
    # Иначе вычисляем
    if n <= 1:
        результат = 1
    else:
        результат = n * вычислить_факториал(n-1)
    
    # Сохраняем в кеш
    кеш_результатов[n] = результат
    return результат
 
# Проверка работы
print(вычислить_факториал(5))  # Вычислит заново
print(вычислить_факториал(5))  # Вернёт из кеша

Эта техника называется мемоизацией и особенно полезна в рекурсивных функциях. Конечно, в реальных проектах используют более продвинутые решения, такие как декоратор @lru_cache из модуля functools.

Интересное применение словарей — паттерн "словарь функций" или "команды". Вместо громоздких конструкций if/elif/else для выбора операции, используйте словарь функций:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def сложить(a, b):
    return a + b
 
def вычесть(a, b):
    return a - b
 
def умножить(a, b):
    return a * b
 
def разделить(a, b):
    return a / b if b != 0 else "Ошибка: деление на ноль"
 
# Словарь операций
операции = {
    "+": сложить,
    "-": вычесть,
    "*": умножить,
    "/": разделить
}
 
# Использование
a, операция, b = 10, "*", 5
результат = операции.get(операция, lambda x, y: "Неизвестная операция")(a, b)
print(f"{a} {операция} {b} = {результат}")

Этот паттерн делает код более модульным и легко расширяемым — просто добавьте новую функцию и соответствующий ключ в словарь операции. Никакой необходимости модифицировать условные конструкции!

Словари отлично подходят для моделирования графов и деревьев:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# Представление графа городов и расстояний между ними
города = {
    "Москва": {"Санкт-Петербург": 650, "Казань": 720, "Нижний Новгород": 400},
    "Санкт-Петербург": {"Москва": 650, "Хельсинки": 380},
    "Казань": {"Москва": 720, "Нижний Новгород": 330, "Уфа": 525},
    "Нижний Новгород": {"Москва": 400, "Казань": 330},
    "Уфа": {"Казань": 525}
}
 
# Функция для поиска всех достижимых городов
def найти_достижимые(город, макс_расстояние):
    результат = {}
    
    def обход(текущий, оставшееся_расстояние, путь):
        for сосед, расстояние in города.get(текущий, {}).items():
            if расстояние <= оставшееся_расстояние and сосед not in путь:
                новый_путь = путь + [сосед]
                результат[сосед] = новый_путь
                обход(сосед, оставшееся_расстояние - расстояние, новый_путь)
    
    обход(город, макс_расстояние, [город])
    return результат
 
# Использование
достижимые = найти_достижимые("Москва", 1000)
for город, путь in достижимые.items():
    print(f"{город}: через {' -> '.join(путь)}")

Этот пример демонстрирует, как легко представить граф в виде словаря словарей и затем использовать рекурсивные алгоритмы для обхода и анализа структуры.

Словари незаменимы в работе с конфигурациями и настройками приложений:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# Многоуровневая система конфигурации
настройки_по_умолчанию = {
    "приложение": {
        "название": "МояАппка",
        "версия": "1.0.0"
    },
    "сеть": {
        "таймаут": 30,
        "повторы": 3,
        "прокси": None
    },
    "интерфейс": {
        "тема": "светлая",
        "язык": "русский",
        "шрифт": {
            "семейство": "Arial",
            "размер": 12
        }
    }
}
 
# Пользовательские настройки могут переопределять только часть параметров
пользовательские_настройки = {
    "сеть": {
        "таймаут": 60
    },
    "интерфейс": {
        "тема": "тёмная",
        "шрифт": {
            "размер": 14
        }
    }
}
 
# Функция для рекурсивного слияния настроек
def объединить_настройки(база, обновления):
    результат = база.copy()
    
    for ключ, значение in обновления.items():
        if ключ in результат and isinstance(результат[ключ], dict) and isinstance(значение, dict):
            результат[ключ] = объединить_настройки(результат[ключ], значение)
        else:
            результат[ключ] = значение
    
    return результат
 
# Получаем итоговые настройки
итоговые_настройки = объединить_настройки(настройки_по_умолчанию, пользовательские_настройки)
 
# Проверим результат
print(f"Тема: {итоговые_настройки['интерфейс']['тема']}")  # "тёмная"
print(f"Шрифт: {итоговые_настройки['интерфейс']['шрифт']['семейство']}, {итоговые_настройки['интерфейс']['шрифт']['размер']}pt")  # "Arial, 14pt"

Функция объединить_настройки рекурсивно обходит и объединяет вложенные словари, сохраняя все уровни иерархии. Это гораздо мощнее, чем простой .update(), который заменил бы вложенные словари целиком.
А вот пример использования словарей для сериализации и десериализации объектов:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import json
 
class Пользователь:
    def __init__(self, имя, возраст, роли=None):
        self.имя = имя
        self.возраст = возраст
        self.роли = роли or []
    
    def в_словарь(self):
        """Сериализует объект в словарь"""
        return {
            "имя": self.имя,
            "возраст": self.возраст,
            "роли": self.роли
        }
    
    @classmethod
    def из_словаря(cls, данные):
        """Создаёт объект из словаря"""
        return cls(
            имя=данные["имя"],
            возраст=данные["возраст"],
            роли=данные.get("роли", [])
        )
 
# Создаём объект и сериализуем
пользователь = Пользователь("Анна", 28, ["админ", "модератор"])
данные = пользователь.в_словарь()
 
# Сохраняем в JSON
json_данные = json.dumps(данные, ensure_ascii=False)
print(json_данные)
 
# Восстанавливаем объект
восстановленный = Пользователь.из_словаря(json.loads(json_данные))
print(f"Восстановлен: {восстановленный.имя}, {восстановленный.возраст}, {восстановленный.роли}")

Этот паттерн часто используется для сохранения состояния объектов между запусками программы или для передачи данных по сети. Python делает процесс сериализации и десериализации максимально простым благодаря родной поддержке JSON.

Одна из распространённых ошибок при работе со словарями — модификация словаря во время итерации по нему:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
словарь = {"a": 1, "b": 2, "c": 3}
 
# Это вызовет RuntimeError
try:
    for ключ in словарь:
        if ключ == "a":
            словарь["d"] = 4  # Модификация во время итерации
except RuntimeError as e:
    print(f"Ошибка: {e}")
 
# Правильный подход — создать копию ключей
for ключ in list(словарь.keys()):
    if ключ == "a":
        словарь["d"] = 4  # Теперь ошибки не будет

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

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# Неправильно: изменяемые структуры как ключи
плохой_кеш = {}
def неправильная_мемоизация(список):
    # Ошибка! Списки не могут быть ключами словаря
    if список in плохой_кеш:  # TypeError: unhashable type: 'list'
        return плохой_кеш[список]
    
    # остальной код...
 
# Правильно: преобразование в неизменяемый тип
хороший_кеш = {}
def правильная_мемоизация(список):
    # Преобразуем список в кортеж, который можно использовать как ключ
    ключ = tuple(список)
    
    if ключ in хороший_кеш:
        return хороший_кеш[ключ]
    
    # остальной код...

Стоит также упомянуть интересный паттерн "словарь словарей" для моделирования табличных данных. Это альтернатива библиотекам вроде pandas, когда нужно что-то попроще:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Таблица студентов в виде словаря словарей
студенты = {
    # id: {данные}
    1: {"имя": "Иван", "группа": "A-101", "средний_балл": 4.5},
    2: {"имя": "Мария", "группа": "Б-202", "средний_балл": 4.8},
    3: {"имя": "Алексей", "группа": "A-101", "средний_балл": 3.9}
}
 
# Фильтрация по условию
отличники = {id: данные for id, данные in студенты.items() 
             if данные["средний_балл"] >= 4.5}
 
# Группировка по полю
по_группам = {}
for id, данные in студенты.items():
    группа = данные["группа"]
    if группа not in по_группам:
        по_группам[группа] = {}
    по_группам[группа][id] = данные
 
print(f"Студенты в группе A-101: {len(по_группам.get('A-101', {}))} человек")

Когда дело доходит до хранения конфигураций и настроек, словари могут работать в связке с модулем configparser, который позволяет читать и писать INI-файлы:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import configparser
 
# Создаём и записываем конфигурацию
config = configparser.ConfigParser()
 
config['DEFAULT'] = {
    'Сервер': 'localhost',
    'Порт': '8080'
}
 
config['База_Данных'] = {
    'Хост': 'db.example.com',
    'Порт': '5432',
    'Имя': 'myapp',
    'Пользователь': 'admin'
}
 
with open('config.ini', 'w') as configfile:
    config.write(configfile)
 
# Затем читаем её обратно
config = configparser.ConfigParser()
config.read('config.ini')
 
# Доступ к настройкам через словареподобный интерфейс
порт_сервера = config['DEFAULT']['Порт']
база_данных = dict(config['База_Данных'])  # Конвертируем секцию в обычный словарь

Словари также служат отличной основой для реализации кэша с автоматическим устареванием данных:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import time
import threading
 
class КэшСУстареванием:
    def __init__(self, время_жизни=300):  # время_жизни в секундах
        self._кэш = {}
        self._время_жизни = время_жизни
        self._замок = threading.RLock()
        
        # Запускаем поток для периодической очистки
        self._поток_очистки = threading.Thread(target=self._очистка_устаревших, daemon=True)
        self._поток_очистки.start()
    
    def установить(self, ключ, значение):
        """Добавляет элемент в кэш"""
        with self._замок:
            время = time.time()
            self._кэш[ключ] = (значение, время)
    
    def получить(self, ключ, по_умолчанию=None):
        """Возвращает значение из кэша, если оно не устарело"""
        with self._замок:
            запись = self._кэш.get(ключ)
            if запись is None:
                return по_умолчанию
                
            значение, время = запись
            if time.time() - время > self._время_жизни:
                del self._кэш[ключ]
                return по_умолчанию
            
            return значение
    
    def _очистка_устаревших(self):
        """Периодически удаляет устаревшие записи"""
        while True:
            time.sleep(60)  # Проверяем каждую минуту
            with self._замок:
                сейчас = time.time()
                для_удаления = []
                
                for ключ, (_, время) in self._кэш.items():
                    if сейчас - время > self._время_жизни:
                        для_удаления.append(ключ)
                
                for ключ in для_удаления:
                    del self._кэш[ключ]

Еще одно практическое применение словарей — это хранение и манипуляция данными в формате JSON-схемы, что часто используется для валидации API:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# Пример JSON-схемы для валидации
схема_пользователя = {
    "type": "object",
    "required": ["имя", "email"],
    "properties": {
        "имя": {"type": "string", "minLength": 2},
        "email": {"type": "string", "format": "email"},
        "возраст": {"type": "integer", "minimum": 18},
        "интересы": {
            "type": "array",
            "items": {"type": "string"}
        }
    }
}
 
# Функция для простой валидации данных по схеме
def валидировать(данные, схема):
    ошибки = []
    
    # Проверка типа
    if схема.get("type") == "object" and not isinstance(данные, dict):
        return ["Ожидался объект (словарь)"]
    
    # Проверка обязательных полей
    for поле in схема.get("required", []):
        if поле not in данные:
            ошибки.append(f"Отсутствует обязательное поле: {поле}")
    
    # Проверка свойств
    for имя, свойство in схема.get("properties", {}).items():
        if имя in данные:
            if свойство.get("type") == "string" and not isinstance(данные[имя], str):
                ошибки.append(f"Поле {имя} должно быть строкой")
            elif свойство.get("type") == "integer" and not isinstance(данные[имя], int):
                ошибки.append(f"Поле {имя} должно быть целым числом")
    
    return ошибки
 
# Пример использования
тестовые_данные = {
    "имя": "Иван",
    "email": "ivan@example.com",
    "возраст": 25,
    "интересы": ["программирование", "музыка"]
}
 
ошибки = валидировать(тестовые_данные, схема_пользователя)
if ошибки:
    print(f"Обнаружены ошибки: {ошибки}")
else:
    print("Данные прошли валидацию!")

Часто в рабочей практике словари используются для создания простых объектно-реляционных отображений (ORM):

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class ПростаяОРМ:
    def __init__(self, таблица):
        self.таблица = таблица
        self._запись = {}
        
    def загрузить(self, id):
        """Имитирует загрузку из базы данных"""
        # В реальности здесь был бы SQL-запрос
        запись = База.получить(self.таблица, id)  # Представим, что эта функция существует
        if запись:
            self._запись = запись
            return True
        return False
        
    def __getitem__(self, ключ):
        """Позволяет обращаться к атрибутам через квадратные скобки"""
        return self._запись.get(ключ)
        
    def __setitem__(self, ключ, значение):
        """Позволяет присваивать значения через квадратные скобки"""
        self._запись[ключ] = значение
        
    def сохранить(self):
        """Имитирует сохранение в базу данных"""
        # В реальности здесь был бы SQL-запрос
        if "id" in self._запись:
            База.обновить(self.таблица, self._запись)
        else:
            id = База.добавить(self.таблица, self._запись)
            self._запись["id"] = id
        return True

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

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def конвертировать_между_форматами(данные, из_формата, в_формат):
    # Сначала десериализуем во внутреннее представление (словарь)
    if из_формата == "json":
        внутренние_данные = json.loads(данные)
    elif из_формата == "xml":
        # Используем xmltodict или аналогичную библиотеку
        import xmltodict
        внутренние_данные = xmltodict.parse(данные)
    elif из_формата == "yaml":
        import yaml
        внутренние_данные = yaml.safe_load(данные)
    else:
        raise ValueError(f"Неизвестный исходный формат: {из_формата}")
    
    # Теперь сериализуем в целевой формат
    if в_формат == "json":
        return json.dumps(внутренние_данные)
    elif в_формат == "xml":
        import xmltodict
        return xmltodict.unparse({"root": внутренние_данные})
    elif в_формат == "yaml":
        import yaml
        return yaml.dump(внутренние_данные)
    else:
        raise ValueError(f"Неизвестный целевой формат: {в_формат}")

Python. Словари
dict = {"name": , "time": } Как можно увеличить ключ name и time не вручную, а программно ? И возможно ли это вообще ? Допустим, чтобы...

Внешние словари python
всем привет, возник такой вопрос, как в python сделать поиск по внешним словарям? Сейчас код выглядит так if J.lower() in : NAS_list...

Словари и файлы в Python
У меня есть файл такого типа: {u'darthlavigne': 2, u'777mrgrizzly777': 2, u'fasgh': 2, u'learde': 2, u'suvmax': 2, u'xresto': 2, u'metrix1233': 2,...

Списки и словари Python
Здраствуйте, подскажите а можно ли как-то достать из списка в котором словарь с ключами, значения ключей выборочно и одним кодом? если у меня там...

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

Словари, файлы в Python
Дана задача: "Создайте словарь, где ключами являются числа, а значениями – строки. Примените к нему метод items(), полученный объект dict_items...

Python (Словари) Банковские счета
Некоторый банк хочет внедрить систему управления счетами клиентов, поддерживающую следующие операции: Пополнение счета клиента. Снятие денег со...

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

Python, словари, чтение из файла
Есть текстовый файл. В нем есть символы, написанные кириллицей. Из файла информация считывается сначала в листы, потом создается и заполняется...

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

Python (Словари) Выборы в государственную думу
Статья 83 закона “О выборах депутатов Государственной Думы Федерального Собрания Российской Федерации” определяет следующий алгоритм...

Словари, файлы в Python. Игра «Знаешь ли ты своих друзей?»
Игра «Знаешь ли ты своих друзей?». Имеется каталог с файлами, содержащими анкетные данные друзей. Все файлы имеют одинаковый формат. Имя Иван ...

Метки python

Размещено в Без категории

« Списки и кортежи в Python: различия, особенности, применение Главная страница Сопоставление с образцом (Pattern Matching) в Python: Списки и словари »

Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.

Всего комментариев 2

Комментарии

	ты сам это пишешь или ИИ?
	Запись от Welemir1 размещена 19.03.2025 в 15:45

	Возьми да проверь.
	Запись от py-thonny размещена 19.03.2025 в 19:16

Новые блоги и статьи Все статьи Все блоги /
Согласованность транзакций в MongoDB Codd 30.04.2025 MongoDB, начинавшая свой путь как классическая NoSQL система с акцентом на гибкость и масштабируемость, сильно спрогрессировала, включив в свой арсенал поддержку транзакционной согласованности. Это. . .	Продвинутый ввод-вывод в Java: NIO, NIO.2 и асинхронный I/O Javaican 30.04.2025 Когда речь заходит о вводе-выводе в Java, классический пакет java. io долгие годы был единственным вариантом для разработчиков, но его ограничения становились всё очевиднее с ростом требований к. . .	Обнаружение объектов в реальном времени на Python с YOLO и OpenCV AI_Generated 29.04.2025 Компьютерное зрение — одна из самых динамично развивающихся областей искусственного интеллекта. В нашем мире, где визуальная информация стала доминирующим способом коммуникации, способность машин. . .	Эффективные парсеры и токенизаторы строк на C# UnmanagedCoder 29.04.2025 Обработка текстовых данных — частая задача в программировании, с которой сталкивается почти каждый разработчик. Парсеры и токенизаторы составляют основу множества современных приложений: от. . .	C++ в XXI веке - Эволюция языка и взгляд Бьярне Страуструпа bytestream 29.04.2025 C++ существует уже более 45 лет с момента его первоначальной концепции. Как и было задумано, он эволюционировал, отвечая на новые вызовы, но многие разработчики продолжают использовать C++ так, будто. . .
Слабые указатели в Go: управление памятью и предотвращение утечек ресурсов golander 29.04.2025 Управление памятью — один из краеугольных камней разработки высоконагруженных приложений. Го (Go) занимает уникальную нишу в этом вопросе, предоставляя разработчикам автоматическое управление памятью. . .	Разработка кастомных расширений для компилятора C++ NullReferenced 29.04.2025 Создание кастомных расширений для компиляторов C++ — инструмент оптимизации кода, внедрения новых языковых функций и автоматизации задач. Многие разработчики недооценивают гибкость современных. . .	Гайд по обработке исключений в C# stackOverflow 29.04.2025 Разработка надёжного программного обеспечения невозможна без грамотной обработки исключительных ситуаций. Любая программа, независимо от её размера и сложности, может столкнуться с непредвиденными. . .	Создаем RESTful API с Laravel Jason-Webb 28.04.2025 REST (Representational State Transfer) — это архитектурный стиль, который определяет набор принципов для создания веб-сервисов. Этот подход к построению API стал стандартом де-факто в современной. . .	Дженерики в C# - продвинутые техники stackOverflow 28.04.2025 История дженериков началась с простой идеи — создать механизм для разработки типобезопасного кода без потери производительности. До их появления программисты использовали неуклюжие преобразования. . .

Сообщение форума

Отменить изменения