Duplikate in Listen entfernen

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

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.

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 (n²) 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. 

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)

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

¹ 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 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

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