Wie entfernen Sie Dubletten aus einer Liste, während Sie die Reihenfolge beibehalten?

Bearbeiten 2016

Raymond hingewiesenin python 3.5+, wo OrderedDict ist implementiert in C, die Liste Verständnis Ansatz wird langsamer sein als OrderedDict (es sei denn, Sie wirklich brauchen, die Liste am Ende - und auch nur dann, wenn der Eingang ist sehr kurz). Also ist die beste Lösung für 3.5+ ist OrderedDict.

Wichtig, Bearbeiten, 2015

Als @abarnert Noten, die more_itertools Bibliothek (pip install more_itertools) enthält eine unique_everseen Funktion, die integriert ist, dieses problem zu lösen, ohne unlesbar (not seen.add) Mutationen in der Liste Verstehens. Dies ist auch die Schnellste Lösung zu:

>>> from  more_itertools import unique_everseen
>>> items = [1, 2, 0, 1, 3, 2]
>>> list(unique_everseen(items))
[1, 2, 0, 3]

Nur eine einfache Bibliothek importieren und keine hacks.
Dies kommt von einer Umsetzung der itertools Rezept unique_everseen, die wie folgt aussieht:

def unique_everseen(iterable, key=None):
    "List unique elements, preserving order. Remember all elements ever seen."
    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
    # unique_everseen('ABBCcAD', str.lower) --> A B C D
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in filterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

In Python 2.7+ akzeptiert gängige idiom (das geht aber nicht auf Geschwindigkeit optimiert ist, würde ich jetzt verwenden unique_everseen) für diese verwendet Sammlungen.OrderedDict:

Laufzeit: O(N)

>>> from collections import OrderedDict
>>> items = [1, 2, 0, 1, 3, 2]
>>> list(OrderedDict.fromkeys(items))
[1, 2, 0, 3]

Das sieht viel schöner aus als:

seen = set()
[x for x in seq if x not in seen and not seen.add(x)]

und nutzen nicht die hässlicher hack,:

not seen.add(x)

die stützt sich auf die Tatsache, dass set.add ist ein in-place-Methode, die immer wieder None so not None ausgewertet True.

Beachten Sie jedoch, dass die hack-Lösung ist schneller im raw-Geschwindigkeit, obwohl es hat die gleiche Laufzeit Komplexität von O(N).

InformationsquelleAutor der Antwort

sequence = ['1', '2', '3', '3', '6', '4', '5', '6']
unique = []
[unique.append(item) for item in sequence if item not in unique]

einzigartigen → ['1', '2', '3', '6', '4', '5']

InformationsquelleAutor der Antwort dansalmo

Ich denke wenn Sie möchte erhalten den Auftrag,

Sie können versuchen, diese:

list1 = ['b','c','d','b','c','a','a']    
list2 = list(set(list1))    
list2.sort(key=list1.index)    
print list2

ODER ähnlich können Sie dies tun:

list1 = ['b','c','d','b','c','a','a']  
list2 = sorted(set(list1),key=list1.index)  
print list2 

Sie können dies auch tun:

