Tôi cần chức năng sau:

Đầu vào : alist

Đầu ra :

• True nếu tất cả các yếu tố trong danh sách đầu vào đánh giá bằng nhau bằng toán tử đẳng thức chuẩn;
• False nếu không thì.

Hiệu suất : tất nhiên, tôi không muốn chịu bất kỳ chi phí không cần thiết nào.

Tôi cảm thấy nó là tốt nhất để:

• lặp qua danh sách
• so sánh các yếu tố liền kề
• và ANDtất cả các giá trị Boolean kết quả

Nhưng tôi không chắc cách Pythonic nhất để làm điều đó là gì.

Việc thiếu tính năng ngắn mạch chỉ gây tổn hại cho đầu vào dài (trên ~ 50 phần tử) có các phần tử không bằng nhau từ sớm. Nếu điều này xảy ra thường xuyên đủ (mức độ thường xuyên phụ thuộc vào thời gian của các danh sách), thì cần phải đoản mạch. Thuật toán ngắn mạch tốt nhất dường như là @KennyTM checkEqual1. Nó trả tiền, tuy nhiên, một chi phí đáng kể cho việc này:

• hiệu suất lên tới 20 lần trong danh sách gần giống nhau
• hiệu suất lên tới 2,5 lần trong danh sách ngắn

Nếu các đầu vào dài với các phần tử không bằng nhau sớm không xảy ra (hoặc hiếm khi xảy ra), thì không cần phải đoản mạch. Sau đó, nhanh nhất là giải pháp @Ivo van der Wijk.

Phương pháp chung:

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

Lót:

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

Ngoài ra một lớp lót:

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

Sự khác biệt giữa 3 phiên bản là:

1. Trong checkEqual2nội dung phải được băm.
2. checkEqual1và checkEqual2có thể sử dụng bất kỳ trình lặp nào, nhưng checkEqual3phải lấy một đầu vào tuần tự, thường là các thùng chứa cụ thể như một danh sách hoặc bộ dữ liệu.
3. checkEqual1 dừng lại ngay khi tìm thấy sự khác biệt
4. Do checkEqual1chứa nhiều mã Python hơn nên sẽ kém hiệu quả hơn khi nhiều mục bằng nhau lúc ban đầu.
5. Vì checkEqual2và checkEqual3luôn luôn thực hiện các hoạt động sao chép O (N), chúng sẽ mất nhiều thời gian hơn nếu hầu hết đầu vào của bạn sẽ trả về Sai.
6. Đối với checkEqual2và checkEqual3nó khó hơn để thích ứng so sánh từ a == bđến a is b.

timeit kết quả, đối với Python 2.7 và (chỉ s1, s4, s7, s9 sẽ trả về 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 = []

chúng tôi nhận được

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

Ghi chú:

# 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

Một giải pháp nhanh hơn so với sử dụng set () hoạt động trên các chuỗi (không phải lặp) là chỉ cần đếm phần tử đầu tiên. Điều này giả định danh sách này không trống (nhưng đó là chuyện nhỏ để kiểm tra và tự quyết định kết quả sẽ có trong danh sách trống)

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

một số điểm chuẩn đơn giản:

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

Cách đơn giản và thanh lịch nhất như sau:

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

(Vâng, điều này thậm chí hoạt động với danh sách trống! Điều này là do đây là một trong số ít trường hợp python có ngữ nghĩa lười biếng.)

Về hiệu suất, điều này sẽ thất bại trong thời gian sớm nhất, vì vậy nó là tối ưu không có triệu chứng.

Một bộ công việc so sánh:

len(set(the_list)) == 1

Sử dụng setloại bỏ tất cả các yếu tố trùng lặp.

Bạn có thể chuyển đổi danh sách thành một bộ. Một tập hợp không thể có trùng lặp. Vì vậy, nếu tất cả các phần tử trong danh sách gốc giống hệt nhau, tập hợp sẽ chỉ có một phần tử.

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

Đối với những gì nó có giá trị, điều này đã xuất hiện trong danh sách gửi thư ý tưởng python gần đây. Nó chỉ ra rằng đã có một công thức itertools để làm điều này đã: ¹

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)

Giả sử nó thực hiện rất độc đáo và có một vài thuộc tính tốt đẹp.

1. Đoản mạch: Nó sẽ ngừng tiêu thụ các mặt hàng từ vòng lặp ngay khi tìm thấy mặt hàng không bằng nhau đầu tiên.
2. Không yêu cầu các mục để có thể băm.
3. Đó là lười biếng và chỉ yêu cầu O (1) bộ nhớ bổ sung để thực hiện kiểm tra.

