Ho bisogno della seguente funzione:

Input : alist

Uscita :

• True se tutti gli elementi nell'elenco di input vengono valutati uguali tra loro utilizzando l'operatore di uguaglianza standard;
• False altrimenti.

Prestazioni : ovviamente preferisco non sostenere spese inutili.

Sento che sarebbe meglio:

• scorrere l'elenco
• confronta gli elementi adiacenti
• e ANDtutti i valori booleani risultanti

Ma non sono sicuro di quale sia il modo più Pythonic per farlo.

La mancanza di funzionalità di corto circuito fa male solo su un input lungo (oltre ~ 50 elementi) che hanno elementi disuguali all'inizio. Se ciò si verifica abbastanza spesso (quanto spesso dipende da quanto potrebbero essere lunghi gli elenchi), è necessario il cortocircuito. Il miglior algoritmo di corto circuito sembra essere @KennyTM checkEqual1. Paga, tuttavia, un costo significativo per questo:

• fino a 20x in elenchi quasi identici delle prestazioni
• fino a 2,5 volte in termini di prestazioni su elenchi brevi

Se gli input lunghi con elementi disuguali precoci non si verificano (o accadono in modo sufficientemente raro), non è necessario il cortocircuito. Quindi, di gran lunga la più veloce è la soluzione @Ivo van der Wijk.

Metodo generale:

def checkEqual1(iterator):
    iterator = iter(iterator)
    try:
        first = next(iterator)
    except StopIteration:
        return True
    return all(first == rest for rest in iterator)

One-liner:

def checkEqual2(iterator):
   return len(set(iterator)) <= 1

Anche una linea:

def checkEqual3(lst):
   return lst[1:] == lst[:-1]

La differenza tra le 3 versioni è che:

1. Nel checkEqual2contenuto deve essere hash.
2. checkEqual1e checkEqual2può usare qualsiasi iteratore, ma checkEqual3deve accettare un input di sequenza, in genere contenitori concreti come un elenco o una tupla.
3. checkEqual1 si interrompe non appena viene rilevata una differenza.
4. Poiché checkEqual1contiene più codice Python, è meno efficiente quando molti degli elementi sono uguali all'inizio.
5. Dal momento che checkEqual2e checkEqual3eseguire sempre O (n) operazioni di copia, prenderanno più a lungo se la maggior parte del vostro input restituisce false.
6. Perché checkEqual2ed checkEqual3è più difficile adattare il confronto da a == ba a is b.

timeit risultato, per Python 2.7 e (solo s1, s4, s7, s9 dovrebbero restituire True)

s1 = [1] * 5000
s2 = [1] * 4999 + [2]
s3 = [2] + [1]*4999
s4 = [set([9])] * 5000
s5 = [set([9])] * 4999 + [set([10])]
s6 = [set([10])] + [set([9])] * 4999
s7 = [1,1]
s8 = [1,2]
s9 = []

noi abbiamo

      | checkEqual1 | checkEqual2 | checkEqual3  | checkEqualIvo | checkEqual6502 |
|-----|-------------|-------------|--------------|---------------|----------------|
| s1  | 1.19   msec | 348    usec | 183     usec | 51.6    usec  | 121     usec   |
| s2  | 1.17   msec | 376    usec | 185     usec | 50.9    usec  | 118     usec   |
| s3  | 4.17   usec | 348    usec | 120     usec | 264     usec  | 61.3    usec   |
|     |             |             |              |               |                |
| s4  | 1.73   msec |             | 182     usec | 50.5    usec  | 121     usec   |
| s5  | 1.71   msec |             | 181     usec | 50.6    usec  | 125     usec   |
| s6  | 4.29   usec |             | 122     usec | 423     usec  | 61.1    usec   |
|     |             |             |              |               |                |
| s7  | 3.1    usec | 1.4    usec | 1.24    usec | 0.932   usec  | 1.92    usec   |
| s8  | 4.07   usec | 1.54   usec | 1.28    usec | 0.997   usec  | 1.79    usec   |
| s9  | 5.91   usec | 1.25   usec | 0.749   usec | 0.407   usec  | 0.386   usec   |

Nota:

# http://stackoverflow.com/q/3844948/
def checkEqualIvo(lst):
    return not lst or lst.count(lst[0]) == len(lst)

# http://stackoverflow.com/q/3844931/
def checkEqual6502(lst):
    return not lst or [lst[0]]*len(lst) == lst

Una soluzione più veloce dell'utilizzo di set () che funziona su sequenze (non iterabili) è semplicemente contare il primo elemento. Questo presuppone che l'elenco non sia vuoto (ma è banale da controllare e decidi tu stesso quale dovrebbe essere il risultato in un elenco vuoto)

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

alcuni semplici benchmark:

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

Il modo più semplice ed elegante è il seguente:

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

(Sì, funziona anche con la lista vuota! Questo perché questo è uno dei pochi casi in cui Python ha una semantica pigra.)

Per quanto riguarda le prestazioni, ciò fallirà il più presto possibile, quindi è asintoticamente ottimale.

