Usuwanie duplikatów na listach

W Pythonie 2.7, nowy sposób usuwania duplikatów z iterowalnych przy zachowaniu pierwotnej kolejności to:

>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

W Pythonie 3.5, OrderedDict posiada implementację C. Moje timingi pokazują, że jest to teraz najszybsze i najkrótsze z różnych podejść do Pythona 3.5.

W Pythonie 3.6 , zwykły dict stał się zarówno uporządkowany, jak i zwarty. (Ta funkcja jest dostępna dla CPython i PyPy, ale może nie występować w innych implementacjach). Że daje nam nowy najszybszy sposób dedupowania przy zachowaniu porządku:

>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

W Pythonie 3.7 , zwykły dict jest gwarantowany dla obu uporządkowanych we wszystkich implementacjach. zatem najkrótszym i najszybszym rozwiązaniem jest:

>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

To jednolinijkowy: list(set(source_list)) da radę.

A {[2] } jest czymś, co nie może mieć duplikatów.

Update: podejście zachowujące porządek to dwie linie:

from collections import OrderedDict
OrderedDict((x, True) for x in source_list).keys()

Tutaj używamy faktu, że OrderedDict zapamiętuje kolejność wstawiania kluczy i nie zmienia jej, gdy wartość w danym kluczu jest aktualizowana. Wstawiamy True jako wartości, ale możemy wstawić cokolwiek, wartości po prostu nie są używane. (set działa podobnie jak {[6] } z ignorowanymi wartościami.)

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> t
[1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> s = []
>>> for i in t:
       if i not in s:
          s.append(i)
>>> s
[1, 2, 3, 5, 6, 7, 8]

Jeśli nie zależy ci na zamówieniu, po prostu zrób to:

def remove_duplicates(l):
    return list(set(l))

A set gwarantuje, że nie będą miały duplikatów.

Aby utworzyć nową listę zachowującą kolejność pierwszych elementów duplikatów w L

newlist=[ii for n,ii in enumerate(L) if ii not in L[:n]]

Na przykład if L=[1, 2, 2, 3, 4, 2, 4, 3, 5] wtedy newlist będzie [1,2,3,4,5]

Sprawdza, czy każdy nowy element nie pojawił się wcześniej na liście przed dodaniem go. Również nie wymaga importu.

Inny sposób działania:

>>> seq = [1,2,3,'a', 'a', 1,2]
>> dict.fromkeys(seq).keys()
['a', 1, 2, 3]

Kolega wysłał mi zaakceptowaną odpowiedź jako część kodu do codereview dzisiaj. Chociaż z pewnością podziwiam elegancję odpowiedzi na pytanie, nie jestem zadowolony z wykonania. Próbowałem tego rozwiązania (używam set aby skrócić czas wyszukiwania)

def ordered_set(in_list):
    out_list = []
    added = set()
    for val in in_list:
        if not val in added:
            out_list.append(val)
            added.add(val)
    return out_list

Aby porównać wydajność, użyłem losowej próbki 100 liczb całkowitych - 62 były unikalne

from random import randint
x = [randint(0,100) for _ in xrange(100)]

In [131]: len(set(x))
Out[131]: 62

Oto wyniki pomiarów

In [129]: %timeit list(OrderedDict.fromkeys(x))
10000 loops, best of 3: 86.4 us per loop

In [130]: %timeit ordered_set(x)
100000 loops, best of 3: 15.1 us per loop

Cóż, co się stanie, jeśli set zostanie usunięty z rozwiązanie?

def ordered_set(inlist):
    out_list = []
    for val in inlist:
        if not val in out_list:
            out_list.append(val)
    return out_list

Wynik nie jest tak zły jak w przypadku OrderedDict , ale nadal ponad 3 razy w stosunku do oryginalnego rozwiązania

In [136]: %timeit ordered_set(x)
10000 loops, best of 3: 52.6 us per loop

Istnieją również rozwiązania wykorzystujące Pandy i Numpy. Obie zwracają tablicę numpy, więc trzeba użyć funkcji .tolist() jeśli chcesz listę.

t=['a','a','b','b','b','c','c','c']
t2= ['c','c','b','b','b','a','a','a']

Rozwiązanie Pandas

Używanie funkcji Pandy unique():

import pandas as pd
pd.unique(t).tolist()
>>>['a','b','c']
pd.unique(t2).tolist()
>>>['c','b','a']

Rozwiązanie Numpy

Używanie funkcji numpy unique().

import numpy as np
np.unique(t).tolist()
>>>['a','b','c']
np.unique(t2).tolist()
>>>['a','b','c']

Zauważ, że numpy.unique() sortuje również wartości . Tak więc lista t2 jest zwracana posortowana. Jeśli chcesz mieć zachowaną kolejność Użyj jak w ta odpowiedź :

_, idx = np.unique(t2, return_index=True)
t2[np.sort(idx)].tolist()
>>>['c','b','a']

Rozwiązanie nie jest tak eleganckie w porównaniu do innych, jednak w porównaniu do pand.unique (), numpy.unique () pozwala również sprawdzić, czy zagnieżdżone tablice są unikalne wzdłuż jednej wybranej osi.

Proste i łatwe:

myList = [1, 2, 3, 1, 2, 5, 6, 7, 8]
cleanlist = []
[cleanlist.append(x) for x in myList if x not in cleanlist]

Wyjście:

>>> cleanlist 
[1, 2, 3, 5, 6, 7, 8]

Miałem dict na swojej liście, więc nie mogłem skorzystać z powyższego podejścia. Mam błąd:

TypeError: unhashable type:

Więc jeśli zależy ci na zamów i / lub niektóre przedmioty są nieszablonowe . To może okazać się przydatne:

def make_unique(original_list):
    unique_list = []
    [unique_list.append(obj) for obj in original_list if obj not in unique_list]
    return unique_list

Niektórzy mogą uznać zrozumienie listy z efektem ubocznym za nie dobre rozwiązanie. Oto alternatywa:

def make_unique(original_list):
    unique_list = []
    map(lambda x: unique_list.append(x) if (x not in unique_list) else False, original_list)
    return unique_list

Spróbuj użyć zestawów:

import sets
t = sets.Set(['a', 'b', 'c', 'd'])
t1 = sets.Set(['a', 'b', 'c'])

print t | t1
print t - t1

Możesz też to zrobić:

>>> t = [1, 2, 3, 3, 2, 4, 5, 6]
>>> s = [x for i, x in enumerate(t) if i == t.index(x)]
>>> s
[1, 2, 3, 4, 5, 6]

Powyższe działanie polega na tym, że metoda index zwraca tylko pierwszy indeks elementu. Zduplikowane elementy mają wyższe indeksy. Zobacz tutaj :

Lista.index (x [, start [, end]])
Zwraca indeks bazujący na 0 na liście pierwszy element, którego wartością jest x. podnosi wartość ValueError jeśli nie ma taki przedmiot.

Wszystkie podejścia zachowujące porządek, które widziałem tutaj do tej pory, albo używają naiwnego porównania (z O (N^2) w najlepszym przypadku złożoności czasowej) lub ciężkiej wagi OrderedDicts/set+list kombinacje, które są ograniczone do hashable wejść. Oto rozwiązanie niezależne od hasha O (nlogn):

Update dodano argument key, dokumentację i kompatybilność Pythona 3.

# from functools import reduce <-- add this import on Python 3

def uniq(iterable, key=lambda x: x):
    """
    Remove duplicates from an iterable. Preserves order. 
    :type iterable: Iterable[Ord => A]
    :param iterable: an iterable of objects of any orderable type
    :type key: Callable[A] -> (Ord => B)
    :param key: optional argument; by default an item (A) is discarded 
    if another item (B), such that A == B, has already been encountered and taken. 
    If you provide a key, this condition changes to key(A) == key(B); the callable 
    must return orderable objects.
    """
    # Enumerate the list to restore order lately; reduce the sorted list; restore order
    def append_unique(acc, item):
        return acc if key(acc[-1][1]) == key(item[1]) else acc.append(item) or acc 
    srt_enum = sorted(enumerate(iterable), key=lambda item: key(item[1]))
    return [item[1] for item in sorted(reduce(append_unique, srt_enum, [srt_enum[0]]))] 

Najlepszym sposobem usuwania duplikatów z listy jest użycie funkcji set () , dostępnej w Pythonie, ponownie konwertującej ten set na list

In [2]: some_list = ['a','a','v','v','v','c','c','d']
In [3]: list(set(some_list))
Out[3]: ['a', 'c', 'd', 'v']

Ten dba o porządek bez większych kłopotów (OrderdDict & inne). Prawdopodobnie nie jest to najbardziej Pythoniczny sposób, ani najkrótsza droga, ale robi sztuczkę:

def remove_duplicates(list):
    ''' Removes duplicate items from a list '''
    singles_list = []
    for element in list:
        if element not in singles_list:
            singles_list.append(element)
    return singles_list

Zmniejsz wariant z zachowaniem kolejności:

Załóżmy, że mamy listę:

l = [5, 6, 6, 1, 1, 2, 2, 3, 4]

Zmniejsz wariant (nieefektywny):

>>> reduce(lambda r, v: v in r and r or r + [v], l, [])
[5, 6, 1, 2, 3, 4]

5 x szybszy, ale bardziej wyrafinowany

>>> reduce(lambda r, v: v in r[1] and r or (r[0].append(v) or r[1].add(v)) or r, l, ([], set()))[0]
[5, 6, 1, 2, 3, 4]

Wyjaśnienie:

default = (list(), set())
# user list to keep order
# use set to make lookup faster

def reducer(result, item):
    if item not in result[1]:
        result[0].append(item)
        result[1].add(item)
    return result

reduce(reducer, l, default)[0]

Poniższy kod jest prosty do usunięcia duplikatu z listy

def remove_duplicates(x):
    a = []
    for i in x:
        if i not in a:
            a.append(i)
    return a

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

Zwraca [1,2,3,4]

Istnieje wiele innych odpowiedzi sugerujących różne sposoby, ale wszystkie są to operacje wsadowe, a niektóre z nich odrzucają pierwotną kolejność. Może to być w porządku w zależności od tego, czego potrzebujesz, ale jeśli chcesz iterować wartości w kolejności pierwszego wystąpienia każdej wartości i chcesz usunąć duplikaty w locie, a nie wszystkie naraz, możesz użyć tego generatora:

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

To zwraca generator / iterator, więc możesz go używać wszędzie, gdzie możesz użyć iterator.

for unique_item in uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]):
    print(unique_item, end=' ')

