Обработка коллекций: поиск неповторяющихся значений в Python

Расширенные примеры получения уникальных значений

1. Использование itertools.groupby для уникальных значений по ключу

Группировка последовательности и взятие первого элемента каждой группы. Подходит для отсортированных данных.

import itertools

pairs = [('a', 1), ('a', 2), ('b', 3), ('b', 4), ('c', 5)]
pairs.sort(key=lambda x: x[0])  # обязательно сортировка
unique_by_key = [next(group) for key, group in itertools.groupby(pairs, key=lambda x: x[0])]
print(unique_by_key)

[('a', 1), ('b', 3), ('c', 5)]

2. numpy.unique для числовых массивов

Работает с любыми numpy массивами, возвращает отсортированные уникальные значения.

import numpy as np
arr = np.array([3, 1, 2, 3, 4, 2, 1])
uniq = np.unique(arr)
print(uniq)

[1 2 3 4]

Также можно получить массив индексов для восстановления исходного массива, количества вхождений.

uniq, counts = np.unique(arr, return_counts=True)
print(uniq, counts)  # [1 2 3 4] [2 2 2 1]

3. Генератор для ленивого вычисления уникальных элементов

Позволяет обрабатывать большие потоки данных без хранения всего набора в памяти.

def unique_generator(iterable):
    seen = set()
    for item in iterable:
        if item not in seen:
            seen.add(item)
            yield item

large_list = [1, 2, 2, 3, 4, 3]
for u in unique_generator(large_list):
    print(u, end=' ')

1 2 3 4

4. Использование декоратора для мемоизации уникальных результатов функции

При вызове функции с одинаковыми аргументами возвращается уже вычисленное значение (кеширование).

from functools import lru_cache

@lru_cache(maxsize=None)
def expensive_calc(x):
    # Имитация тяжелых вычислений
    return x * x

values = [2, 3, 2, 4, 3, 5]
unique_results = {expensive_calc(v) for v in values}
print(unique_results)  # {4, 9, 16, 25}

5. Обработка уникальных строк из файла

Чтение файла построчно и сбор уникальных строк с сохранением порядка первого вхождения.

from collections import OrderedDict

unique_lines = []
with open('data.txt', 'r') as f:
    for line in f:
        stripped = line.strip()
        if stripped and stripped not in unique_lines:
            unique_lines.append(stripped)
print(unique_lines[:5])  # первые 5 уникальных строк

Более эффективно при большом файле: использовать OrderedDict или dict.fromkeys.

from collections import OrderedDict

with open('data.txt', 'r') as f:
    lines = (line.strip() for line in f if line.strip())
    unique_ordered = list(OrderedDict.fromkeys(lines))
print(unique_ordered[:5])

6. Использование filter с lambda для уникальности по определенному свойству

Например, оставить только уникальные значения длины строки.

words = ['cat', 'dog', 'elephant', 'cat', 'tiger', 'dog']
seen_lengths = set()
def is_new_length(word):
    length = len(word)
    if length not in seen_lengths:
        seen_lengths.add(length)
        return True
    return False

unique_by_len = list(filter(is_new_length, words))
print(unique_by_len)  # ['cat', 'elephant'] ('dog' и 'tiger' не попали, т.к. длина 3 и 5 уже есть)

7. Использование reduce для накопления уникальных значений (учебный пример)

Не рекомендуется из-за читаемости, но возможно.

from functools import reduce

numbers = [1, 2, 2, 3, 3, 4]
unique_reduce = reduce(lambda acc, x: acc if x in acc else acc + [x], numbers, [])
print(unique_reduce)  # [1, 2, 3, 4]

8. Собственный хеш для объектов пользовательских классов

Если нужно определить уникальность по собственным правилам, переопределяются методы __eq__ и __hash__.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __eq__(self, other):
        return self.name == other.name
    def __hash__(self):
        return hash(self.name)
    def __repr__(self):
        return f"{self.name} ({self.age})"

people = [Person('Anna', 25), Person('Bob', 30), Person('Anna', 35)]
unique_people = list(set(people))
print(unique_people)  # [Anna (25), Bob (30)] - Anna (35) отброшена, т.к. name совпадает

9. Получение уникальных значений из нескольких кортежей с сохранением порядка объединения

t1 = (1, 2, 3)
t2 = (2, 3, 4)
t3 = (4, 5, 6)
merged = t1 + t2 + t3
unique = list(dict.fromkeys(merged))
print(unique)  # [1, 2, 3, 4, 5, 6]