ฉันต้องการฟังก์ชั่นต่อไปนี้:

อินพุต :list

ผลผลิต :

• True หากองค์ประกอบทั้งหมดในรายการอินพุตประเมินผลเท่ากันโดยใช้ตัวดำเนินการความเสมอภาคมาตรฐาน
• False มิฉะนั้น.

ประสิทธิภาพ : แน่นอนฉันไม่ต้องการให้เกิดค่าใช้จ่ายที่ไม่จำเป็น

ฉันรู้สึกว่ามันจะดีที่สุด:

• วนซ้ำตามรายการ
• เปรียบเทียบองค์ประกอบที่อยู่ติดกัน
• และANDค่าบูลีนผลลัพธ์ทั้งหมด

แต่ฉันไม่แน่ใจว่าเป็นวิธีที่ Pythonic ที่สุดที่จะทำ

การขาดคุณสมบัติลัดวงจรเพียงเจ็บอินพุตยาว (มากกว่า ~ 50 องค์ประกอบ) ที่มีองค์ประกอบที่ไม่เท่ากันในช่วงต้น หากสิ่งนี้เกิดขึ้นบ่อยครั้งเพียงพอ (ความถี่ขึ้นอยู่กับจำนวนรายการที่อาจจะเกิดขึ้น) จำเป็นต้องใช้ไฟฟ้าลัดวงจร ขั้นตอนวิธีการลัดวงจรที่ดีที่สุดน่าจะเป็น checkEqual1@KennyTM อย่างไรก็ตามมันจ่ายค่าใช้จ่ายที่สำคัญสำหรับสิ่งนี้:

• มากถึง 20x ในรายการที่เกือบเหมือนประสิทธิภาพ
• ประสิทธิภาพสูงสุด 2.5x สำหรับรายการสั้น ๆ

หากอินพุตยาวที่มีองค์ประกอบไม่เท่ากันต้นไม่เกิดขึ้น (หรือเกิดขึ้นน้อยมาก) ไม่จำเป็นต้องใช้ไฟฟ้าลัดวงจร จากนั้นที่เร็วที่สุดคือโซลูชันของ @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) เสมอพวกเขาจะใช้เวลานานขึ้นหากข้อมูลส่วนใหญ่ของคุณจะส่งกลับค่าเท็จ
6. สำหรับcheckEqual2และcheckEqual3มันเป็นเรื่องยากที่จะปรับตัวเข้ากับการเปรียบเทียบจากไปa == ba 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 () ที่ทำงานกับลำดับ (ไม่ใช่ iterables) คือการนับองค์ประกอบแรก นี่ถือว่าเป็นรายการที่ไม่ว่างเปล่า (แต่มันไม่ค่อยสำคัญในการตรวจสอบและตัดสินใจด้วยตัวเองว่าผลลัพธ์ควรอยู่ในรายการที่ว่างเปล่า)

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)

(ใช่มันใช้กับรายการที่ว่างได้ด้วย! นี่เป็นเพราะหนึ่งในไม่กี่กรณีที่ไพ ธ อนมีความหมายแบบขี้เกียจ)

เกี่ยวกับประสิทธิภาพการทำงานสิ่งนี้จะล้มเหลวในเวลาที่เร็วที่สุดดังนั้นจึงเป็นวิธีที่เหมาะสมที่สุด

การเปรียบเทียบชุดทำงาน:

len(set(the_list)) == 1

การใช้setจะลบองค์ประกอบที่ซ้ำกันทั้งหมด

คุณสามารถแปลงรายการเป็นชุด ชุดไม่สามารถมีข้อมูลซ้ำได้ ดังนั้นหากองค์ประกอบทั้งหมดในรายการต้นฉบับเหมือนกันชุดจะมีเพียงองค์ประกอบเดียว

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

สำหรับสิ่งที่คุ้มค่านี้ขึ้นมาบนหลามความคิดรายการจดหมายเมื่อเร็ว ๆ นี้ ปรากฎว่ามีสูตร 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. ลัดวงจร: มันจะหยุดการบริโภคไอเท็มจาก iterable ทันทีที่พบไอเท็มแรกที่ไม่เท่ากัน
2. ไม่ต้องใช้รายการที่จะแฮช
3. มันขี้เกียจและต้องการเพียง O (1) หน่วยความจำเพิ่มเติมเพื่อทำการตรวจสอบ

^{1กล่าวอีกนัยหนึ่งฉันไม่สามารถใช้เครดิตในการแก้ปัญหาได้ - ฉันจะไม่สามารถนำเครดิตไปใช้เพื่อค้นหาได้}

ต่อไปนี้เป็นวิธีการง่ายๆสองวิธี

ใช้ชุด ()

เมื่อแปลงรายการเป็นชุดองค์ประกอบที่ซ้ำกันจะถูกลบออก ดังนั้นหากความยาวของชุดแปลงเป็น 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

ใช้ทั้งหมด ()

สิ่งนี้จะทำการเปรียบเทียบ (เทียบเท่า) องค์ประกอบแรกของรายการอินพุตกับองค์ประกอบอื่น ๆ ในรายการ หากทั้งหมดเท่ากับ 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]

นี่คือตัวเลือกอื่นเร็วกว่า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))

ส่งคืน tuple โดยที่ค่าแรกเป็นบูลีนหากทุกรายการเหมือนกันหรือไม่

ฉันจะทำ:

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

เป็นanyหยุดค้นหา iterable เร็วที่สุดเท่าที่จะพบ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:]))

หรือใช้diffวิธีการ numpy:

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

และโทร:

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

เอาท์พุท:

True

หรือใช้วิธี diff ของ numpy:

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)

มันค่อนข้างน่ารำคาญที่หลามทำให้คุณนำเข้าตัวดำเนินการเช่น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:])

อย่างไรก็ตามด้วยเหตุผลบางอย่างมันเป็นในบางกรณีสองคำสั่งของขนาดที่ช้ากว่าตัวเลือกอื่น ๆ มาจากความคิดทางภาษา 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