print()

Wyjście:

1 2 3 4 5 6 7 8

Jeśli chcesz list, możesz to zrobić:

unique_list = list(uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]))

print(unique_list)

Wyjście:

[1, 2, 3, 4, 5, 6, 7, 8]

Bez użycia zestawu

data=[1, 2, 3, 1, 2, 5, 6, 7, 8]
uni_data=[]
for dat in data:
    if dat not in uni_data:
        uni_data.append(dat)

print(uni_data) 

Oto najszybsze rozwiązanie pythoniczne comaring do innych wymienionych w odpowiedziach.

Wykorzystanie szczegółów implementacji oceny zwarciowej pozwala na wykorzystanie rozumienia list, co jest wystarczająco szybkie. visited.add(item) zawsze zwraca None jako wynik, który jest oceniany jako False, więc prawa strona or zawsze byłaby wynikiem takiego wyrażenia.

Time it yourself

def deduplicate(sequence):
    visited = set()
    adder = visited.add  # get rid of qualification overhead
    out = [adder(item) or item for item in sequence if item not in visited]
    return out

Za pomocą set :

a = [0,1,2,3,4,3,3,4]
a = list(set(a))
print a

Za pomocą unique :

import numpy as np
a = [0,1,2,3,4,3,3,4]
a = np.unique(a).tolist()
print a

