次の機能が必要です。

入力：alist

出力：

• True 入力リストのすべての要素が標準の等価演算子を使用して互いに等しいと評価された場合。
• False さもないと。

パフォーマンス：もちろん、不要なオーバーヘッドが発生しないようにします。

私はそれが最善だと思います：

• リストを反復する
• 隣接する要素を比較する
• とANDすべての結果のブール値

しかし、それを行うための最もPythonicな方法が何かはわかりません。

ショートサーキット機能の欠如は、早い段階で等しくない要素を持つ長い入力（約50要素以上）でのみ害を及ぼします。これが頻繁に発生する場合（どのくらいの頻度がリストの長さに依存するか）、短絡が必要です。最良の短絡アルゴリズムは@KennyTMのようですcheckEqual1。ただし、これにはかなりの費用がかかります。

• パフォーマンスがほぼ同じリストで最大20倍
• ショートリストのパフォーマンスは最大2.5倍

初期の不均等な要素を持つ長い入力が発生しない場合（または十分にまれにしか発生しない場合）、短絡は必要ありません。次に、最も速いのは@Ivo van der Wijkソリューションです。

一般的な方法：

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

一発ギャグ：

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

また、ワンライナー：

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

3つのバージョンの違いは次のとおりです。

1. ではcheckEqual2、コンテンツハッシュ可能でなければなりません。
2. checkEqual1また、checkEqual2任意のイテレータを使用できますがcheckEqual3、通常はリストやタプルなどの具体的なコンテナであるシーケンス入力を受け取る必要があります。
3. checkEqual1 違いが見つかるとすぐに停止します。
4. にcheckEqual1はより多くのPythonコードが含まれているため、最初に多くの項目が等しい場合は効率が低下します。
5. 以来checkEqual2とcheckEqual3常にO（N）のコピー操作を実行し、あなたの入力のほとんどはFalseを返しますならば、彼らは時間がかかります。
6. 用checkEqual2とcheckEqual3それがより比較に適応するのは難しいですa == bへをa is b。

timeit 結果、Python 2.7および（s1、s4、s7、s9のみが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 = []

我々が得る

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

注意：

# 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

シーケンス（反復可能ではない）で機能するset（）を使用するよりも速い解決策は、最初の要素を数えることです。これは、リストが空ではないことを前提としています（ただし、チェックして、空のリストで結果をどうするかを自分で決めるのは簡単です）

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

いくつかの簡単なベンチマーク：

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

最も単純で最もエレガントな方法は次のとおりです。

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

（はい、これは空のリストでも機能します！これは、Pythonが遅延セマンティクスを使用する数少ないケースの1つであるためです。）

パフォーマンスに関しては、これはできるだけ早い時期に失敗するため、漸近的に最適です。

セット比較作業：

len(set(the_list)) == 1

を使用setすると、すべての重複要素が削除されます。

リストをセットに変換できます。セットは重複できません。したがって、元のリストのすべての要素が同一である場合、セットには要素が1つだけ含まれます。

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

価値のあることとして、これは最近python-ideasメーリングリストに登場しました。これを実行するためのitertoolsレシピがすでにあることがわかります：¹

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)

おそらくそれは非常にうまく機能し、いくつかの素晴らしいプロパティを持っています。

1. ショートサーキット：最初の等しくないアイテムが見つかるとすぐに、反復可能オブジェクトからのアイテムの消費を停止します。
2. アイテムをハッシュ可能にする必要はありません。
3. それは怠惰であり、チェックを行うためにO（1）の追加メモリのみを必要とします。

^{1言い換えれば、私はソリューションを思いついたとしても、それを見つけたとしても信用できません。}

これを行う2つの簡単な方法を次に示します

set（）の使用

リストをセットに変換すると、重複する要素が削除されます。したがって、変換されたセットの長さが1の場合、すべての要素が同じであることを意味します。

len(set(input_list))==1

ここに例があります

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

all（）の使用

これは、入力リストの最初の要素をリスト内の他のすべての要素と（同等）比較します。すべて同等の場合はTrueが返され、それ以外の場合はFalseが返されます。

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

ここに例があります

>>> 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リスト全体が特定の値と等しいかどうかを確認する場合は、input_list [0]の値をsuibstitueできます。

これは別のオプションで、len(set(x))==1長いリストよりも高速です（短絡を使用）

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

これは簡単な方法です：

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

これは少し複雑で、関数呼び出しのオーバーヘッドが発生しますが、セマンティクスはより明確に綴られています。

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

すべての要素が最初のものと等しいかどうかを確認します。

np.allclose(array, array[0])

これは「最もPythonic」であるに違いありませんが、次のようなものです。

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

トリックを行います。

あなたがもう少し読みやすい何かに興味があるなら（もちろん、それほど効率的ではありません）、あなたは試すことができます：

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

リストをセットに変換し、セット内の要素の数を見つけます。結果が1の場合、要素は同一であり、そうでない場合、リスト内の要素は同一ではありません。

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

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

使用に関してreduce()でlambda。これが私が個人的に他のいくつかの答えよりも優れていると思う作業コードです。

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

すべてのアイテムが同じかどうかに応じて、最初の値がブール値であるタプルを返します。

私はします：

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

条件anyが見つかるとすぐに反復可能オブジェクトの検索を停止しTrueます。

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

「すべて」を持たないPython 2.4で動作します。

マップとラムダを使用できます

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

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

またはdiffnumpyのメソッドを使用します：

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

そして呼び出すには：

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

出力：

True

またはnumpyのdiffメソッドを使用します：

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

そして呼び出すには：

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

出力：

本当

できるよ：

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

pythonにのような演算子をインポートさせるのはかなり面倒ですoperator.and_。python3以降、もインポートする必要がありますfunctools.reduce。

（このメソッドは、等しくない値が見つかっても壊れないため、使用しないでください。ただし、リスト全体の調査を続行します。完全を期すための回答としてここに記載しています。）

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

次のものは短絡します：

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

リストをセットに変更します。次に、セットのサイズが1のみの場合、それらは同じでなければなりません。

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

純粋なPython再帰オプションもあります。

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

ただし、何らかの理由で、他のオプションよりも2桁遅い場合があります。C言語の考え方から来たので、これはもっと速いと思っていましたが、そうではありません！

他の欠点は、この場合に調整する必要があるPythonの再帰制限があることです。たとえば、これを使用します。

を使用.nunique()して、リスト内の一意のアイテムの数を見つけることができます。

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

使用できますset。セットを作成し、反復的な要素を削除します。次に、要素が1つ以下であることを確認します。

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

例：

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