it-swarm.com.de

Duplikate in Listen entfernen

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
740
Neemaximo

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.

1277
poke

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']
343

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.)

170
9000
>>> 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]
79
Neeraj

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.

68
Brendan Long

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.

37

Eine andere Möglichkeit:

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

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
18
volcano

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']

Pandas Lösung

Verwendung der Pandas-Funktion unique() :

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

Wackelige Lösung

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.

16
G M

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]
14
Nima Soroush

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
10
cchristelis

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]]))] 
7
Eli Korvigo

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
6
Charlie Martin

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.

6
Atonal

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.

5
Akarsh Jain

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) 
5
Suresh Gupta

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']
5
Anurag Misra

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]
4
Cyphase

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]

4
vinay hegde

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]
4

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'

4
Cybernetic

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
4
cgf

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
3
thodnev

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
3

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]
3
Wariored

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()
2
Flavio Wuensche

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]
2
user2404093

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
2
Apogentus

Ich denke, das Konvertieren in Set ist der einfachste Weg, Duplikate zu entfernen:

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

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]
1
SuperNova

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.

1

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'}
1
Anurag Misra

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!!
1
krozaine
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

1

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/

1
Santosh Pillai

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. 

0
ste_kwr

Der Vollständigkeit halber, und da dies eine sehr beliebte Frage ist, bietet die toolz library eine unique Funktion:

>>> Tuple(unique((1, 2, 3)))
(1, 2, 3)
>>> Tuple(unique((1, 2, 1, 3)))
(1, 2, 3)
0
Björn Pollex

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)
0
where23

Es muss ein Drittanbieter-Modul installiert werden, das Paket iteration_utilities enthält jedoch ein unique_everseen1 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.

0
MSeifert

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.

0
HEEL_caT666
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   
0
Dennis Peterson
list_with_unique_items = list(set(list_with_duplicates))
0
Gajendra D Ambi

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

0
yunus

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 dictnamens__ oder eines setnamens__ 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

0
Israel Teixeira

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']

0
Anoop Kumar