Как удалить дубликаты из списка в Python одной строкой

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

set(x): дубликаты исчезают одной строкой

set() от списка из урока 2 отбрасывает повторы молча и мгновенно. Проверим на списке, где каждый элемент встречается дважды:

nums = [3, 1, 3, 2, 1, 2]

unique = set(nums)
print('уникальных:', len(unique))
print(sorted(unique))
print(sorted(list(set(nums))))

уникальных: 3
[1, 2, 3]
[1, 2, 3]

Шесть элементов превратились в три, и вторая строка — уже встречавшаяся идиома list(set(x)): множество отфильтровало дубликаты, list вернул список. Обратите внимание на печать: и в одном, и в другом случае вывод идёт через sorted. Множество не хранит порядок — печатать его напрямую нельзя, результаты будут разными от запуска к запуску, а sorted даёт стабильный отсортированный список. Для чисел это удобный порядок; для строк — алфавитный.

dict.fromkeys(x): дубликаты с сохранением порядка

Когда порядок первого вхождения важен — гости в журнале, страницы в маршруте, — на помощь приходит словарь. dict.fromkeys(x) строит словарь, у которого ключами служат элементы списка, а значения пустые. Ключи в словаре помнят порядок вставки, а дубликат просто не создаёт вторую пару:

logs = ['Анна', 'Борис', 'Анна', 'Вера', 'Борис']

print('уникальных имён:', len(set(logs)))
print('dict.fromkeys сохраняет порядок:', list(dict.fromkeys(logs)))

уникальных имён: 3
dict.fromkeys сохраняет порядок: ['Анна', 'Борис', 'Вера']

dict.fromkeys сохраняет порядок первого вхождения: словарь помнит порядок вставки ключей, а дубликат не создаёт вторую пару. Анна попала в результат от первой записи, Борис — от второй, Вера — от четвёртой. Обёртка list возвращает список ключей — теперь его можно печатать напрямую: порядок у списка гарантирован.

seen_days = dict.fromkeys(['пн', 'вт'], 0)

print(seen_days)
seen_days['пн'] += 1
print(list(seen_days), seen_days['пн'])

{'пн': 0, 'вт': 0}
['пн', 'вт'] 1

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

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

Своё правило равенства: ручной цикл с памятью

Оба приёма сравнивают элементы через ==, а это не всегда то равенство, которое нужно. Теги Python и python — для множества разные строки, хотя человек видит один тег. Когда равенство своё, порядок важен и хочется одного прохода, работает ручной цикл: множество служит памятью о том, что уже видели:

tags = ['Python', 'python', 'PYTHON', 'книги', 'Книги']

seen = set()
unique_tags = []
for tag in tags:
    key = tag.lower()
    if key not in seen:
        seen.add(key)
        unique_tags.append(tag)

print(unique_tags)
print(len(tags), '->', len(unique_tags))

['Python', 'книги']
5 -> 2

Множество seen хранит не сами теги, а их нижние версии — ключ сравнения. Первое вхождение осталось в списке в исходном регистре: Python и книги, без перемен. Проверка in на множестве стоит O(1) из урока 5, поэтому весь проход — O(n): на списке в миллион элементов цикл не притормозит.

Только посчитать: len(set(x))

Часто список дубликатов не нужен вовсе — нужен ответ на вопрос «сколько разных». Тогда ни sorted, ни fromkeys не нужны:

answers = ['да', 'нет', 'да', 'не знаю', 'нет', 'да']

print('ответов:', len(answers))
print('разных ответов:', len(set(answers)))
print('есть повтор:', len(answers) != len(set(answers)))

ответов: 6
разных ответов: 3
есть повтор: True

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

purchases = [5, 7, 5, 7, 7]

print('чек с повторами:', sum(purchases))
print('уникальные товары:', sorted(set(purchases)))
print('сумма без повторов:', sum(set(purchases)))

чек с повторами: 31
уникальные товары: [5, 7]
сумма без повторов: 12

Множество работает с любыми функциями, которые умеют перебирать коллекцию: sum, min, max, len. Пять покупок свелись к двум уникальным товарам, и сумма по множеству отвечает на вопрос «сколько стоит один комплект из купленного». Считать поверх set не только короче, но и безопаснее перебора с флажками.

Дубликаты кортежей и предел приёма

Элементы могут быть и составными: пары координат, записи. Кортежи из урока 11 хешируемы, поэтому оба приёма работают с ними без изменений:

points = [(1, 2), (3, 4), (1, 2), (5, 6)]

print(list(dict.fromkeys(points)))
print(sorted(set(points)))

[(1, 2), (3, 4), (5, 6)]
[(1, 2), (3, 4), (5, 6)]

rows = [[1, 2], [3, 4], [1, 2]]

as_tuples = []
for r in rows:
    as_tuples.append(tuple(r))

print(sorted(set(as_tuples)))

[(1, 2), (3, 4)]

Что дальше

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

Итог урока умещается в таблицу из двух строк: set(x) — когда порядок безразличен, dict.fromkeys(x) — когда важен порядок первого вхождения. Всё остальное — вопрос того, что считать равным, и это правило вы задаёте сами.