Как найти уникальный элемент в списке python

Предположим, есть список, который содержит повторяющиеся числа:

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

Но нужен список с уникальными числами:

numbers = [1, 2, 3, 4]

Есть несколько вариантов, как можно получить уникальные значения. Разберем их.

Вариант №1. Использование множества (set) для получения элементов

Использование множества (set) — один из вариантов. Он удобен тем, что включает только уникальные элементы. После этого множество можно обратно превратить в список.

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

numbers = [1, 2, 2, 3, 3, 4, 5]


def get_unique_numbers(numbers):

    list_of_unique_numbers = []

    unique_numbers = set(numbers)


    for number in unique_numbers:

        list_of_unique_numbers.append(number)


    return list_of_unique_numbers


print(get_unique_numbers(numbers))

Разберем, что происходит на каждом этапе. Есть список чисел numbers. Передаем его в функцию get_unique_numbers.

Внутри этой функции создается пустой список, который в итоге будет включать все уникальные числа. После этого используется set для получения уникальных чисел из списка numbers.

unique_numbers = set(numbers)

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

for number in unique_numbers:

       list_of_unique_numbers.append(number)

На каждой итерации текущее число добавляется в список list_of_unique_numbers. Наконец, именно этот список возвращается в конце программы.

Есть и более короткий способ использования множества для получения уникальных значений в Python. О нем и пойдет речь дальше.

Короткий вариант с set

Весь код выше можно сжать в одну строку с помощью встроенных в Python функций.

numbers = [1, 2, 2, 3, 3, 4, 5]

unique_numbers = list(set(numbers))

print(unique_numbers)

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

unique_numbers = list(set(numbers))

Проще всего думать «изнутри наружу» при чтении этого кода. Самый вложенный код выполняется первым: set(numbers). Затем — внешний блок: list(set(numbers)).

Вариант №2. Использование цикла for

Также стоит рассмотреть подход с использованием цикла.

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

Рассмотрим два способа использования цикла. Начнем с более подробного.

numbers = [20, 20, 30, 30, 40]


def get_unique_numbers(numbers):

    unique = []


    for number in numbers:

        if number in unique:

            continue

        else:

            unique.append(number)

    return unique


print(get_unique_numbers(numbers))

Вот что происходит на каждом этапе. Сначала есть список чисел numbers. Он передается в функцию get_unique_numbers.

Внутри этой функции создается пустой список unique. В итоге он будет включать все уникальные значения.

Цикл будет использоваться для перебора по числам в списке numbers.

    for number in numbers:

        if number in unique:

            continue

        else:

            unique.append(number)

Условные конструкции в цикле проверяют, есть ли число текущей итерации в списке unique. Если да, то цикл переходит на следующую итерации. Если нет — число добавляется в список.

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

Короткий способ с циклом

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

numbers = [20, 20, 30, 30, 40]


def get_unique_numbers(numbers):

    unique = []

    for number in numbers:

        if number not in unique:

            unique.append(number)

    return unique

Разница в условной конструкции. В этот раз она следующая — если числа нет в unique, то его нужно добавить.

if number not in unique:

    unique.append(number)

В противном случае цикл перейдет к следующему числу в списке numbers.

Результат будет тот же. Но иногда подобное читать сложнее, когда булево значение опускается.

Есть еще несколько способов поиска уникальных значений в списке Python. Но достаточно будет тех, которые описаны в этой статье.

If we need to keep the elements order, how about this:

used = set()
mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = [x for x in mylist if x not in used and (used.add(x) or True)]

And one more solution using reduce and without the temporary used var.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, [])

UPDATE – Dec, 2020 – Maybe the best approach!

Starting from python 3.7, the standard dict preserves insertion order.

Changed in version 3.7: Dictionary order is guaranteed to be insertion order. This behavior was an implementation detail of CPython from 3.6.

So this gives us the ability to use dict.from_keys for de-duplication!

NOTE: Credits goes to @rlat for giving us this approach in the comments!

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = list(dict.fromkeys(mylist))

