Comprobando si todos los elementos de una lista son únicos

¿Cuál es la mejor forma (mejor que en la forma convencional) de comprobar si todos los elementos de una lista son únicos?

Mi enfoque actual usando a Counteres:

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

¿Puedo hacerlo mejor?

No es el más eficiente, pero sencillo y conciso:

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

Probablemente no haga mucha diferencia para las listas cortas.

Aquí hay una línea de dos líneas que también hará una salida anticipada:

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

Si los elementos de x no se pueden cifrar, tendrá que recurrir al uso de una lista para 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

Una solución de salida temprana podría ser

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

sin embargo, para casos pequeños o si la salida anticipada no es el caso común, esperaría que len(x) != len(set(x))sea ​​el método más rápido.

por velocidad:

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

¿Qué tal agregar todas las entradas a un conjunto y verificar su longitud?

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

Alternativa a a set, puede utilizar a dict.

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

Otro enfoque completamente, usando sorted y groupby:

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

Requiere una ordenación, pero sale en el primer valor repetido.

Aquí hay una versión recursiva O (N ² ) por diversión:

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

Aquí hay una función de salida temprana recursiva:

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 lo suficientemente rápido para mí sin usar conversiones extrañas (lentas) mientras tengo un enfoque de estilo funcional.

Qué tal esto

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

Puede usar la sintaxis de Yan (len (x)> len (set (x))), pero en lugar de set (x), defina una función:

 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

y haz len (x)> len (f5 (x)). Esto será rápido y también preservará el orden.

El código se toma de: http://www.peterbe.com/plog/uniqifiers-benchmark

Usando un enfoque similar en un marco de datos de Pandas para probar si el contenido de una columna contiene valores únicos:

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

Para mí, esto es instantáneo en una variable int en un marco de fecha que contiene más de un millón de filas.

todas las respuestas anteriores son buenas pero prefiero usar all_unique ejemplo de 30 segundos de Python

necesitas usar set() en la lista dada para eliminar duplicados, compare su longitud con la longitud de la lista.

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

devuelve Truesi todos los valores en una lista plana son unique, de lo Falsecontrario

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

Para principiantes:

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