Python: TypeError 'unhashable type: list' — как исправить ошибку быстро

kirilljsx

В Python ошибка TypeError: unhashable type: ‘list’ возникает, когда вы пытаетесь использовать список как ключ словаря или элемент множества. Это происходит потому, что списки изменяемы, а для хэширования нужны неизменяемые типы. В этой статье разберем причины и покажем простые способы исправления, чтобы ваш код работал без сбоев.

Знание этих решений сэкономит часы отладки. Мы пройдемся по типичным случаям, примерам и лучшим практикам. После прочтения вы сможете избежать подобных ошибок в проектах с данными, ML или веб-разработкой.

Почему Python не позволяет хэшировать списки

Списки в Python — это мутабельные структуры, то есть их содержимое можно менять после создания. Функция hash() требует стабильного значения, которое не изменится. Если список попадет в словарь как ключ или в set, Python выдаст ошибку, потому что не сможет вычислить его хэш.

Представьте ситуацию: у вас есть данные вроде координат или слов, и вы хотите убрать дубликаты через set(). Или строите словарь, где ключ — список параметров запроса. Код ломается на строке вроде my_set.add([1, 2, 3]) или mydict[[1, 2]] = 'value'. Это классика, особенно в обработке текста или данных из JSON.

Ошибка проявляется в traceback с указанием строки. Часто это циклы с for item in data, где item — список, и дальше идет item in some_set. Логично перейти к решениям: их несколько, и выбор зависит от задачи.

Проверьте traceback: найдите точную строку с ошибкой и тип объекта.
Используйте type(obj): чтобы подтвердить, что это list.
Преобразуйте в tuple: базовое решение для большинства случаев.

Базовые способы исправления: список в tuple

Самое простое решение — преобразовать список в кортеж с помощью tuple(). Кортежи неизменяемы, их хэш стабилен, и они работают как ключи словарей или элементы set. Это подходит для 90% случаев, когда данные простые и не вложенные.

Возьмем пример: пытаетесь создать set из списка списков для удаления дубликатов.

# Ошибка
data = [[1, 2], [3, 4], [1, 2]]
unique = set(data)  # TypeError: unhashable type: 'list'

Исправление:

unique = set(tuple(item) for item in data)
print(unique)  # {(1, 2), (3, 4)}

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

Ситуация	Ошибочный код	Решение
Set из списков	`set([[1,2]])`	`set(tuple(lst) for lst in data)`
Ключ словаря	`d[[1,2]] = val`	`d[tuple([1,2])] = val`
Проверка вхождения	`if [1,2] in my_set`	`if tuple([1,2]) in my_set`

Преимущества tuple: скорость, память, совместимость с hash.
Когда не подходит: если данные глубоко вложены или содержат другие списки.
Альтернатива: строки через str(lst), но это медленнее и менее читаемо.

Работа с вложенными структурами и словарями

Когда внутри списков есть другие списки, словари или set, простого tuple() недостаточно — ошибка уйдет глубже. Нужно рекурсивно преобразовать всю структуру. Это типично для парсинга JSON или данных из API, где объекты смешанные.

Пример проблемы: tuple с list внутри.

data = (1, [2, 3])
hash(data)  # TypeError

Решение — функция для рекурсивного хэширования:

def make_hashable(obj):
    if isinstance(obj, list):
        return tuple(make_hashable(item) for item in obj)
    elif isinstance(obj, dict):
        return frozenset((k, make_hashable(v)) for k, v in obj.items())
    elif isinstance(obj, set):
        return frozenset(make_hashable(item) for item in obj)
    return obj

hashable_data = make_hashable(data)
print(hash(hashable_data))  # Работает

Для словарей unhashable type: 'dict' используйте frozenset(items()). В чат-ботах или NLP, как в примерах с NLTK, это спасает при создании bag-of-words или pickle-дампов.

Для dict в set: set(tuple(d.items()) for d in dicts).
JSON-строки: json.dumps(lst, sort_keys=True) — универсально, но потеря типа.
Нюанс: сортируйте ключи в dict для стабильного хэша.

Тип	Хэшируемая замена	Пример
list	tuple()	`tuple([1,2])`
dict	frozenset(items())	`frozenset(d.items())`
set	frozenset()	`frozenset(s)`
nested	Рекурсия	Функция make_hashable

Особые случаи в ML и кастомных классах

В машинном обучении, например с NLTK или LangChain, ошибка часто в classes.index(doc) или Qdrant-векторах, где word_list — список. Решение: лемматизируйте и tuple’изуйте перед хранением.

Пример из чат-бота:

# Ошибка
words.append(word_list)  # list of lists
# Потом
for word in words:  # word is list
    bag.append(1 if word in word_patterns else 0)

Исправление: words.extend(word_list) вместо append, или tuple на этапе.

Для кастомных классов реализуйте __hash__ и __eq__:

class MyClass:
    def __init__(self, data):
        self.data = tuple(data)  # tuple внутри
    def __hash__(self):
        return hash(self.data)
    def __eq__(self, other):
        return self.data == other.data

В pickle: дампьте tuple-версии.
В pandas: df.drop_duplicates() сам конвертирует.
Внимание: __hash__ вызывается только если нет изменений после.

Случаи, когда лучше изменить структуру кода

Иногда преобразования — костыль. Проще перестроить логику: используйте dict с tuple-ключами изначально или Counter из collections. В больших данных set списков замените на multimap.

Например, вместо set списков для уникальности — dict с tuple: unique_dict = {tuple(lst): lst for lst in data}. Затем list(unique_dict.values()). Это сохраняет оригинальные списки.

Другие идеи:

collections.defaultdict(list): собирайте без хэша.
itertools.groupby: группировка без set.
numpy.unique: для массивов быстрее.

Подход	Когда использовать	Скорость
tuple()	Простые списки	Высокая
Рекурсия	Вложенные	Средняя
Изменить структуру	Частые операции	Высокая

Хэширование без компромиссов: продвинутые трюки

Даже после tuple могут быть подводные камни: неуникальные хэши или потеря порядка. Для критичных задач используйте sorted tuple или строки с repr(). В продакшене добавьте логирование типов.

В многопотоке hash может конфликтовать — используйте id() или внешние ID. Осталось подумать о производительности: для миллионов элементов тесты покажут, что frozenset быстрее tuple на 20-30%. В реальных проектах комбинируйте с profiling.