Bardzo prosty sposób w Pythonie 3:

>>> n = [1, 2, 3, 4, 1, 1]
>>> n
[1, 2, 3, 4, 1, 1]
>>> m = sorted(list(set(n)))
>>> m
[1, 2, 3, 4]

W dzisiejszych czasach możesz użyć klasy Counter:

>>> import collections
>>> c = collections.Counter([1, 2, 3, 4, 5, 6, 1, 1, 1, 1])
>>> c.keys()
dict_keys([1, 2, 3, 4, 5, 6])

Oto przykład, zwracając listę bez powtórzeń zachowując porządek. Nie wymaga żadnego importu zewnętrznego.

def GetListWithoutRepetitions(loInput):
    # return list, consisting of elements of list/tuple loInput, without repetitions.
    # Example: GetListWithoutRepetitions([None,None,1,1,2,2,3,3,3])
    # Returns: [None, 1, 2, 3]

    if loInput==[]:
        return []

    loOutput = []

    if loInput[0] is None:
        oGroupElement=1
    else: # loInput[0]<>None
        oGroupElement=None

    for oElement in loInput:
        if oElement<>oGroupElement:
            loOutput.append(oElement)
            oGroupElement = oElement
    return loOutput

Zaznacz to, jeśli chcesz usunąć duplikaty (edycja w miejscu zamiast zwracania nowej listy) bez użycia wbudowanego zestawu dict.keys, uniqify, counter

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> for i in t:
...     if i in t[t.index(i)+1:]:
...         t.remove(i)
... 
>>> t
[3, 1, 2, 5, 6, 7, 8]

Myślę, że konwersja do set jest najprostszym sposobem na usunięcie duplikatu:

list1 = [1,2,1]
list1 = list(set(list1))
print list1

Aby usunąć duplikaty, zrób z niego zestaw, a następnie ponownie zrób z niego listę i wydrukuj/użyj go. Zestaw ma gwarancję posiadania unikalnych elementów. Na przykład:

a = [1,2,3,4,5,9,11,15]
b = [4,5,6,7,8]
c=a+b
print c
print list(set(c)) #one line for getting unique elements of c

Wynik będzie następujący (sprawdzany w Pythonie 2.7)

[1, 2, 3, 4, 5, 9, 11, 15, 4, 5, 6, 7, 8]  #simple list addition with duplicates
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 15] #duplicates removed!!

Możesz to zrobić po prostu za pomocą zestawów.

Krok 1: Pobierz różne elementy list
Krok 2 Get Common elements of lists
Krok 3 połącz je

In [1]: a = ["apples", "bananas", "cucumbers"]

In [2]: b = ["pears", "apples", "watermelons"]

In [3]: set(a).symmetric_difference(b).union(set(a).intersection(b))
Out[3]: {'apples', 'bananas', 'cucumbers', 'pears', 'watermelons'}

def remove_duplicates(A):
   [A.pop(count) for count,elem in enumerate(A) if A.count(elem)!=1]
   return A

Lista do usuwania duplikatów