list1 = ['b','c','d','b','c','a','a']    
list2 = []    
for i in list1:    
    if not i in list2:  
        list2.append(i)`    
print list2

Es kann auch geschrieben werden als:

list1 = ['b','c','d','b','c','a','a']    
list2 = []    
[list2.append(i) for i in list1 if not i in list2]    
print list2 

InformationsquelleAutor der Antwort shamrock

Nur um ein weiteres (sehr performant) die Umsetzung einer solchen Funktionalität von einem externen Modul¹: iteration_utilities.unique_everseen:

>>> from iteration_utilities import unique_everseen
>>> lst = [1,1,1,2,3,2,2,2,1,3,4]

>>> list(unique_everseen(lst))
[1, 2, 3, 4]

Timings

Habe ich einige timings (Python 3.6), und diese zeigen, dass es schneller als alle anderen alternativen, die ich getestet, einschließlich OrderedDict.fromkeysf7 und more_itertools.unique_everseen:

%matplotlib notebook

from iteration_utilities import unique_everseen
from collections import OrderedDict
from more_itertools import unique_everseen as mi_unique_everseen

def f7(seq):
    seen = set()
    seen_add = seen.add
    return [x for x in seq if not (x in seen or seen_add(x))]

def iteration_utilities_unique_everseen(seq):
    return list(unique_everseen(seq))

def more_itertools_unique_everseen(seq):
    return list(mi_unique_everseen(seq))

def odict(seq):
    return list(OrderedDict.fromkeys(seq))

from simple_benchmark import benchmark

b = benchmark([f7, iteration_utilities_unique_everseen, more_itertools_unique_everseen, odict],
              {2**i: list(range(2**i)) for i in range(1, 20)},
              'list size (no duplicates)')
b.plot()

Und nur um sicherzugehen, ich habe auch einen test mit mehr Duplikate nur um zu überprüfen, ob es einen Unterschied macht:

import random

b = benchmark([f7, iteration_utilities_unique_everseen, more_itertools_unique_everseen, odict],
              {2**i: [random.randint(0, 2**(i-1)) for _ in range(2**i)] for i in range(1, 20)},
              'list size (lots of duplicates)')
b.plot()

Und enthält nur einen Wert:

b = benchmark([f7, iteration_utilities_unique_everseen, more_itertools_unique_everseen, odict],
              {2**i: [1]*(2**i) for i in range(1, 20)},
              'list size (only duplicates)')
b.plot()

In allen diesen Fällen ist die iteration_utilities.unique_everseen - Funktion ist die Schnellste (auf meinem computer).

Diese iteration_utilities.unique_everseen Funktion kann auch mit unhashable Werte in der input - (aber mit einem O(n*n) Leistung anstelle der O(n) Leistung, wenn die Werte hashable).

>>> lst = [{1}, {1}, {2}, {1}, {3}]

>>> list(unique_everseen(lst))
[{1}, {2}, {3}]

¹ Disclaimer: ich bin der Autor des Pakets.

InformationsquelleAutor der Antwort MSeifert

Nicht zum kicken ein Totes Pferd (diese Frage ist sehr alt und hat schon viele gute Antworten), aber hier ist die Lösung mit den pandas, die sehr schnell in viele Umstände und ist tot einfach zu bedienen.

import pandas as pd

my_list = range(5) + range(5)  # [0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
>>> pd.Series(my_list).drop_duplicates().tolist()
# Output:
# [0, 1, 2, 3, 4]

InformationsquelleAutor der Antwort Alexander

5 x schneller reduzieren Variante aber anspruchsvoller

>>> l = [5, 6, 6, 1, 1, 2, 2, 3, 4]
>>> 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]

Erklärung:

default = (list(), set())
# use 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]
[5, 6, 1, 2, 3, 4]

InformationsquelleAutor der Antwort Sergey M Nikitin

MizardX die Antwort gibt eine gute Sammlung mehrerer Ansätze.

Dies ist, was ich kam mit, während Sie laut denken:

mylist = [x for i,x in enumerate(mylist) if x not in mylist[i+1:]]

InformationsquelleAutor der Antwort Saurabh Hirani

Relativ wirksam Ansatz mit _sorted_ eine numpy arrays:

b = np.array([1,3,3, 8, 12, 12,12])    
numpy.hstack([b[0], [x[0] for x in zip(b[1:], b[:-1]) if x[0]!=x[1]]])

Ausgänge:

array([ 1,  3,  8, 12])

InformationsquelleAutor der Antwort dominecf

Eine einfache rekursive Lösung:

def uniquefy_list(a):
    return uniquefy_list(a[1:]) if a[0] in a[1:] else [a[0]]+uniquefy_list(a[1:]) if len(a)>1 else [a[0]]

InformationsquelleAutor der Antwort Ilya Prokin

Wenn du eine brauchst, liner, dann wird das vielleicht helfen:

reduce(lambda x, y: x + y if y[0] not in x else x, map(lambda x: [x],lst))

... sollte funktionieren, aber korrigieren Sie mich, wenn ich falsch bin,

InformationsquelleAutor der Antwort code22

das bewahrt Ordnung und laufen in O(n) Zeit. im Grunde die Idee ist, erstellen Sie ein Loch, wo es ist ein Duplikat gefunden und Spüle es hinunter auf den Grund. macht Gebrauch von einer lese-und schreib-Zeiger. wenn ein Duplikat gefunden wird, nur die lese-Zeiger Fortschritte und schreiben Zeiger bleibt auf den doppelten Eintrag zu überschreiben.

def deduplicate(l):
    count = {}
    (read,write) = (0,0)
    while read < len(l):
        if l[read] in count:
            read += 1
            continue
        count[l[read]] = True
        l[write] = l[read]
        read += 1
        write += 1
    return l[0:write]

InformationsquelleAutor der Antwort Soham Joshi

Da ich auf der Suche an einem dup und sammelte einige Verwandte, aber unterschiedliche, Bezug, nützliche, Informationen, die nicht Teil der anderen Antworten, hier sind zwei andere mögliche Lösungen.

.bekommen(Wahr) XOR .setdefault(False)

Die erste ist sehr ähnlich wie das angenommen seen_add soultion nutzen, aber mit expliziten Nebenwirkungen mit Wörterbuch get(x,<default>) und setdefault(x,<default>):

# Explanation of d.get(x,True) != d.setdefault(x,False)
#
# x in d | d[x]  | A = d.get(x,True) | x in d | B = d.setdefault(x,False) | x in d | d[x]    | A xor B
# False  | None  | True          (1) | False  | False                 (2) | True   | False   | True
# True   | False | False         (3) | True   | False                 (4) | True   | False   | False
#
# Notes
# (1) x is not in the dictionary, so get(x,<default>) returns True but does __not__ add the value to the dictionary
# (2) x is not in the dictionary, so setdefault(x,<default>) adds the {x:False} and returns False
# (3) since x is in the dictionary, the <default> argument is ignored, and the value of the key is returned, which was
#     set to False in (2)
# (4) since the key is already in the dictionary, its value is returned directly and the argument is ignored
#
# A != B is how to do boolean XOR in Python
#
def sort_with_order(s):
    d = dict()
    return [x for x in s if d.get(x,True) != d.setdefault(x,False)]

get(x,<default>) zurück <default> wenn x ist nicht im Wörterbuch, aber nicht fügen Sie den Schlüssel in das Wörterbuch. set(x,<default>) gibt den Wert zurück, falls der Schlüssel im dictionary, sonst setzt es an und zurück <default>.

Beiseite: a != b ist, wie man ein XOR in python

__ÜBERWIEGENDES ___fehlen_____ (inspiriert durch diese Antwort)

Die zweite Technik ist das überschreiben der __missing__ Methode, die aufgerufen wird, wenn der Schlüssel existiert nicht in einem Wörterbuch, das nur aufgerufen, wenn mit d[k] notation:

class Tracker(dict):
    # returns True if missing, otherwise sets the value to False
    # so next time d[key] is called, the value False will be returned
    # and __missing__ will not be called again
    def __missing__(self, key):
        self[key] = False
        return True

t = Tracker()
unique_with_order = [x for x in samples if t[x]]

Vom die docs:

Neu in version 2.5: Wenn eine Unterklasse von dict definiert eine Methode
_____fehlen_____(), wenn der Schlüssel nicht vorhanden ist, die d[key] operation fordert, dass die Methode mit dem Schlüssel als argument. Die d[key] Betrieb
dann gibt oder wirft, was zurückgegeben wird, oder ausgelöst durch die
_____fehlen_____(Taste) - Aufruf, wenn der Schlüssel nicht vorhanden ist. Keine anderen Operationen oder Methoden aufrufen _____fehlen_____(). Wenn _____fehlen_____() ist nicht definiert,
KeyError ausgelöst. _____fehlen_____() muss eine Methode; es kann nicht sein, ein
Instanz-Variablen. Ein Beispiel finden Sie unter Kollektionen.defaultdict.

InformationsquelleAutor der Antwort cod3monk3y

dies ist die smartes Weg, um entfernen Sie Duplikate aus einer Liste in Python, während die Erhaltung seiner Ordnung, können Sie sogar tun Sie es in einer Zeile code:

a_list = ["a", "b", "a", "c"]

sorted_list = [x[0] for x in (sorted({x:a_list.index(x) for x in set(a_list)}.items(), key=lambda x: x[1]))]

print sorted_list

InformationsquelleAutor der Antwort Liam

Nur hinzufügen, eine andere Antwort habe ich nicht gesehen, aufgeführt

>>> a = ['f', 'F', 'F', 'G', 'a', 'b', 'b', 'c', 'd', 'd', 'd', 'f']

>>> [a[i] for i in sorted(set([a.index(elem) for elem in a]))]

['f', 'F', 'G', 'a', 'b', 'c', 'd']
>>>

Dies ist mit .index zu bekommen, der erste index, der jedem element in der Liste und loszuwerden doppelte Ergebnisse (für die sich wiederholenden Elemente), mit setdann Sortieren, weil es gibt keine Reihenfolge, in der Sätze. Beachten Sie, dass wir nicht Locker, um Informationen, weil der erste index, der jedes neue element wird immer in aufsteigender Reihenfolge. So sortiert wird immer richtig stellen.

Habe ich nur als der einfache syntax, nicht die Leistung.

InformationsquelleAutor der Antwort progmatico