In terms of speed – for me its fast enough and readable enough to become my new favorite approach!

UPDATE – March, 2019

And a 3rd solution, which is a neat one, but kind of slow since .index is O(n).

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = [x for i, x in enumerate(mylist) if i == mylist.index(x)]

UPDATE – Oct, 2016

Another solution with reduce, but this time without .append which makes it more human readable and easier to understand.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce(lambda l, x: l+[x] if x not in l else l, mylist, [])
#which can also be writed as:
unique = reduce(lambda l, x: l if x in l else l+[x], mylist, [])

NOTE: Have in mind that more human-readable we get, more unperformant the script is. Except only for the dict.from_keys approach which is python 3.7+ specific.

import timeit

setup = "mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']"

#10x to Michael for pointing out that we can get faster with set()
timeit.timeit('[x for x in mylist if x not in used and (used.add(x) or True)]', setup='used = set();'+setup)
0.2029558869980974

timeit.timeit('[x for x in mylist if x not in used and (used.append(x) or True)]', setup='used = [];'+setup)
0.28999493700030143

# 10x to rlat for suggesting this approach!   
timeit.timeit('list(dict.fromkeys(mylist))', setup=setup)
0.31227896199925453

timeit.timeit('reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, [])', setup='from functools import reduce;'+setup)
0.7149233570016804

timeit.timeit('reduce(lambda l, x: l+[x] if x not in l else l, mylist, [])', setup='from functools import reduce;'+setup)
0.7379565160008497

timeit.timeit('reduce(lambda l, x: l if x in l else l+[x], mylist, [])', setup='from functools import reduce;'+setup)
0.7400134069976048

timeit.timeit('[x for i, x in enumerate(mylist) if i == mylist.index(x)]', setup=setup)
0.9154880290006986

ANSWERING COMMENTS

Because @monica asked a good question about “how is this working?”. For everyone having problems figuring it out. I will try to give a more deep explanation about how this works and what sorcery is happening here 😉

So she first asked:

I try to understand why unique = [used.append(x) for x in mylist if x not in used] is not working.

Well it’s actually working

