Una solución más rápida que usar set() que funciona en secuencias (no iterables) es simplemente contar el primer elemento. Esto asume que la lista no está vacía (pero eso es trivial de verificar y decidir por ti mismo cuál debe ser el resultado en una lista vacía)

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

Algunos puntos de referencia simples:

>>> 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

La forma más simple y elegante es la siguiente:

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

(¡Sí, esto incluso funciona con la lista nula! Esto se debe a que este es uno de los pocos casos en los que python tiene semántica perezosa.)

En cuanto al rendimiento, esto fallará lo antes posible, por lo que es asintóticamente óptimo.

Un trabajo de comparación de conjuntos:

len(set(the_list)) == 1

Usando set elimina todos los elementos duplicados.

Puede convertir la lista a un conjunto. Un conjunto no puede tener duplicados. Así que si todos los elementos de la lista original son idénticos, el conjunto tendrá solo un elemento.

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

Por si sirve de algo, esto surgió recientemente en la lista de correo de python-ideas. Resulta que hay una receta de itertools para hacer esto ya:¹

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)

Supuestamente funciona muy bien y tiene algunas propiedades agradables.

1. Cortocircuitos: Dejará de consumir elementos del iterable tan pronto como encuentre el primer elemento no igual.
2. No requiere que los elementos sean hashables.
3. Es perezoso y solo requiere O (1) memoria adicional para hacer la comprobación.

^{1En otras palabras, no puedo tomar el crédito para llegar a la solución nor ni puedo tomar el crédito para incluso encontrar.}

Esta es otra opción, más rápida que len(set(x))==1 para listas largas (usa cortocircuito)

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

Esta es una forma sencilla de hacerlo:

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

Esto es un poco más complicado, incurre en sobrecarga de llamadas a funciones, pero la semántica está más claramente explicada:

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

Duda que este es el "más pitónico", pero algo así como:

>>> 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

Haría el truco.

Si usted está interesado en algo un poco más legible (pero por supuesto no tan eficiente,) usted podría intentar:

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

Yo haría:

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

Como any deja de buscar el iterable tan pronto como encuentra una condición True.

Con respecto a usar reduce() con lambda. Aquí hay un código de trabajo que personalmente creo que es mucho más agradable que algunas de las otras respuestas.

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

Devuelve una truple donde el primer valor es el booleano si todos los elementos son iguales o no.

Compruebe si todos los elementos son iguales al primero.

np.allclose(array, array[0])

Convierta la lista en el conjunto y luego encuentre el número de elementos en el conjunto. Si el resultado es 1, tiene elementos idénticos y si no, entonces los elementos de la lista no son idénticos.

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

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

Aquí hay dos formas simples de hacer esto

Usando set ()

Al convertir la lista a un conjunto, se eliminan los elementos duplicados. Así que si la longitud del conjunto convertido es 1, entonces esto implica que todos los elementos son los mismos.

len(set(input_list))==1

He aquí un ejemplo

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

Usando all ()

Esto comparará (equivalencia) el primer elemento de la lista de entrada con todos los demás elementos de la lista. Si todos son equivalentes True será devuelto, de lo contrario False será devuelto.

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

He aquí un ejemplo

>>> 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 usted está comprobando para ver si la lista entera es equivalente a un cierto valor, usted puede suibstitue el valor adentro para 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

Funciona en Python 2.4, que no tiene "todo".

Puede usar map y lambda

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

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

Puedes hacer:

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

Es bastante molesto que python te haga importar operadores como operator.and_. A partir de python3, también necesitarás importar functools.reduce.

(No debe usar este método porque no se romperá si encuentra valores no iguales, sino que continuará examinando toda la lista. Solo se incluye aquí como una respuesta para completar.)

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

El próximo cortocircuito cortocircuito:

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

Cambie la lista a un conjunto. Entonces, si el tamaño del conjunto es solo 1, deben haber sido el mismo.

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