Добавление и изменение пар в словаре

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

Новая пара: d[ключ] = значение

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

stock = {'молоко': 12}

stock['хлеб'] = 5
stock['сыр'] = 8

print(stock)

{'молоко': 12, 'хлеб': 5, 'сыр': 8}

Новые пары встают в конец — и печатаются в том же порядке. Словарь помнит порядок вставки: сначала добавили 'хлеб', потом 'сыр' — в этом порядке они и живут. Так пустой словарь {} из урока про создание превращается в полноценный справочник, пара за парой.

Тот же ключ — другая работа

stock = {'молоко': 12, 'хлеб': 5}

stock['молоко'] = 10

print(stock)

{'молоко': 10, 'хлеб': 5}

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

prices = {'молоко': 89, 'молоко': 99}

print(prices)
print(len(prices))

{'молоко': 99}
1

Уникальность ключей — не причуда, а фундамент всей адресации словаря: имя ведёт ровно к одному значению, поэтому поиск по ключу однозначен. Типичный рабочий сценарий перезаписи — обновление по свежим данным: цена изменилась, счёт вырос. Новое значение часто считают от старого — читают по ключу и тут же записывают обратно; у прибавления есть и короткая запись +=. Ключ при этом должен существовать, иначе чтение упадёт: как проверить его заранее — в уроке про in.

score = {'Анна': 12}

score['Анна'] = score['Анна'] + 3

print(score)

{'Анна': 15}

Замена не двигает пару на новое место

Вот место, где словарь ведёт себя не так, как ожидают. Многие думают, что присваивание по существующему ключу «пересоздаёт» пару, и та встаёт в конец. Нет: пара сохраняет свою позицию, меняется только значение. Проверяется это просто.

cart = {}
cart['чай'] = 1
cart['кофе'] = 2
cart['чай'] = 3

print(cart)
print(list(cart))

{'чай': 3, 'кофе': 2}
['чай', 'кофе']

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

Счётчик в одну строку

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

words = ['чай', 'кофе', 'чай']
count = {}

for w in words:
    count[w] = count.get(w, 0) + 1

print(count)

{'чай': 2, 'кофе': 1}

Это рабочий код, но писать его руками каждый раз лень. Ровно для таких мест в стандартной библиотеке есть Counter — словарь, который считает сам: в уроке 11 разбираем его подробно. А defaultdict(int) из урока 12 умеет то же самое ещё короче: счётчик стартует с нуля сам, и строка превращается в count[w] += 1 без всякого .get.

Обратите внимание на +=. Это не отдельная операция словаря, а сокращение Python: score['Анна'] += 3 разворачивается в score['Анна'] = score['Анна'] + 3. И тут скрыта ловушка — прочитать значение приходится раньше, чем записать, а значит, ключ обязан существовать. Для счётчика, где ключ может появиться впервые, += не подходит: он уронит программу с KeyError. Либо get с нулём, либо defaultdict.

score = {'Анна': 12, 'Борис': 9}

score['Анна'] += 3
score['Борис'] += 1

print(score)

{'Анна': 15, 'Борис': 10}

Удаление дешёвых позиций

Присваивание умеет и обратное: del d[ключ] убирает пару целиком. Нюанс в том, что нельзя удалять прямо во время обхода словаря — Python ломает обход с RuntimeError. Если нужно вычистить дешёвые позиции, сначала соберите ключи-кандидаты в список и удаляйте после цикла.

prices = {'молоко': 89, 'хлеб': 42}

for name in list(prices.keys()):
    if prices[name] < 50:
        del prices[name]

print(prices)

{'молоко': 89}

Обёртка list(...) — обязательная часть приёма. Она делает копию ключей, по которой цикл идёт уже без оглядки на словарь: удалять из оригинала во время такого обхода можно спокойно. Подробнее про запрет менять словарь во время перебора — в уроке 8.

Что дальше

Добавлять и менять пары вы умеете. Обратная операция — удаление — в уроке 6: там четыре инструмента (del, pop, popitem, clear) и разница между ними, которая на практике важнее, чем кажется. А чтобы не гадать, есть ли ключ вообще, — урок 7 про оператор in.

Шпаргалка: добавить, изменить, удалить

Самая частая ошибка при работе с парами — не в синтаксисе, а в ожиданиях. Первый сюрприз: перезапись не переносит пару на новое место, второй: += требует существующего ключа, третий: дубликат ключа в данных исчезает без следа. Все три мы разобрали — теперь ясно, где искать, если что-то пойдёт не так.