Краткий ответ

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

Исторический контекст

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

Поэтому Python не разрешает использовать обычные изменяемые контейнеры, например списки и словари, ключами. Для наборов данных с неизменяемым содержимым существуют специальные хешируемые формы — кортежи и frozenset, если все их элементы также хешируемы.

Постановка проблемы

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

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

Подробное решение

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

Хешируемость не равна простой неизменяемости. Кортеж хешируем только тогда, когда хешируемы все его элементы; кортеж со списком внутри ключом быть не может. И наоборот, пользовательский изменяемый объект технически может иметь хеш, но это безопасно лишь при неизменности всех данных, участвующих в __hash__ и __eq__, пока объект используется как ключ.

Если класс переопределяет __eq__, Python обычно делает его экземпляры нехешируемыми, если класс явно не задаёт безопасный __hash__. Это предотвращает распространённую ошибку: объекты сравниваются по изменяемому содержимому, но получают неподходящий или унаследованный хеш.

items = {(1, 2): "точка", frozenset({"ru", "en"}): "языки"}
print(items[(1, 2)])

try:
    items[[1, 2]] = "список"
except TypeError as error:
    print(error)

В примере кортеж и frozenset подходят как ключи, а список вызывает TypeError, потому что список изменяем и не хешируется. При выборе ключа важно учитывать не только текущую структуру объекта, но и то, может ли измениться состояние, определяющее его равенство и хеш.

Ситуация из практики

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

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

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

Что кандидаты часто упускают

Достаточно ли объекту быть неизменяемым, чтобы стать ключом словаря?

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

Обязан ли каждый объект с одинаковым хешем быть равен другому объекту?

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

Можно ли безопасно использовать изменяемый объект как ключ, если его хеш не меняется?

Иногда технически да, но только если изменения не влияют ни на __hash__, ни на __eq__. Например, объект может содержать изменяемые служебные данные, не участвующие в идентичности. На практике такой дизайн требует строгого контроля и часто менее надёжен, чем явное использование неизменяемого ключа.