une solution plus rapide que l'utilisation de set() qui fonctionne sur des séquences (non itérables) est de simplement compter le premier élément. Cela suppose que la liste n'est pas vide (mais c'est trivial de vérifier, et de décider vous-même ce que le résultat devrait être sur une liste vide)

x.count(x[0]) == len(x)

simples points de repère:

>>> timeit.timeit('len(set(s1))<=1', 's1=[1]*5000', number=10000)
1.4383411407470703
>>> timeit.timeit('len(set(s1))<=1', 's1=[1]*4999+[2]', number=10000)
1.4765670299530029
>>> timeit.timeit('s1.count(s1[0])==len(s1)', 's1=[1]*5000', number=10000)
0.26274609565734863
>>> timeit.timeit('s1.count(s1[0])==len(s1)', 's1=[1]*4999+[2]', number=10000)
0.25654196739196777

le moyen le plus simple et le plus élégant est le suivant:

all(x==myList[0] for x in myList)

(Oui, cela fonctionne même avec le nul de la liste! C'est parce que c'est l'un des rares cas où python est paresseux de la sémantique.)

en ce qui concerne la performance, cela échouera le plus tôt possible, il est donc asymptotiquement optimal.

Un ensemble de comparaison de travail:

len(set(the_list)) == 1

utilisant set supprime tous les éléments en double.

vous pouvez convertir la liste en un ensemble. Un ensemble ne peut pas avoir de doublons. Ainsi, si tous les éléments de la liste originale sont identiques, l'ensemble n'aura qu'un seul élément.

if len(sets.Set(input_list)) == 1
// input_list has all identical elements.

pour ce que ça vaut, c'est arrivé sur la liste de diffusion Python-ideas récemment. Il s'avère qu'Il ya un itertools recette pour ce faire déjà: ¹

def all_equal(iterable):
    "Returns True if all the elements are equal to each other"
    g = groupby(iterable)
    return next(g, True) and not next(g, False)

semble-t-il fonctionne très bien et a quelques belles propriétés.

1. courts-circuits: il cessera de consommer des articles de l'itérable dès qu'il trouve le premier non-équivalent article.
2. N'exige pas que les articles soient hachables.
3. Il est paresseux et ne nécessite O(1) de la mémoire supplémentaire pour faire le chèque.

^{1 en d'autres termes, Je ne peux pas prendre le crédit de venir avec la solution -- ni ne peux prendre le crédit pour même trouver il.}

c'est une autre option, plus rapide que len(set(x))==1 pour les longues listes (utilise le court-circuit)

def constantList(x):
    return x and [x[0]]*len(x) == x

C'est une façon simple de le faire:

result = mylist and all(mylist[0] == elem for elem in mylist)

c'est un peu plus compliqué, il engage appel de fonction au-dessus, mais la sémantique est plus clairement énoncée:

def all_identical(seq):
    if not seq:
        # empty list is False.
        return False
    first = seq[0]
    return all(first == elem for elem in seq)

de Doute, c'est le "plus Pythonic", mais quelque chose comme:

>>> falseList = [1,2,3,4]
>>> trueList = [1, 1, 1]
>>> 
>>> def testList(list):
...   for item in list[1:]:
...     if item != list[0]:
...       return False
...   return True
... 
>>> testList(falseList)
False
>>> testList(trueList)
True

ferait l'affaire.

si vous êtes intéressé par quelque chose d'un peu plus lisible (mais bien sûr pas aussi efficace,) vous pouvez essayer:

def compare_lists(list1, list2):
    if len(list1) != len(list2): # Weed out unequal length lists.
        return False
    for item in list1:
        if item not in list2:
            return False
    return True

a_list_1 = ['apple', 'orange', 'grape', 'pear']
a_list_2 = ['pear', 'orange', 'grape', 'apple']

b_list_1 = ['apple', 'orange', 'grape', 'pear']
b_list_2 = ['apple', 'orange', 'banana', 'pear']

c_list_1 = ['apple', 'orange', 'grape']
c_list_2 = ['grape', 'orange']

print compare_lists(a_list_1, a_list_2) # Returns True
print compare_lists(b_list_1, b_list_2) # Returns False
print compare_lists(c_list_1, c_list_2) # Returns False

je ferais:

not any((x[i] != x[i+1] for i in range(0, len(x)-1)))

comme any cesse de chercher le itérable dès qu'il trouve une condition True .

concernant l'utilisation de reduce() avec lambda . Voici un code de travail que je pense personnellement est beaucoup plus agréable que certaines des autres réponses.

reduce(lambda x, y: (x[1]==y, y), [2, 2, 2], (True, 2))

renvoie un truple où la première valeur est le booléen si tous les éléments sont identiques ou non.

vérifier si tous les éléments sont égaux au premier.

np.allclose(array, array[0])

convertissez la liste dans l'ensemble puis trouvez le nombre d'éléments dans l'ensemble. Si le résultat est 1, il a des éléments identiques et si non, alors les éléments de la liste ne sont pas identiques.

list1 = [1,1,1]
len(set(list1)) 
>1

list1 = [1,2,3]
len(set(list1)
>3

Voici deux façons simples de le faire

utilisant set ()

lors de la conversion de la liste en un ensemble, les éléments dupliqués sont supprimés. Donc si la longueur de l'ensemble converti est 1, alors cela implique que tous les éléments sont les mêmes.

len(set(input_list))==1

voici un exemple

>>> a = ['not', 'the', 'same']
>>> b = ['same', 'same', 'same']
>>> len(set(a))==1  # == 3
False
>>> len(set(b))==1  # == 1
True

à l'aide de tous()

comparera (équivalence) la première élément de la liste d'entrée pour tous les autres éléments de la liste. Si tous sont équivalents Vrai sera retourné, sinon False sera retourné.

all(element==input_list[0] for element in input_list)

voici un exemple

>>> a = [1, 2, 3, 4, 5]
>>> b = [1, 1, 1, 1, 1]
>>> all(number==a[0] for number in a)
False
>>> all(number==b[0] for number in b)
True

P. S Si vous vérifiez si la liste entière est équivalente à une certaine valeur, vous pouvez suivre la valeur de input_list[0].

>>> a = [1, 2, 3, 4, 5, 6]
>>> z = [(a[x], a[x+1]) for x in range(0, len(a)-1)]
>>> z
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
# Replacing it with the test
>>> z = [(a[x] == a[x+1]) for x in range(0, len(a)-1)]
>>> z
[False, False, False, False, False]
>>> if False in z : Print "All elements are not equal"

def allTheSame(i):
    j = itertools.groupby(i)
    for k in j: break
    for k in j: return False
    return True

fonctionne en Python 2.4, qui n'a pas "tout".

peut utiliser la carte et lambda

lst = [1,1,1,1,1,1,1,1,1]

print all(map(lambda x: x == lst[0], lst[1:]))

Vous pouvez le faire:

reduce(and_, (x==yourList[0] for x in yourList), True)

c'est assez ennuyeux que python vous fasse importer les opérateurs comme operator.and_ . À partir de python3, vous devrez également importer functools.reduce .

(vous ne devez pas utiliser cette méthode parce qu'elle ne se cassera pas si elle trouve des valeurs non égales, mais continuera à examiner la liste entière. Il est juste inclus ici comme une réponse pour l'exhaustivité.)

lambda lst: reduce(lambda a,b:(b,b==a[0] and a[1]), lst, (lst[0], True))[1]

le prochain court-circuit sera:

all(itertools.imap(lambda i:yourlist[i]==yourlist[i+1], xrange(len(yourlist)-1)))

changez la liste en un ensemble. Alors si la taille de l'ensemble est seulement 1, Ils doivent avoir été les mêmes.

if len(set(my_list)) == 1: