Vérifier si tous les éléments d'une liste sont uniques

Quelle est la meilleure façon (la meilleure comme de manière conventionnelle) de vérifier si tous les éléments d'une liste sont uniques?

Mon approche actuelle utilisant a Counterest:

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

Puis-je faire mieux?

Pas le plus efficace, mais simple et concis:

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

Cela ne fera probablement aucune différence pour les listes courtes.

Voici un deux lignes qui fera également une sortie anticipée:

>>> 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 les éléments de x ne sont pas hachables, vous devrez alors recourir à une liste pour 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

Une solution de sortie anticipée pourrait être

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

cependant, pour les petits cas ou si la sortie anticipée n'est pas le cas courant, je m'attends à len(x) != len(set(x))être la méthode la plus rapide.

pour la vitesse:

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

Que diriez-vous d'ajouter toutes les entrées à un ensemble et de vérifier sa longueur?

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

Alternative à a set, vous pouvez utiliser un dict.

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

Une autre approche entièrement, utilisant trié et groupby:

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

Il nécessite un tri, mais se termine sur la première valeur répétée.

Voici une version récursive O (N ² ) pour le plaisir:

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

Voici une fonction de sortie anticipée récursive:

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)    

C'est assez rapide pour moi sans utiliser de conversions étranges (lentes) tout en ayant une approche de style fonctionnel.

Que dis-tu de ça

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

Vous pouvez utiliser la syntaxe de Yan (len (x)> len (set (x))), mais au lieu de set (x), définissez une fonction:

 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

et faites len (x)> len (f5 (x)). Ce sera rapide et préservera également l'ordre.

Le code est tiré de: http://www.peterbe.com/plog/uniqifiers-benchmark

En utilisant une approche similaire dans un dataframe Pandas pour tester si le contenu d'une colonne contient des valeurs uniques:

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

Pour moi, c'est instantané sur une variable int dans une dateframe contenant plus d'un million de lignes.

toutes les réponses ci-dessus sont bonnes mais je préfère utiliser l' all_uniqueexemple de 30 secondes de python

vous devez utiliser set()sur la liste donnée pour supprimer les doublons, comparez sa longueur à la longueur de la liste.

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

il renvoie Truesi toutes les valeurs d'une liste plate sont unique, Falsesinon

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

Pour les débutants:

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