^{1 Nói cách khác, tôi không thể lấy tín dụng cho đến với giải pháp - cũng không phải tôi có thể mất tín dụng cho dù việc tìm kiếm nó.}

Đây là hai cách đơn giản để làm điều này

sử dụng bộ ()

Khi chuyển đổi danh sách thành một tập hợp, các phần tử trùng lặp sẽ bị xóa. Vì vậy, nếu độ dài của bộ chuyển đổi là 1, thì điều này ngụ ý rằng tất cả các phần tử đều giống nhau.

len(set(input_list))==1

Đây là một ví dụ

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

sử dụng tất cả ()

Điều này sẽ so sánh (tương đương) phần tử đầu tiên của danh sách đầu vào với mọi phần tử khác trong danh sách. Nếu tất cả đều tương đương True sẽ được trả về, nếu không Sai sẽ được trả về.

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

Đây là một ví dụ

>>> 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 Nếu bạn đang kiểm tra xem toàn bộ danh sách có tương đương với một giá trị nhất định hay không, bạn có thể xác nhận giá trị trong cho input_list [0].

Đây là một tùy chọn khác, nhanh hơn so len(set(x))==1với danh sách dài (sử dụng ngắn mạch)

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

Đây là một cách đơn giản để làm điều đó:

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

Điều này phức tạp hơn một chút, nó phát sinh chức năng gọi qua đầu, nhưng ngữ nghĩa được phát âm rõ ràng hơn:

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

Kiểm tra nếu tất cả các yếu tố bằng đầu tiên.

np.allclose(array, array[0])

Nghi ngờ đây là "Pythonic nhất", nhưng đại loại như:

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

sẽ làm các mẹo.

Nếu bạn quan tâm đến thứ gì đó dễ đọc hơn một chút (nhưng tất nhiên là không hiệu quả,) bạn có thể thử:

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

Chuyển đổi danh sách thành tập hợp và sau đó tìm số phần tử trong tập hợp. Nếu kết quả là 1, nó có các phần tử giống hệt nhau và nếu không, thì các phần tử trong danh sách không giống nhau.

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

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

Về việc sử dụng reduce()với lambda. Đây là một mã làm việc mà cá nhân tôi nghĩ là đẹp hơn so với một số câu trả lời khác.

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

Trả về một tuple trong đó giá trị đầu tiên là boolean nếu tất cả các mục giống nhau hoặc không.

Tôi sẽ làm:

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

khi anydừng tìm kiếm iterable ngay khi nó tìm thấy một Trueđiều kiện.

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

Hoạt động trong Python 2.4, không có "tất cả".

Có thể sử dụng bản đồ và lambda

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

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

Hoặc sử dụng diffphương pháp của numpy:

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

Và gọi:

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

Đầu ra:

True

Hoặc sử dụng phương pháp diff của numpy:

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

Và gọi:

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

Đầu ra:

Thật

Bạn có thể làm:

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

Điều khá khó chịu là python khiến bạn nhập các toán tử như thế nào operator.and_. Kể từ python3, bạn cũng sẽ cần phải nhập functools.reduce.

(Bạn không nên sử dụng phương pháp này vì nó sẽ không bị hỏng nếu tìm thấy các giá trị không bằng nhau, nhưng sẽ tiếp tục kiểm tra toàn bộ danh sách. Nó chỉ được đưa vào đây như một câu trả lời cho sự hoàn chỉnh.)

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

Tiếp theo sẽ ngắn mạch:

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

Thay đổi danh sách thành một bộ. Sau đó, nếu kích thước của tập hợp chỉ là 1, thì chúng phải giống nhau.

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

Ngoài ra còn có một tùy chọn đệ quy Python thuần túy:

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

Tuy nhiên vì một số lý do, trong một số trường hợp, hai bậc độ lớn chậm hơn các tùy chọn khác. Xuất phát từ tâm lý ngôn ngữ C, tôi mong muốn điều này sẽ nhanh hơn, nhưng thực tế không phải vậy!

Nhược điểm khác là có giới hạn đệ quy trong Python cần được điều chỉnh trong trường hợp này. Ví dụ sử dụng cái này .

Bạn có thể sử dụng .nunique()để tìm số lượng các mục duy nhất trong một danh sách.

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

bạn có thể sử dụng set. Nó sẽ tạo ra một tập hợp và loại bỏ các yếu tố lặp đi lặp lại. Sau đó kiểm tra xem nó có không quá 1 phần tử.

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

Thí dụ:

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