Ziemlich oft muss ich ein Programm schreiben, um zu überprüfen, ob eine Liste Duplikate enthält. Wenn ja, werden sie entfernt und eine neue Liste mit den Elementen zurückgegeben, die nicht dupliziert/entfernt wurden. Das habe ich, aber ehrlich gesagt weiß ich nicht, was ich tun soll.
def remove_duplicates():
t = ['a', 'b', 'c', 'd']
t2 = ['a', 'c', 'd']
for t in t2:
t.append(t.remove())
return t
Um eine einzigartige Sammlung von Elementen zu erhalten, verwenden Sie eine set
. Sets sind ungeordnete Sammlungen von distinct Objekten. Um ein Set aus einem beliebigen iterierbaren Element zu erstellen, können Sie es einfach an die integrierte Funktion set()
übergeben. Wenn Sie später wieder eine reale Liste benötigen, können Sie das Set ebenfalls an die Funktion list()
übergeben.
Das folgende Beispiel sollte sich auf das beziehen, was Sie zu tun versuchen:
>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> t
[1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> list(set(t))
[1, 2, 3, 5, 6, 7, 8]
>>> s = [1, 2, 3]
>>> list(set(t) - set(s))
[8, 5, 6, 7]
Wie Sie am Beispielergebnis sehen können, wird die ursprüngliche Reihenfolge nicht beibehalten. Wie oben erwähnt, sind Sets selbst ungeordnete Sammlungen, sodass die Reihenfolge verloren geht. Wenn Sie einen Satz zurück in eine Liste konvertieren, wird eine beliebige Reihenfolge erstellt.
Wenn die Reihenfolge für Sie wichtig ist, müssen Sie einen anderen Mechanismus verwenden. Eine sehr gebräuchliche Lösung hierfür ist die Verwendung von OrderedDict
, um die Reihenfolge der Schlüssel während des Einfügens beizubehalten:
>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]
Beachten Sie, dass dies den Aufwand verursacht, zuerst ein Wörterbuch und dann eine Liste davon zu erstellen. Wenn Sie die Reihenfolge also nicht unbedingt beibehalten müssen, sollten Sie lieber ein Set verwenden. Check out diese Frage für weitere Details und alternative Möglichkeiten, die Reihenfolge beim Entfernen von Duplikaten zu erhalten.
Beachten Sie schließlich, dass sowohl für die set
-Lösung als auch für die OrderedDict
-Lösung Ihre Artikel hashable sein müssen. Dies bedeutet normalerweise, dass sie unveränderlich sein müssen. Wenn Sie sich mit Elementen beschäftigen müssen, die nicht hashierbar sind (z. B. Listenobjekte), müssen Sie einen langsamen Ansatz verwenden, bei dem Sie grundsätzlich jedes Element mit jedem anderen Element in einer verschachtelten Schleife vergleichen müssen.
In Python 2.7 besteht die neue Methode zum Entfernen von Duplikaten aus einer Iteration, während sie in der ursprünglichen Reihenfolge bleibt:
>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
In Python 3.5 hat OrderedDict eine C-Implementierung. Meine Timings zeigen, dass dies für Python 3.5 nun sowohl der schnellste als auch der kürzeste Ansatz ist.
In Python 3.6 wurde das reguläre Diktat geordnet und kompakt. (Diese Funktion gilt für CPython und PyPy, ist jedoch in anderen Implementierungen möglicherweise nicht vorhanden.) Das gibt uns eine neue, schnellste Art, Deduktion durchzuführen, während die Ordnung erhalten bleibt:
>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
In Python 3.7 ist der reguläre Befehl für beide Implementierungen garantiert. Die kürzeste und schnellste Lösung ist also:
>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
Es ist ein Einzeiler: list(set(source_list))
macht den Trick.
Eine set
ist etwas, das möglicherweise keine Duplikate haben kann.
Update: Ein auftragserhaltender Ansatz besteht aus zwei Zeilen:
from collections import OrderedDict
OrderedDict((x, True) for x in source_list).keys()
Hier verwenden wir die Tatsache, dass OrderedDict
die Reihenfolge des Einfügens von Schlüsseln speichert und diese nicht ändert, wenn ein Wert an einem bestimmten Schlüssel aktualisiert wird. Wir setzen True
als Werte ein, aber wir könnten alles einfügen, Werte werden einfach nicht verwendet. (set
arbeitet ähnlich wie eine dict
mit ignorierten Werten.)
>>> 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]
Wenn Sie sich nicht für die Bestellung interessieren, tun Sie dies einfach:
def remove_duplicates(l):
return list(set(l))
Eine set
hat garantiert keine Duplikate.
So erstellen Sie eine neue Liste mit der Reihenfolge der ersten Elemente von Duplikaten in L
newlist=[ii for n,ii in enumerate(L) if ii not in L[:n]]
beispielsweise if L=[1, 2, 2, 3, 4, 2, 4, 3, 5]
dann newlist
wird [1,2,3,4,5]
Dadurch wird überprüft, ob jedes neue Element zuvor in der Liste enthalten war, bevor es hinzugefügt wurde. Auch braucht es keine Importe.
Eine andere Möglichkeit:
>>> seq = [1,2,3,'a', 'a', 1,2]
>> dict.fromkeys(seq).keys()
['a', 1, 2, 3]
Ein Kollege hat mir heute die akzeptierte Antwort als Teil seines Codes für ein Codereview gesandt. Obwohl ich die Eleganz der fraglichen Antwort durchaus bewundere, bin ich mit der Leistung nicht zufrieden (Ich verwende set , um die Suchzeit zu reduzieren)
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
Um die Effizienz zu vergleichen, habe ich eine Zufallsstichprobe von 100 ganzen Zahlen verwendet - 62 waren einzigartig
from random import randint
x = [randint(0,100) for _ in xrange(100)]
In [131]: len(set(x))
Out[131]: 62
Hier sind die Ergebnisse der Messungen
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
Nun, was passiert, wenn das Set aus der Lösung entfernt wird?
def ordered_set(inlist):
out_list = []
for val in inlist:
if not val in out_list:
out_list.append(val)
return out_list
Das Ergebnis ist nicht so schlecht wie bei OrderedDict , aber immer noch mehr als das Dreifache der ursprünglichen Lösung
In [136]: %timeit ordered_set(x)
10000 loops, best of 3: 52.6 us per loop
Es gibt auch Lösungen, die Pandas und Numpy verwenden. Beide geben ein numpy-Array zurück, daher müssen Sie die Funktion .tolist()
verwenden, wenn Sie eine Liste wünschen.
t=['a','a','b','b','b','c','c','c']
t2= ['c','c','b','b','b','a','a','a']
Verwendung der Pandas-Funktion unique()
:
import pandas as pd
pd.unique(t).tolist()
>>>['a','b','c']
pd.unique(t2).tolist()
>>>['c','b','a']
Verwenden der numpy-Funktion unique()
.
import numpy as np
np.unique(t).tolist()
>>>['a','b','c']
np.unique(t2).tolist()
>>>['a','b','c']
Beachten Sie, dass auch numpy.unique () die Werte sortiert. Die Liste t2
wird also sortiert zurückgegeben. Wenn Sie möchten, dass die Bestellung erhalten bleibt, verwenden Sie als diese Antwort :
_, idx = np.unique(t2, return_index=True)
t2[np.sort(idx)].tolist()
>>>['c','b','a']
Die Lösung ist nicht so elegant im Vergleich zu den anderen. Im Vergleich zu pandas.unique () können Sie mit numpy.unique () auch prüfen, ob verschachtelte Arrays entlang einer ausgewählten Achse eindeutig sind.
Simpel und einfach:
myList = [1, 2, 3, 1, 2, 5, 6, 7, 8]
cleanlist = []
[cleanlist.append(x) for x in myList if x not in cleanlist]
Ausgabe:
>>> cleanlist
[1, 2, 3, 5, 6, 7, 8]
Ich hatte ein Diktat in meiner Liste, daher konnte ich den obigen Ansatz nicht verwenden. Ich habe den Fehler erhalten:
TypeError: unhashable type:
Wenn Sie sich also für order interessieren und/oder einige Artikel unhashable sind. Dann könnte dies nützlich sein:
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
Einige mögen Listenverständnis mit einem Nebeneffekt als keine gute Lösung betrachten. Hier ist eine Alternative:
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
Alle bisher erhaltenen ordnungserhaltenden Ansätze verwenden entweder naive Vergleichskonfigurationen (im besten Fall mit O (n ^ 2) Zeitkomplexität) oder schwere OrderedDicts
/set
+ list
Kombinationen, die auf Hash-Eingaben beschränkt sind. Hier ist eine Hash-unabhängige Lösung O(nlogn):
Update fügte das Argument key
, Dokumentation und Python 3-Kompatibilität hinzu.
# 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]]))]
Versuchen Sie es mit Sets:
import sets
t = sets.Set(['a', 'b', 'c', 'd'])
t1 = sets.Set(['a', 'b', 'c'])
print t | t1
print t - t1
Sie könnten dies auch tun:
>>> 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]
Der oben genannte Grund ist, dass die index
-Methode nur den ersten Index eines Elements zurückgibt. Doppelte Elemente haben höhere Indizes. hier :
list.index (x [ start [ end]])
Gibt einen nullbasierten Index in der Liste von .__ zurück. das erste Element, dessen Wert x ist. Löst einen ValueError aus, wenn kein .__ vorhanden ist. solche Artikel.
Ein noch besserer Ansatz könnte sein,
import pandas as pd
myList = [1, 2, 3, 1, 2, 5, 6, 7, 8]
cleanList = pd.Series(myList).drop_duplicates().tolist()
print(cleanList)
#> [1, 2, 3, 5, 6, 7, 8]
und die Reihenfolge bleibt erhalten.
Ohne zu setzen
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)
Die beste Methode, Duplikate aus einer Liste zu entfernen, ist die Verwendung von set () - Funktion, die in Python verfügbar ist und die Gruppe erneut in Liste umwandelt
In [2]: some_list = ['a','a','v','v','v','c','c','d']
In [3]: list(set(some_list))
Out[3]: ['a', 'c', 'd', 'v']
Es gibt viele andere Antworten, die auf verschiedene Arten darauf hinweisen, aber es handelt sich um Batch-Vorgänge, und einige von ihnen werfen die ursprüngliche Reihenfolge weg. Je nach Bedarf kann dies in Ordnung sein. Wenn Sie jedoch die Werte in der Reihenfolge der ersten Instanz jedes Werts durchlaufen möchten und die Duplikate im Vergleich zu allen gleichzeitig entfernen möchten, können Sie dies verwenden dieser Generator:
def uniqify(iterable):
seen = set()
for item in iterable:
if item not in seen:
seen.add(item)
yield item
Dadurch wird ein Generator/Iterator zurückgegeben, sodass Sie ihn überall verwenden können, wo Sie einen Iterator verwenden können.
for unique_item in uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]):
print(unique_item, end=' ')
print()
Ausgabe:
1 2 3 4 5 6 7 8
Wenn Sie eine list
wünschen, können Sie Folgendes tun:
unique_list = list(uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]))
print(unique_list)
Ausgabe:
[1, 2, 3, 4, 5, 6, 7, 8]
der folgende Code ist einfach zum Entfernen von Duplikaten in der Liste
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])
es kehrt zurück [1,2,3,4]
Variante mit Bestellbesteck reduzieren:
Angenommen, wir haben eine Liste:
l = [5, 6, 6, 1, 1, 2, 2, 3, 4]
Variante reduzieren (nicht effizient):
>>> reduce(lambda r, v: v in r and r or r + [v], l, [])
[5, 6, 1, 2, 3, 4]
5 x schneller aber raffinierter
>>> 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]
Erläuterung:
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]
Sie können folgende Funktion verwenden:
def rem_dupes(dup_list):
yooneeks = []
for elem in dup_list:
if elem not in yooneeks:
yooneeks.append(elem)
return yooneeks
Beispiel :
my_list = ['this','is','a','list','with','dupicates','in', 'the', 'list']
Verwendungszweck:
rem_dupes(my_list)
['this', 'is', 'a', 'list', 'mit', 'dupicates', 'in', 'the'
Dieser kümmert sich um die Bestellung ohne zu viel Ärger (OrderdDict und andere). Wahrscheinlich nicht der pythonischste Weg oder der kürzeste Weg, aber der Trick:
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
Hier ist die schnellste Pythonic-Lösung, die zu anderen in den Antworten aufgeführten führt.
Die Verwendung der Implementierungsdetails der Kurzschlussauswertung ermöglicht das Verwenden des Listenverständnisses, was schnell genug ist. visited.add(item)
gibt immer None
als Ergebnis zurück, das als False
ausgewertet wird. Die rechte Seite von or
wäre also immer das Ergebnis eines solchen Ausdrucks.
Zeit es selbst
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
Verwenden Sieset:
a = [0,1,2,3,4,3,3,4]
a = list(set(a))
print a
Verwenden vonunique:
import numpy as np
a = [0,1,2,3,4,3,3,4]
a = np.unique(a).tolist()
print a
Sehr einfacher Weg in Python 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]
Sie können set
verwenden, um Duplikate zu entfernen:
mylist = list(set(mylist))
Beachten Sie jedoch, dass die Ergebnisse ungeordnet sein werden. Wenn das ein Problem ist:
mylist.sort()
Aktivieren Sie diese Option, wenn Sie Duplikate entfernen möchten (In-Place-Bearbeitung, anstatt neue Liste zurückzugeben), ohne den eingebauten Satz dict.keys, uniqify und counter zu verwenden
>>> 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]
Hier ein Beispiel, eine Liste ohne Wiederholungen, die die Reihenfolge erhalten. Benötigt keine externen Importe.
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
Ich denke, das Konvertieren in Set ist der einfachste Weg, Duplikate zu entfernen:
list1 = [1,2,1]
list1 = list(set(list1))
print list1
Eine andere Lösung könnte die folgende sein. Erstellen Sie ein Wörterbuch aus der Liste mit item als Schlüssel und Index als Wert und drucken Sie dann die Wörterbuchschlüssel.
>>> lst = [1, 3, 4, 2, 1, 21, 1, 32, 21, 1, 6, 5, 7, 8, 2]
>>>
>>> dict_enum = {item:index for index, item in enumerate(lst)}
>>> print dict_enum.keys()
[32, 1, 2, 3, 4, 5, 6, 7, 8, 21]
Es gibt viele Antworten, die hier set(..)
(was schnell ist, wenn die Elemente hashable sind) oder eine Liste (die den Nachteil hat, dass sie zu einem O führt (n2) Algorithmus.
Die von mir vorgeschlagene Funktion ist eine Hybridfunktion: Wir verwenden eine set(..)
für Elemente, die are hashable sind, und eine list(..)
für die anderen, die dies nicht tun. Darüber hinaus ist es als generator implementiert, sodass wir beispielsweise die Anzahl der Elemente begrenzen oder zusätzliche Filterungen vornehmen können.
Schließlich können wir auch ein key
-Argument verwenden, um anzugeben, auf welche Weise die Elemente eindeutig sein sollen. Wir können dies beispielsweise verwenden, wenn wir eine Liste von Strings so filtern möchten, dass jeder String in der Ausgabe eine andere Länge hat.
def uniq(iterable, key=lambda x: x):
seens = set()
seenl = []
for item in iterable:
k = key(item)
try:
seen = k in seens
except TypeError:
seen = k in seenl
if not seen:
yield item
try:
seens.add(k)
except TypeError:
seenl.append(k)
Wir können jetzt zum Beispiel folgendes verwenden:
>>> list(uniq(["Apple", "pear", "banana", "lemon"], len))
['Apple', 'pear', 'banana']
>>> list(uniq(["Apple", "pear", "lemon", "banana"], len))
['Apple', 'pear', 'banana']
>>> list(uniq(["Apple", "pear", {}, "lemon", [], "banana"], len))
['Apple', 'pear', {}, 'banana']
>>> list(uniq(["Apple", "pear", {}, "lemon", [], "banana"]))
['Apple', 'pear', {}, 'lemon', [], 'banana']
>>> list(uniq(["Apple", "pear", {}, "lemon", {}, "banana"]))
['Apple', 'pear', {}, 'lemon', 'banana']
Es handelt sich somit um einen Unifilter, der auf beliebigen Iterationen arbeiten kann und Unikate herausfiltern kann, unabhängig davon, ob diese Hash-fähig sind oder nicht.
Es wird eine Annahme gemacht: Wenn ein Objekt hashierbar ist und ein anderes nicht, dann sind die beiden Objekte niemals gleich. Dies kann streng genommen passieren, obwohl es sehr ungewöhnlich wäre.
Sie können dies einfach mit Sets tun.
Schritt 1: Holen Sie sich verschiedene Elemente von Listen
Step2 Gemeinsame Elemente von Listen abrufen
Schritt3 Kombinieren
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'}
Um die Duplikate zu entfernen, machen Sie ein SET und dann erneut eine LISTE, und drucken Sie sie aus/verwenden Sie sie. Ein Set enthält garantiert eindeutige Elemente. Zum Beispiel :
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
Die Ausgabe sieht wie folgt aus (in Python 2.7 geprüft)
[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!!
def remove_duplicates(A):
[A.pop(count) for count,elem in enumerate(A) if A.count(elem)!=1]
return A
Ein Listenverständnis zum Entfernen von Duplikaten
Wenn Sie sich nicht für die Reihenfolge interessieren und etwas anderes als die oben vorgeschlagenen Pythonic-Methoden wünschen (dh sie kann in Interviews verwendet werden),
def remove_dup(arr):
size = len(arr)
j = 0 # To store index of next unique element
for i in range(0, size-1):
# If current element is not equal
# to next element then store that
# current element
if(arr[i] != arr[i+1]):
arr[j] = arr[i]
j+=1
arr[j] = arr[size-1] # Store the last element as whether it is unique or repeated, it hasn't stored previously
return arr[0:j+1]
if __== '__main__':
arr = [10, 10, 1, 1, 1, 3, 3, 4, 5, 6, 7, 8, 8, 9]
print(remove_dup(sorted(arr)))
Zeitkomplexität: O (n)
Hilfsraum: O (n)
Referenz: http://www.geeksforgeeks.org/remove-duplicates-sorted-array/
Unglücklicherweise. Die meisten Antworten erhalten entweder die Reihenfolge nicht oder sind zu lang. Hier ist eine einfache, bestellende Antwort.
s = [1,2,3,4,5,2,5,6,7,1,3,9,3,5]
x=[]
[x.append(i) for i in s if i not in x]
print(x)
Dadurch erhalten Sie x, wobei Duplikate entfernt wurden, aber die Reihenfolge erhalten bleibt.
Manchmal müssen Sie die doppelten Elemente direkt entfernen, ohne eine neue Liste erstellen zu müssen. Zum Beispiel ist die Liste groß oder behält sie als Schattenkopie bei
from collections import Counter
cntDict = Counter(t)
for item,cnt in cntDict.items():
for _ in range(cnt-1):
t.remove(item)
Es muss ein Drittanbieter-Modul installiert werden, das Paket iteration_utilities
enthält jedoch ein unique_everseen
1 Funktion, die alle Duplikate entfernen kann, während die Reihenfolge erhalten bleibt:
>>> from iteration_utilities import unique_everseen
>>> list(unique_everseen(['a', 'b', 'c', 'd'] + ['a', 'c', 'd']))
['a', 'b', 'c', 'd']
Wenn Sie den Aufwand der Listenzugriffsoperation vermeiden möchten, können Sie stattdessen itertools.chain
verwenden:
>>> from itertools import chain
>>> list(unique_everseen(chain(['a', 'b', 'c', 'd'], ['a', 'c', 'd'])))
['a', 'b', 'c', 'd']
Der unique_everseen
funktioniert auch, wenn Sie in den Listen unausweichliche Elemente (z. B. Listen) enthalten:
>>> from iteration_utilities import unique_everseen
>>> list(unique_everseen([['a'], ['b'], 'c', 'd'] + ['a', 'c', 'd']))
[['a'], ['b'], 'c', 'd', 'a']
Dies ist jedoch (viel) langsamer als wenn die Elemente hashierbar sind.
1 Offenlegung: Ich bin der Autor der iteration_utilities
- Bibliothek.
Wenn Sie die Bestellung beibehalten und keine externen Module verwenden möchten, können Sie dies auf einfache Weise tun:
>>> t = [1, 9, 2, 3, 4, 5, 3, 6, 7, 5, 8, 9]
>>> list(dict.fromkeys(t))
[1, 9, 2, 3, 4, 5, 6, 7, 8]
Hinweis: Bei dieser Methode wird die Reihenfolge des Erscheinungsbildes beibehalten. Wie oben gezeigt, werden neun nach eins erscheinen, da es das erste Mal erschien. Dies ist jedoch das gleiche Ergebnis, das Sie mit dem Ausführen erhalten würden
from collections import OrderedDict
ulist=list(OrderedDict.fromkeys(l))
aber es ist viel kürzer und läuft schneller.
Dies funktioniert, da jedes Mal, wenn die fromkeys
-Funktion versucht, einen neuen Schlüssel zu erstellen, der Wert bereits überschrieben wird, wenn der Wert bereits vorhanden ist. Dies wirkt sich jedoch nicht auf das Wörterbuch aus, da fromkeys
ein Wörterbuch erstellt, in dem alle Schlüssel den Wert None
haben. Auf diese Weise werden alle Duplikate effektiv beseitigt.
def remove_duplicates(input_list):
if input_list == []:
return []
#sort list from smallest to largest
input_list=sorted(input_list)
#initialize ouput list with first element of the sorted input list
output_list = [input_list[0]]
for item in input_list:
if item >output_list[-1]:
output_list.append(item)
return output_list
list_with_unique_items = list(set(list_with_duplicates))
dies ist nur eine lesbare Funktion, leicht verständlich, und ich habe die Datenstruktur von Dict verwendet. Ich habe einige eingebaute Funktionen und eine bessere Komplexität von O (n) verwendet.
def undup(dup_list):
b={}
for i in dup_list:
b.update({i:1})
return b.keys()
a=["a",'b','a']
print undup(a)
disclamer: u kann einen Einrückungsfehler erhalten (beim Kopieren und Einfügen), verwenden Sie den obigen Code mit der richtigen Einrückung vor dem Einfügen
Wenn Ihre Liste sortiert ist, können Sie wie folgt vorgehen, um die wiederholten Werte zu überspringen. Dies ist besonders nützlich, um große Listen mit geringem Speicherverbrauch zu verwalten und die Kosten für die Erstellung eines dict
namens__ oder eines set
namens__ zu umgehen:
def uniq(iterator):
prev = None
for item in iterator:
if item != prev:
prev = item
yield item
Dann:
for item in [1, 1, 3, 5, 5, 6]:
print(item, end=' ')
Die Ausgabe wird sein: 1 3 5 6
Python hat viele Funktionen eingebaut. Sie können set () verwenden, um das Duplikat in der Liste zu entfernen
t = ['a', 'b', 'c', 'd']
t2 = ['a', 'c', 'd']
result = list(set(t) - set(t2))
result
Antwort: ['b']