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 Counter
est:
>>> 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?
len(x) > len(set(x))
est True lorsque les éléments de nex
sont PAS uniques. Le titre de cette question demande exactement le contraire: "Vérifier si tous les éléments d'une liste sont uniques"Voici un deux lignes qui fera également une sortie anticipée:
Si les éléments de x ne sont pas hachables, vous devrez alors recourir à une liste pour
seen
:la source
Une solution de sortie anticipée pourrait être
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.la source
s = set()
...return not any(s.add(x) if x not in s else True for x in g)
len(x) != len(set(x))
à être plus rapide que cela si la sortie prématurée n'est pas courante? Les deux opérations ne sont-elles pas O (len (x)) ? (oùx
est la liste d'origine)if x in s
intérieur de la boucle O (len (x)) for.pour la vitesse:
la source
Que diriez-vous d'ajouter toutes les entrées à un ensemble et de vérifier sa longueur?
la source
len()
.Alternative à a
set
, vous pouvez utiliser undict
.la source
Une autre approche entièrement, utilisant trié et groupby:
Il nécessite un tri, mais se termine sur la première valeur répétée.
la source
groupby
et j'ai trouvé cette réponse. Je trouve cela très élégant, car il s'agit d'une expression unique et fonctionne avec les outils intégrés sans nécessiter de variable supplémentaire ou d'instruction de boucle.id()
fonction pour les trier car c'est un prérequis pourgroupby()
fonctionner:groupby(sorted(seq), key=id)
Voici une version récursive O (N 2 ) pour le plaisir:
la source
Voici une fonction de sortie anticipée récursive:
C'est assez rapide pour moi sans utiliser de conversions étranges (lentes) tout en ayant une approche de style fonctionnel.
la source
H in T
effectue une recherche linéaire etT = L[1:]
copie la partie découpée de la liste, ce sera donc beaucoup plus lent que les autres solutions qui ont été suggérées sur les grandes listes. C'est O (N ^ 2) je pense, alors que la plupart des autres sont O (N) (ensembles) ou O (N log N) (solutions basées sur le tri).Que dis-tu de ça
la source
Vous pouvez utiliser la syntaxe de Yan (len (x)> len (set (x))), mais au lieu de set (x), définissez une fonction:
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
la source
x = range(1000000) + range(1000000)
, l'exécution de set (x) est plus rapide que f5 (x). L'ordre n'est pas une exigence dans la question, mais même l'exécution triée (set (x)) est toujours plus rapide que f5 (x)En utilisant une approche similaire dans un dataframe Pandas pour tester si le contenu d'une colonne contient des valeurs uniques:
Pour moi, c'est instantané sur une variable int dans une dateframe contenant plus d'un million de lignes.
la source
toutes les réponses ci-dessus sont bonnes mais je préfère utiliser l'
all_unique
exemple de 30 secondes de pythonvous devez utiliser
set()
sur la liste donnée pour supprimer les doublons, comparez sa longueur à la longueur de la liste.il renvoie
True
si toutes les valeurs d'une liste plate sontunique
,False
sinonla source
Pour les débutants:
la source