Un lavoro di confronto impostato:

len(set(the_list)) == 1

L'uso setrimuove tutti gli elementi duplicati.

È possibile convertire l'elenco in un set. Un set non può avere duplicati. Quindi, se tutti gli elementi nell'elenco originale sono identici, il set avrà solo un elemento.

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

Per quello che vale, questo è apparso recentemente nella mailing list di Python-Ideas . Si scopre che esiste già una ricetta itertools per fare questo: ¹

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)

Presumibilmente si comporta molto bene e ha alcune belle proprietà.

1. Cortocircuiti: smetterà di consumare oggetti dall'iterabile non appena trova il primo oggetto non uguale.
2. Non richiede articoli per essere hash.
3. È pigro e richiede solo O (1) memoria aggiuntiva per eseguire il controllo.

^{1 In altre parole, non posso prendermi il merito per aver trovato la soluzione, né posso prendermi il merito anche per averla trovata .}

Ecco due semplici modi per farlo

usando set ()

Quando si converte l'elenco in un set, gli elementi duplicati vengono rimossi. Quindi, se la lunghezza dell'insieme convertito è 1, ciò implica che tutti gli elementi sono uguali.

len(set(input_list))==1

Ecco un esempio

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

usando all ()

Ciò confronterà (equivalenza) il primo elemento dell'elenco di input con ogni altro elemento dell'elenco. Se tutti sono equivalenti, True verrà restituito, altrimenti False verrà restituito.

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

Ecco un esempio

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

PS Se stai verificando se l'intero elenco è equivalente a un determinato valore, puoi sostituire il valore in input_list [0].

Questa è un'altra opzione, più veloce rispetto len(set(x))==1alle liste lunghe (usa il corto circuito)

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

Questo è un modo semplice per farlo:

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

Questo è leggermente più complicato, comporta un overhead di chiamata di funzione, ma la semantica è spiegata più chiaramente:

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

Controlla se tutti gli elementi sono uguali al primo.

np.allclose(array, array[0])

Dubbio, questo è il "più Pythonic", ma qualcosa del genere:

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

farebbe il trucco.

Se sei interessato a qualcosa di un po 'più leggibile (ma ovviamente non altrettanto efficiente), potresti provare:

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

Converti l'elenco nel set e trova il numero di elementi nel set. Se il risultato è 1, ha elementi identici e, in caso contrario, gli elementi nell'elenco non sono identici.

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

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

Per quanto riguarda l'utilizzo reduce()con lambda. Ecco un codice funzionante che personalmente ritengo molto più bello di alcune delle altre risposte.

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

Restituisce una tupla in cui il primo valore è il valore booleano se tutti gli elementi sono uguali o meno.

Farei:

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

come anysi ferma la ricerca sul iterabile non appena trova una Truecondizione.

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

Funziona in Python 2.4, che non ha "tutto".

Può usare map e lambda

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

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

O usa il diffmetodo di numpy:

import numpy as np
def allthesame(l):
    return np.all(np.diff(l)==0)

E chiamare:

print(allthesame([1,1,1]))

Produzione:

True

O usa il metodo diff di numpy:

import numpy as np
def allthesame(l):
    return np.unique(l).shape[0]<=1

E chiamare:

print(allthesame([1,1,1]))

Produzione:

Vero

Tu puoi fare:

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

È abbastanza fastidioso che Python ti faccia importare gli operatori come operator.and_. A partire da python3, dovrai anche importare functools.reduce.

(Non dovresti usare questo metodo perché non si romperà se troverà valori non uguali, ma continuerai a esaminare l'intero elenco. È solo incluso qui come risposta per completezza.)

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

Il prossimo metterà in corto circuito:

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

Cambia l'elenco in un set. Quindi se la dimensione del set è solo 1, devono essere stati gli stessi.

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

C'è anche un'opzione ricorsiva Python pura:

 def checkEqual(lst):
    if len(lst)==2 :
        return lst[0]==lst[1]
    else:
        return lst[0]==lst[1] and checkEqual(lst[1:])

Tuttavia, per qualche motivo è in alcuni casi due ordini di grandezza più lenti rispetto ad altre opzioni. Venendo dalla mentalità del linguaggio C, mi aspettavo che questo fosse più veloce, ma non lo è!

L'altro svantaggio è che esiste un limite di ricorsione in Python che deve essere modificato in questo caso. Ad esempio usando questo .

È possibile utilizzare .nunique()per trovare il numero di elementi univoci in un elenco.

def identical_elements(list):
    series = pd.Series(list)
    if series.nunique() == 1: identical = True
    else:  identical = False
    return identical



identical_elements(['a', 'a'])
Out[427]: True

identical_elements(['a', 'b'])
Out[428]: False

puoi usare set. Farà un set e rimuoverà elementi ripetitivi. Quindi controlla che non abbia più di 1 elemento.

if len(set(your_list)) <= 1:
    print('all ements are equal')

Esempio:

>>> len(set([5, 5])) <= 1
True