>>> used = []
>>> mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
>>> unique = [used.append(x) for x in mylist if x not in used]
>>> print used
[u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow']
>>> print unique
[None, None, None, None, None]

The problem is that we are just not getting the desired results inside the unique variable, but only inside the used variable. This is because during the list comprehension .append modifies the used variable and returns None.

So in order to get the results into the unique variable, and still use the same logic with .append(x) if x not in used, we need to move this .append call on the right side of the list comprehension and just return x on the left side.

But if we are too naive and just go with:

>>> unique = [x for x in mylist if x not in used and used.append(x)]
>>> print unique
[]

We will get nothing in return.

Again, this is because the .append method returns None, and it this gives on our logical expression the following look:

x not in used and None

This will basically always:

1. evaluates to False when x is in used,
2. evaluates to None when x is not in used.

And in both cases (False/None), this will be treated as falsy value and we will get an empty list as a result.

But why this evaluates to None when x is not in used? Someone may ask.

Well it’s because this is how Python’s short-circuit operators works.

The expression x and y first evaluates x; if x is false, its value is
returned; otherwise, y is evaluated and the resulting value is
returned.

So when x is not in used (i.e. when its True) the next part or the expression will be evaluated (used.append(x)) and its value (None) will be returned.

But that’s what we want in order to get the unique elements from a list with duplicates, we want to .append them into a new list only when we they came across for a fist time.

So we really want to evaluate used.append(x) only when x is not in used, maybe if there is a way to turn this None value into a truthy one we will be fine, right?

Well, yes and here is where the 2nd type of short-circuit operators come to play.

The expression x or y first evaluates x; if x is true, its value is
returned; otherwise, y is evaluated and the resulting value is
returned.

We know that .append(x) will always be falsy, so if we just add one or next to him, we will always get the next part. That’s why we write:

x not in used and (used.append(x) or True)

so we can evaluate used.append(x) and get True as a result, only when the first part of the expression (x not in used) is True.

Similar fashion can be seen in the 2nd approach with the reduce method.

(l.append(x) or l) if x not in l else l
#similar as the above, but maybe more readable
#we return l unchanged when x is in l
#we append x to l and return l when x is not in l
l if x in l else (l.append(x) or l)

where we:

1. Append x to l and return that l when x is not in l. Thanks to the or statement .append is evaluated and l is returned after that.
2. Return l untouched when x is in l

Given a list, print all the unique numbers in any order.

Examples: 

Input : 10 20 10 30 40 40
Output : 10 20 30 40 

Input : 1 2 1 1 3 4 3 3 5 
Output : 1 2 3 4 5  

Method 1: Traversal of the list

Using traversal, we can traverse for every element in the list and check if the element is in the unique_list already if it is not over there, then we can append it to the unique_list. This is done using one for loop and another if statement which checks if the value is in the unique list or not which is equivalent to another for a loop.  

the unique values from 1st list is
10 20 30 40 
the unique values from 2nd list is
1 2 3 4 5

Time Complexity: O(n*n)
Auxiliary Space: O(n)

Method 2: Using Set

Using set() property of Python, we can easily check for the unique values. Insert the values of the list in a set. Set only stores a value once even if it is inserted more than once. After inserting all the values in the set by list_set=set(list1), convert this set to a list to print it. 

the unique values from 1st list is
40 10 20 30 
the unique values from 2nd list is
1 2 3 4 5

Time complexity: O(n), where n is length of list.
Auxiliary Space: O(n), where n is length of list.

Method 3: Using numpy.unique

Using Python’s import numpy, the unique elements in the array are also obtained. In the first step convert the list to x=numpy.array(list) and then use numpy.unique(x) function to get the unique values from the list. numpy.unique() returns only the unique values in the list. 

Output: 

the unique values from 1st list is
[10 20 30 40]

the unique values from 2nd list is
[1 2 3 4 5]

Time complexity: O(nlogn) due to the use of the sorting algorithm used by the numpy.unique() function. 
Auxiliary space: O(n) because numpy.unique() function creates a copy of the input array and then sorts it before returning the unique elements. 

Method #4: Using collections.Counter()

Using python import Counter() from collections print all the keys of Counter elements or we print directly by using the “*” symbol. Below is the implementation of above approach.

the unique values from 1st list is
10 20 30 40

the unique values from 2nd list is
1 2 3 4 5

Time Complexity: O(n), where n is the number of elements in the input list.
Auxiliary Space : O(n)

Method #5: Using reduce()

Using python import reduce() from functools and iterate over all element and checks if the element is a duplicate or unique value. Below is the implementation of the above approach.

the unique values from 1st list is
[10, 20, 30, 40]

the unique values from 2nd list is
[1, 2, 3, 4, 5]

Method #6:Using Operator.countOf() method

the unique values from 1st list is
10
20
30
40

the unique values from 2nd list is
1
2
3
4
5

Time Complexity:O(N)
Auxiliary Space: O(N)

Method#7: Using pandas

Output:

the unique values from 1st list is
10
20
30
40

the unique values from 2nd list is
1
2
3
4
5

Time Complexity:O(N)
Auxiliary Space: O(N)

Method #8: Using dict.fromkeys() –

Using the fromkeys() method of dictionary data structure we can fetch the unique elements.

Step – 1: Firstly we need to define a list which consists of duplicate elements.

Step – 2 : Then we need to use a variable in which we will store the result after using the fromkeys() method.

Step – 3 : We need to convert that result into list, as the fromkeys() method is part of the dictionary so by default it returns a dictionary with all the unique keys and None as their values.

Step – 4 : We will print the final result.

[10, 20, 30, 40]
[1, 2, 3, 4, 5]

Time Complexity – O(n)
Space Complexity – O(n)

Last Updated :
15 May, 2023

Like Article

Save Article