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

Quel est le meilleur moyen (le meilleur comme dans le mode conventionnel) de vérifier si tous les éléments d'une liste sont uniques?

Mon approche actuelle à l'aide d'un 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 de mieux?

InformationsquelleAutor user225312 | 2011-03-11

140

Pas le plus efficace, mais simple et concis:
```
if len(x) > len(set(x)):
   pass # do something
```
Ne sera probablement pas faire beaucoup de différence pour des listes.
- voulez-vous dire == ?
- C'est ce que je fais. Probablement pas efficace pour les grandes listes bien que.
- Pas nécessairement, qui va exécuter le corps de la condition, si la liste contient des éléments répétés (le "#faire quelque chose" dans l'exemple).
- Assez juste, la bonne solution. Je suis de la manipulation de peine < 500 éléments, donc il doit faire ce que je veux.
- Pour ceux qui s'inquiètent de l'efficacité avec de longues listes, ce est efficace pour de longues listes qui sont réellement unique (où tous les éléments ont besoin d'être vérifiées). La sortie précoce des solutions de plus long (environ 2x plus dans mes tests) pour réellement unique listes. Alors... si vous vous attendez à la plupart de vos listes pour être unique, utilisez ce simple réglage de la longueur de la vérification de la solution. Si vous vous attendez à la plupart de vos listes pour ne PAS être unique, utiliser une sortie précoce de la solution. À utiliser dépend de votre cas d'utilisation.
- Expliquer pourquoi cela fonctionne aiderait
InformationsquelleAutor yan
87

Ici est une de deux-liner qui va aussi faire un début de sortie:
```
>>> 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 hashable, alors vous allez avoir à recourir à l'aide d'une liste 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
```
- +1 nettoyer et ne pas parcourir toute la liste si pas nécessaire.
- +1, fin de la partie, mais c'est une excellente solution (et qu'il mérite beaucoup plus upvotes).
- Seriez-vous prêt à la licence de cet extrait de code, en vertu d'un Apache 2.0-compatible avec la licence (par exemple, Apache 2, 2/3 de la ligne de BSD, MIT, X11, zlib). J'aimerais l'utiliser dans Apache 2.0 projet, je suis à l'aide, et parce que StackOverflow de la licence, fubar, je vous le demande comme l'auteur original.
- J'ai mis un autre code à l'aide de licence MIT, de sorte que fonctionne pour moi pour cet extrait. Rien de spécial je dois faire?
InformationsquelleAutor PaulMcG
20

Une sortie précoce de la solution 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 en début de sortie n'est pas le cas alors je m'attends à len(x) != len(set(x)) être la méthode la plus rapide.
- +1 ce qui semble le moyen efficace de le faire.
- J'ai accepté l'autre réponse, que je n'étais pas particulièrement à la recherche de l'optimisation.
- Vous pouvez la réduire en mettant la ligne suivante après s = set()... return not any(s.add(x) if x not in s else True for x in g)
- Pourriez-vous expliquer pourquoi vous attendez len(x) != len(set(x)) être plus rapide que si en début de sortie n'est pas commun? Ne sont pas tant les opérations de O(len(x))? (où x est l'original de la liste)
- Oh, je vois: votre méthode n'est pas O(len(x)) parce que vous vérifiez if x in s à l'intérieur de la O(len(x)) pour la boucle.
InformationsquelleAutor 6502

pour la vitesse:

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

InformationsquelleAutor locojay

10

Comment sur l'ajout de toutes les entrées d'un ensemble et de vérifier sa longueur?
```
len(set(x)) == len(x)
```
- Répondu une seconde après yan, ouch. Court et doux. Toutes les raisons de ne pas utiliser cette solution?
- Pas toutes les séquences (générateurs spécialement) soutien len().
InformationsquelleAutor Grzegorz Oledzki
9

Alternative à un set, vous pouvez utiliser un dict.
```
len({}.fromkeys(x)) == len(x)
```
- Très bonne idée! +1
- Je ne vois absolument aucun avantage à utiliser un dict sur un jeu. Semble compliquer inutilement les choses.
InformationsquelleAutor Tugrul Ates
2

Une autre approche entièrement, à l'aide de trier et grouper:
```
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 quitte sur la première répété valeur.
- le hachage est plus rapide que le tri
InformationsquelleAutor PaulMcG
2

Ici est récursive de sortie précoce de la fonction:
```
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)    
```
Il est assez rapide pour moi, sans l'aide de bizarre(lent) conversions tout en
avoir une fonctionnelle approche de style.
- H in T fait une recherche linéaire, et T = L[1:] des copies de tranches partie de la liste, de sorte que ce sera beaucoup plus lente que les autres solutions qui ont été proposées sur les grosses listes. Il est O(N^2) je pense que, bien que la plupart des autres sont en O(N) (fixe) ou O(N log N) (tri en fonction des solutions).
InformationsquelleAutor mhourdakis

Ici est un appel récursif à O(N²) version pour le fun:

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

InformationsquelleAutor Karol

Comment à ce sujet

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

InformationsquelleAutor yilmazhuseyin

1

En utilisant une approche similaire dans une Pandas dataframe de 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 un dateframe contenant plus d'un million de lignes.

InformationsquelleAutor user1718097
0

Vous pouvez utiliser Yan de la syntaxe (len(x) > len(set(x))), mais au lieu de set(x), définir 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 ne len(x) > len(f5(x)). Ce sera rapide et est également afin de préserver.

Code, il est pris à partir de: http://www.peterbe.com/plog/uniqifiers-benchmark
- Pourrait être bon, mais je ne suis pas à la recherche à des fins d'optimisation.
- cette fonction f5 sera plus lent qu'à l'aide de jeu qui est mieux optimisé pour la vitesse. Ce code commence à casser lorsque la liste est très importante en raison du cher "annexer" fonctionnement. avec de grandes listes de ce genre x = range(1000000) + range(1000000), en cours d'exécution jeu(x) est plus rapide que la touche f5(x). L'ordre n'est pas une exigence dans la question, mais même en cours d'exécution sorted(set(x)) est encore plus rapide que la touche f5(x)
InformationsquelleAutor canisrufus

-4

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

InformationsquelleAutor DonChriss

Vous devez vous connecter pour publier un commentaire.