Überprüfen, ob alle Elemente in einer Liste eindeutig sind

Was ist der beste Weg (am besten wie auf herkömmliche Weise), um zu überprüfen, ob alle Elemente in einer Liste eindeutig sind?

Mein aktueller Ansatz mit a Counterist:

>>> x = [1, 1, 1, 2, 3, 4, 5, 6, 2]
>>> counter = Counter(x)
>>> for values in counter.itervalues():
        if values > 1: 
            # do something

Kann ich es besser machen

Nicht die effizienteste, aber unkompliziert und prägnant:

if len(x) > len(set(x)):
   pass # do something

Wahrscheinlich wird es für kurze Listen keinen großen Unterschied machen.

Hier ist ein Zweiliner, der auch vorzeitig aussteigen wird:

>>> def allUnique(x):
...     seen = set()
...     return not any(i in seen or seen.add(i) for i in x)
...
>>> allUnique("ABCDEF")
True
>>> allUnique("ABACDEF")
False

Wenn die Elemente von x nicht hashbar sind, müssen Sie eine Liste verwenden für seen:

>>> def allUnique(x):
...     seen = list()
...     return not any(i in seen or seen.append(i) for i in x)
...
>>> allUnique([list("ABC"), list("DEF")])
True
>>> allUnique([list("ABC"), list("DEF"), list("ABC")])
False

Eine Early-Exit-Lösung könnte sein

def unique_values(g):
    s = set()
    for x in g:
        if x in s: return False
        s.add(x)
    return True

Für kleine Fälle oder wenn ein vorzeitiges Beenden nicht der übliche Fall ist, würde ich erwarten len(x) != len(set(x)), dass dies die schnellste Methode ist.

für Geschwindigkeit:

import numpy as np
x = [1, 1, 1, 2, 3, 4, 5, 6, 2]
np.unique(x).size == len(x)

Wie wäre es, wenn Sie alle Einträge zu einem Set hinzufügen und dessen Länge überprüfen?

len(set(x)) == len(x)

Alternativ zu a setkönnen Sie a verwenden dict.

len({}.fromkeys(x)) == len(x)

Ein ganz anderer Ansatz, sortiert und gruppiert:

from itertools import groupby
is_unique = lambda seq: all(sum(1 for _ in x[1])==1 for x in groupby(sorted(seq)))

Es erfordert eine Sortierung, wird jedoch beim ersten wiederholten Wert beendet.

Hier ist eine rekursive O (N ² ) -Version zum Spaß:

def is_unique(lst):
    if len(lst) > 1:
        return is_unique(s[1:]) and (s[0] not in s[1:])
    return True

Hier ist eine rekursive Early-Exit-Funktion:

def distinct(L):
    if len(L) == 2:
        return L[0] != L[1]
    H = L[0]
    T = L[1:]
    if (H in T):
            return False
    else:
            return distinct(T)    

Es ist schnell genug für mich, ohne seltsame (langsame) Konvertierungen zu verwenden, während ich einen funktionalen Ansatz habe.

Wie wäre es damit

def is_unique(lst):
    if not lst:
        return True
    else:
        return Counter(lst).most_common(1)[0][1]==1

Sie können die Yan-Syntax (len (x)> len (set (x))) verwenden, aber anstelle von set (x) eine Funktion definieren:

 def f5(seq, idfun=None): 
    # order preserving
    if idfun is None:
        def idfun(x): return x
    seen = {}
    result = []
    for item in seq:
        marker = idfun(item)
        # in old Python versions:
        # if seen.has_key(marker)
        # but in new ones:
        if marker in seen: continue
        seen[marker] = 1
        result.append(item)
    return result

und mache len (x)> len (f5 (x)). Dies wird schnell gehen und ist auch auftragserhaltend.

Der dortige Code stammt von: http://www.peterbe.com/plog/uniqifiers-benchmark

Verwenden eines ähnlichen Ansatzes in einem Pandas-Datenrahmen, um zu testen, ob der Inhalt einer Spalte eindeutige Werte enthält:

if tempDF['var1'].size == tempDF['var1'].unique().size:
    print("Unique")
else:
    print("Not unique")

Für mich erfolgt dies sofort für eine int-Variable in einem Datumsrahmen, der über eine Million Zeilen enthält.

Alle Antworten oben sind gut, aber ich bevorzuge es, ein all_uniqueBeispiel aus 30 Sekunden Python zu verwenden

Sie müssen set()die angegebene Liste verwenden, um Duplikate zu entfernen. Vergleichen Sie deren Länge mit der Länge der Liste.

def all_unique(lst):
  return len(lst) == len(set(lst))

es gibt , Truewenn alle Werte in einer flachen Liste sind unique, Falsesonst

x = [1,2,3,4,5,6]
y = [1,2,2,3,4,5]
all_unique(x) # True
all_unique(y) # False

Für Anfänger:

def AllDifferent(s):
    for i in range(len(s)):
        for i2 in range(len(s)):
            if i != i2:
                if s[i] == s[i2]:
                    return False
    return True