Кортежи и множества из прошлого урока научили хранить значения без повторов и без имён, а сегодня на сцену выходит структура, которая знает каждое своё значение по имени. Словарь в Python работает как обычный толковый словарь из бумажной книги: есть слово, есть определение, и нужная статья открывается мгновенно, без перелистывания всех страниц подряд. В программировании слово называют ключом, а определение значением, и такая пара закрывает огромный пласт задач: профили пользователей, настройки программы, карточки товаров, корзины покупок, кэш вычислений. Практически ни один реальный проект не обходится без словарей, поэтому этот урок стоит проработать не спеша, с запущенным интерпретатором под рукой.
Словарь как хранилище пар ключей и значений
Создаётся словарь фигурными скобками, внутри которых через запятую перечисляются пары вида ключ и значение, разделённые двоеточием:
user = {
"name": "Анна",
"age": 28,
"city": "Казань"
}
print(user)
print(len(user))
Функция len() вернёт 3, по числу пар. Ключом чаще всего становится строка, хотя подойдут и числа, и кортежи. Значением может быть что угодно: строка, число, список, другой словарь. Пустой словарь создаётся двумя способами, через пустые фигурные скобки или через функцию dict():
empty = {}
settings = dict()
print(type(empty), type(settings))
Есть и компактный вариант, dict() с именованными аргументами, при котором ключи не требуют кавычек:
user = dict(name="Анна", age=28)
print(user)
Перед тем как наполнять словарь, полезно держать в голове три правила:
- Ключом может быть только неизменяемый тип, например строка, число или кортеж, а список ключом стать не может;
- Ключи внутри одного словаря не повторяются, запись с существующим ключом перезаписывает старое значение;
- Значения повторяться могут спокойно, у двух разных ключей вправе оказаться одинаковые значения.
Второе правило ловит новичков постоянно. Человек второй раз добавляет в словарь ключ "age" и удивляется, почему значение поменялось, хотя он хотел добавить ещё одно поле. Словарь честно сделал то, о чём его попросили: ключи уникальны, поэтому старое значение затёрлось. Начиная с версии Python 3.7 словарь к тому же помнит порядок добавления пар, поэтому при выводе записи появятся в том порядке, в каком их занесли.
Отдельно стоит прочертить границу между списком и словарём. Список хранит набор однородных элементов, когда важна последовательность и позиция: шаги рецепта, очередь задач, оценки за четверть. Словарь хранит факты о сущности, когда у каждого значения есть имя и смысл: у пользователя есть имя, возраст и город. Путаница начинается там, где программист складывает объекты с полями в список, а потом выискивает нужный перебором, хотя пара ключей и значений решила бы вопрос за одно обращение. Простая проверка перед выбором структуры: если при чтении кода хочется спросить, что же лежит в element[2], значит, напрашивается словарь.
Доступ по ключу и суровая ошибка KeyError
Чтение значения идёт по ключу в квадратных скобках, и это самая частая операция над словарями:
user = {"name": "Анна", "age": 28}
print(user["name"])
print(user["age"])
user["age"] += 1
print(user["age"])
Пока ключ существует, всё гладко. Но стоит обратиться к несуществующему ключу, как интерпретатор поднимает KeyError:
user = {"name": "Анна"}
print(user["email"])
# KeyError: 'email'
Ошибка выглядит грозно, хотя смысл у неё простой: словарь честно сообщает, что такого ключа не знает. В скрипте из трёх строк источник проблемы виден сразу, а в большой программе KeyError иногда прилетает из глубины кода и портит настроение надолго. Опечатка в ключе, данные, пришедшие не в том формате, пустой ответ внешнего сервиса, всё это типичные причины. Значит, нужен способ чтения без риска, и у словарей он есть.
Метод get со значением по умолчанию
Метод get() возвращает значение по ключу, а при его отсутствии не роняет программу, а выдаёт запасной вариант:
user = {"name": "Анна", "age": 28}
print(user.get("email"))
print(user.get("email", "почта не указана"))
Первый вызов напечатает None, потому что значение по умолчанию не передано. Второй напечатает аккуратную заглушку. Поведение сильно отличается от квадратных скобок: там отсутствие ключа означает аварийное завершение, здесь программа спокойно продолжает работу. Опытные разработчики тянутся к get() везде, где отсутствие данных считается нормальной ситуацией, например когда пользователь не заполнил часть профиля. Обратная сторона медали в том, что заглушка умеет маскировать опечатку в ключе, и баг тихо живёт в программе неделями. Поэтому выбор между скобками и get() зависит от задачи: где нужна строгая проверка, а где мягкость.
У метода get() есть и более изящное применение, подсчёт элементов. Классическая задача про частоту слов решается в четыре строки:
text = "яблоко банан яблоко груша банан яблоко"
counts = {}
for word in text.split():
counts[word] = counts.get(word, 0) + 1
print(counts)
Выражение counts.get(word, 0) читается так: достань текущий счётчик слова, а если слова ещё нет, считай его равным нулю. Затем счётчик увеличивается и записывается обратно. Приём встречается в реальном коде на каждом шагу, от подсчёта ошибок в логах до статистики продаж по товарам.
Добавление, изменение и удаление записей в словаре
Новый ключ добавляется простым присваиванием, и этим словарь радикально отличается от списка, где позицию приходится вычислять:
user = {"name": "Анна"}
user["email"] = "Адрес электронной почты защищен от спам-ботов. Для просмотра адреса в браузере должен быть включен Javascript. "
user["age"] = 28
print(user)
То же присваивание меняет существующее значение: если ключ уже есть, Python записывает поверх него новое значение. Удаление идёт двумя путями. Метод pop() извлекает значение и убирает пару из словаря, а оператор del выкидывает запись безвозвратно:
user = {"name": "Анна", "age": 28, "city": "Казань"}
age = user.pop("age")
print(age)
del user["city"]
print(user)
Тонкость в том, что pop() принимает вторым аргументом значение по умолчанию, и тогда отсутствие ключа не оборачивается ошибкой, а del на несуществующем ключе честно поднимет KeyError. Когда записи приходят пачкой, выручает метод update(), вливающий пары другого словаря в исходный:
defaults = {"theme": "dark", "lang": "ru"}
user_settings = {"lang": "en"}
defaults.update(user_settings)
print(defaults)
Ключ lang перезаписался, ключ theme остался на месте. Такие слияния встречаются постоянно: базовые настройки по умолчанию объединяются с тем, что задал пользователь, и побеждают пользовательские значения.
Отдельная ловушка поджидает при копировании. Присваивание словаря новой переменной не создаёт копию, а лишь даёт второе имя тому же объекту:
original = {"lang": "ru"}
duplicate = original
duplicate["lang"] = "en"
print(original)
Вывод покажет en в обоих случаях, ведь под двумя именами скрывается один и тот же словарь. Для настоящей копии существует метод copy(), дублирующий словарь на верхнем уровне. Без этого знания начинающий программист однажды обнаружит, что изменение одной переменной неожиданно испортило вторую, и потратит вечер на поиски таинственной причины.
Проверка ключа и перебор содержимого словаря
Оператор in отвечает на вопрос, есть ли ключ в словаре, и обычно трудится внутри условия:
user = {"name": "Анна", "age": 28}
if "email" in user:
print("Почта указана")
else:
print("Почты нет")
Есть и обратный вариант not in, проверяющий отсутствие. Работает in очень быстро даже на огромных словарях, потому что внутри словарь устроен как хеш-таблица и находит ключ почти мгновенно, независимо от количества записей. За перебор содержимого отвечают три метода. keys() выдаёт ключи, values() значения, а items() пары целиком, и именно items() чаще всего пригождается в цикле for:
user = {"name": "Анна", "age": 28, "city": "Казань"}
for key in user.keys():
print(key)
for value in user.values():
print(value)
for key, value in user.items():
print(key, "=", value)
Две переменные в заголовке цикла выглядят поначалу как фокус, хотя это обычный синтаксис языка: items() отдаёт пары, а цикл раскладывает каждую на ключ и значение. Перебирать словарь можно и напрямую, конструкция for key in user даст тот же результат, что и keys(). А вот изменять словарь прямо во время перебора нельзя: добавление или удаление ключей внутри такого цикла приводит к ошибкам и непредсказуемому поведению, поэтому ключи для изменений сначала собирают в отдельный список, а потом обходят его.
Методы перебора красиво комбинируются с привычными функциями. len() считает пары, sum() складывает числовые значения, а max() отыщет самый дорогой товар в корзине:
cart = {"хлеб": 55, "молоко": 89, "сыр": 620}
print(len(cart), sum(cart.values()), max(cart.values()))
Одна строка заменяет цикл с ручным накоплением суммы и читается как обычное предложение. Такие связки придают коду лаконичность, которой сложно добиться со списками, где смысл элементов приходится передавать через позицию.
Вложенные словари на примере карточки товара
Значением словаря вправе быть другой словарь, и на этом строятся сложные структуры вроде карточек товаров в интернет-магазине:
product = {
"title": "Кофемолка",
"price": 3490,
"in_stock": True,
"specs": {
"power": 150,
"color": "белый",
"capacity_g": 60
}
}
print(product["price"])
print(product["specs"]["power"])
Обращение идёт цепочкой: сначала внешний ключ specs, затем внутренний power. Такая вложенность встречается повсюду, от файлов конфигурации до ответов веб-серверов, потому что отражает естественную иерархию предмета: у товара есть характеристики, у пользователя есть адрес, у раздела настроек есть подразделы. Формат JSON, на котором обмениваются данными веб-сервисы, почти дословно повторяет структуру словаря, так что навык чтения вложенных конструкций окупается при работе с любыми внешними интерфейсами. Глубину разумно ограничивать здравым смыслом: на третьем и четвёртом уровне код уже трудно читать, и структуру стоит упрощать. Проверять глубоко вложенные ключи безопаснее через get() на каждом уровне, тогда отсутствие промежуточного раздела не обернётся падением программы.
Телефонная книга как итоговый пример работы словаря
Соберём изученное в маленький, но полностью рабочий сценарий. Задача классическая: телефонная книга, в которую можно добавлять абонентов и искать номер по имени:
phonebook = {}
while True:
command = input("Команда (добавить, найти, список, выход): ")
if command == "добавить":
name = input("Имя: ")
number = input("Номер: ")
phonebook[name] = number
print("Абонент сохранён")
elif command == "найти":
name = input("Имя: ")
if name in phonebook:
print(name, phonebook[name])
else:
print("Такого абонента нет")
elif command == "список":
for name, number in phonebook.items():
print(name, "-", number)
elif command == "выход":
break
Здесь видно, как органично легли инструменты урока. Пустой словарь создан фигурными скобками и растёт по мере работы. Добавление записи выполнено присваиванием по ключу. Поиск начинается не с обращения по ключу, а с проверки in, поэтому программа не падает с KeyError на незнакомом имени. Вывод всего списка построен на items() с распаковкой пары. Сценарий легко расширяется: удалить абонента поможет pop(), переименование делается парой присваиваний, а число контактов даст len(). Полезно дописать эти ветки самостоятельно, такая тренировка закрепляет материал крепче любого перечитывания.
Любопытно, что поиск по номеру в такой книге тоже возможен, хотя словарь смотрит только в одну сторону, от ключа к значению. Обратный поиск строится перебором: цикл по items() сравнивает номера с искомым и выдаёт имя владельца. Для редких запросов этого достаточно, а если обратный поиск нужен часто, параллельно заводят второй словарь, где ключом служит номер. Правило простое: один словарь отвечает на один тип вопроса, и структура данных подстраивается под частые запросы, а не наоборот.
Заканчивать разбор хочется практическим наблюдением. Словарь кажется простой структурой, но именно он меняет стиль мышления: вместо россыпи переменных name, age и city программист заводит одну понятную сущность и обращается к её полям по смыслу. Данные складываются там, где их логично искать, а код читается как описание предметной области. В следующем уроке на сцену выйдут функции, которые научат заворачивать подобные сценарии в переиспользуемые блоки, и телефонная книга станет аккуратнее на глазах.