Comprobando si todos los elementos en una lista son únicos

Question

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

Mi enfoque actual es el uso de un Counter:

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

¿Puedo hacer algo mejor?

Answer 1

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

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

probablemente no va a hacer mucha diferencia para listas cortas.

Answer 2

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

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

Answer 3

alternativa a un set, se puede utilizar un dict.

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

Answer 4

Una solución pronta salida 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 temprana excitante no es el caso común entonces yo esperaría len(x) != len(set(x)) siendo el método más rápido.

Answer 5

puede utilizar la sintaxis de Yan (len (x)> len (juego (x))), pero en lugar de conjunto (x), definir 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 hacer len (x)> len (f5 (x)). Esto será rápido y también preservará el orden.

Código no se ha tomado de: http://www.peterbe.com/plog/uniqifiers-benchmark

Answer 6

Aquí es un revestimiento de dos que también lo hará la salida temprana:

>>> 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 son hashable, entonces tendrá a recurrir al uso de una lista de 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 

Answer 7

¿Qué tal esto

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

Answer 8

para la velocidad:

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

Answer 9

Otro enfoque totalmente, utilizando ordenados 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 especie, pero salidas en el primer valor repetido.

Answer 10

Aquí es 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 necesidad de utilizar las conversiones extrañas (lento), mientras que tener un enfoque de estilo funcional.

Answer 11

Aquí es una O recursiva (N) versión para la diversión:

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

Answer 12

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 

Answer 13

Utilizando un enfoque similar en una trama de datos 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í, este soy yo nstantaneous en una variable int en un marco de fecha que contiene más de un millón de filas.