Удаление: del, pop и popitem

В прошлом уроке пары появлялись и обновлялись присваиванием. Осталась зеркальная задача — убрать лишнее: товар снят с продажи, запись удалена, счётчик сброшен. У словаря четыре инструмента на все случаи: del, pop, popitem и clear. Отличаются они тем, возвращают ли значение и что делают с отсутствующим ключом: del удаляет пару молча, pop сначала отдаёт значение, и только потом забывает ключ.

del: удалить пару

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

del stock['хлеб']

print(stock)

{'молоко': 12, 'сыр': 8}

Оператор del убирает пару целиком — и ключ, и значение, — и ничего не возвращает. Ключа 'хлеб' больше нет: обращение к нему теперь упало бы с KeyError из урока про строгий доступ. И у самого del тот же нрав: удалить отсутствующий ключ нельзя — словарь не догадывается, хотели вы что-то убрать или просто ошиблись.

pop: удалить и забрать значение

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

price = stock.pop('сыр')

print(price)
print(stock)

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

Метод pop — это «достать и выбросить» одним движением: он вернул значение 8 и тут же удалил пару. Отсутствующий ключ pop тоже не прощает — но у него есть запасной путь, которого нет у del: второй аргумент. Он вернётся вместо ошибки, если ключа нет:

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

print(stock.pop('кефир', 0))
print(stock.pop('кефир', 'нет такого'))
print(stock)

0
нет такого
{'молоко': 12}

popitem и clear: снять последнюю пару и опустошить всё

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

last = stock.popitem()
print(last)
print(stock)

stock.clear()
print(stock)

('хлеб', 5)
{'молоко': 12}
{}

Метод popitem вызывается без аргументов: он снимает последнюю добавленную пару и отдаёт её кортежем из двух элементов — ключа и значения. Метод clear удаляет все пары разом, оставляя пустой словарь. popitem удобен, когда словарь обрабатывают как стопку: снял верхнюю пару — поработал с ней. clear — приём резковатый: он опустошает всё без разбора, поэтому чаще пары удаляют по одной — через del или pop, а проверку «а есть ли ключ вообще» делают оператором in из следующего урока.

popitem как стопка: снимаем всё по порядку

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

data = {'a': 1, 'b': 2, 'c': 3}

while True:
    try:
        key, value = data.popitem()
    except KeyError:
        break
    print(key, value)

c 3
b 2
a 1

Пара-кортеж распаковывается прямо в две переменные — key, value = data.popitem(). Цикл заканчивается, когда словарь опустеет и popitem начнёт бросать KeyError: его ловим и выходим из цикла через break. Важно: в блоке except ничего не печатается: пустой словарь — это штатное завершение, а не ошибка.

Удаление во время обхода: почему нельзя

Отдельная грабли, на которую наступает почти каждый, кто впервые чистит словарь. Логика программиста простая: «просматриваю позиции, не годятся — удаляю». Python так не работает: он запрещает менять размер словаря посреди обхода и обрывает программу с RuntimeError. Причина техническая — обход держит в памяти указатель на текущую позицию таблицы, и удаление пары сдвигает всё следом, указатель уезжает мимо, и обход начинает повторять элементы или пропускать их.

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

removed = []
for name in list(stock):
    if stock[name] < 6:
        removed.append(name)
        del stock[name]

print('удалено:', removed)
print(stock)

удалено: ['хлеб']
{'молоко': 12, 'сыр': 8}

Обёртка list(stock) — обязательная деталь приёма: цикл идёт по копии ключей, и удаление из оригинала во время обхода уже безопасно. Собранные имена кладём в отдельный список removed — заодно получится готовый отчёт о том, что именно вычистили. Второй вариант — собрать новый словарь из нужных пар и просто заменить старый; оба подхода одинаково рабочие, первый чуть экономнее по памяти.

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

try:
    for name in stock:
        if stock[name] < 6:
            del stock[name]
except RuntimeError as e:
    print('RuntimeError:', e)

RuntimeError: dictionary changed size during iteration

Вот как это выглядит «в лоб». Текст ошибки достаточно красноречив: dictionary changed size during iteration — размер словаря изменился во время итерации. Никакой номера строки и никакого имени ключа здесь нет, потому что это не ошибка данных, а ошибка самого способа обхода. Лечится только переносом удалений за пределы цикла.

del или pop: как выбрать

Возвращаясь к выбору инструмента. Правило простое: если удалённое значение больше не нужно — del, он короче и молчит; если значение надо куда-то записать перед удалением — pop, он возвращает его. Разница в одну строку, но на практике pop спасает от ситуации, когда значение забыли сохранить и потом пришлось искать его в другом месте.

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

print(stock.pop('молоко'))
print(stock)
print(stock.pop('молоко', 'нет'))

12
{'хлеб': 5}
нет

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

Второй способ почистить: собрать новый словарь

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

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

fresh = {name: amount for name, amount in stock.items() if amount >= 6}

print(fresh)
print(stock)

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

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

Иногда удалять не нужно вовсе. В одном сервисе заказ нельзя было убрать из словаря: его статус смотрели три разных обработчика, и если бы пара исчезла, обработчик решил бы, что заказа не существует, и списал его повторно. Там оставили в словаре флаг deleted и пропускали такие записи при обходе.

Что дальше

Удалять пары вы теперь умеете четырьмя способами и знаете, почему нельзя удалять прямо в цикле. Дальше — проверка наличия ключа: оператор in отвечает на вопрос «есть ли такой ключ» и никогда не падает. В уроке 7 разбираем его, сравниваем с get и объясняем, почему поиск по ключу быстрый даже на огромных словарях.