जांचें कि क्या किसी सूची के सभी तत्व समान हैं

Question

मुझे निम्न कार्य की आवश्यकता है:

इनपुट : एlist

आउटपुट :

• True यदि इनपुट सूची के सभी तत्व मानक समानता ऑपरेटर का उपयोग करके एक दूसरे के बराबर मूल्यांकन करते हैं;
• False अन्यथा।

प्रदर्शन : बेशक, मैं किसी भी अनावश्यक ओवरहेड को लाइक नहीं करना चाहता।

मुझे लगता है कि यह सबसे अच्छा होगा:

• सूची के माध्यम से पुनरावृति
• आसन्न तत्वों की तुलना करें
• और ANDसभी परिणामस्वरूप बूलियन मान

लेकिन मुझे यकीन नहीं है कि ऐसा करने का सबसे पैथोनिक तरीका क्या है।

---

शॉर्ट-सर्किट सुविधा की कमी केवल एक लंबे इनपुट (~ 50 तत्वों) से अधिक होती है जिसमें असमान तत्व होते हैं। यदि यह अक्सर पर्याप्त होता है (सूची कितनी बार निर्भर हो सकती है), शॉर्ट-सर्किट की आवश्यकता होती है। सबसे अच्छा शॉर्ट-सर्किट एल्गोरिथ्म @ केनीटीएम लगता है checkEqual1। हालांकि, यह इसके लिए एक महत्वपूर्ण लागत का भुगतान करता है:

• लगभग समान सूची में प्रदर्शन में 20x तक
• लघु सूचियों पर प्रदर्शन में 2.5x तक

यदि प्रारंभिक असमान तत्वों के साथ लंबे इनपुट नहीं होते हैं (या पर्याप्त रूप से शायद ही कभी होता है), शॉर्ट-सर्किट की आवश्यकता नहीं होती है। फिर, अब तक सबसे तेज़ @Ivo van der Wijk solution है।

Comments

में के रूप में a == bया समान रूप में समान a is b?

— kennytm

क्या समाधान को खाली सूचियों को संभालना चाहिए? यदि हां, तो क्या लौटाया जाना चाहिए?

— डग

बराबर = a == b में। खाली सूची को संभालना चाहिए, और सही लौटना चाहिए।

— अधिकतम

हालांकि मुझे पता है कि यह कुछ अन्य सिफारिशों की तुलना में धीमी है, मुझे आश्चर्य functools.reduce(operator.eq, a)है कि सुझाव नहीं दिया गया है।

— user2846495

Answer 1

सामान्य विधि:

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सामग्री hashable होना चाहिए।
2. checkEqual1और checkEqual2किसी भी पुनरावृत्तियों का उपयोग कर सकते हैं, लेकिनcheckEqual3 एक अनुक्रम इनपुट लेना चाहिए, आमतौर पर एक सूची या टपल जैसे कंक्रीट कंटेनर।
3. checkEqual1 अंतर मिलते ही रुक जाता है।
4. चूंकि checkEqual1अधिक पायथन कोड शामिल है, इसलिए यह कम कुशल है जब कई आइटम शुरुआत में बराबर होते हैं।
5. के बाद से checkEqual2और checkEqual3हमेशा हे (एन) को कॉपी कार्रवाई करने, वे अधिक समय लग सकता है, तो आपके इनपुट के सबसे झूठी वापस आ जाएगी होगा।
6. के लिए checkEqual2और checkEqual3इसे से तुलना अनुकूल करने के लिए कठिन है a == bकरने के लिए a is b।

---

timeit परिणाम, पायथन 2.7 और (केवल s1, s4, s7, s9 के लिए सही होना चाहिए)

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

Comments

धन्यवाद, यह विकल्प का एक बहुत ही उपयोगी विवरण है। क्या आप कृपया अपने प्रदर्शन तालिका की दोहरी जांच कर सकते हैं - क्या यह सब msec में है, और सही कोशिकाओं में संख्याएँ हैं?

— अधिकतम

@ मोम: हाँ। ध्यान दें कि 1 मिसेक = 1000 usec।

— kennytm

बहुत बड़े सरणियों के लिए मेमोरी उपयोग विश्लेषण को मत भूलना, एक देशी समाधान जो कॉल को obj.__eq__कब lhs is rhs, और आउट-ऑफ-ऑर्डर ऑप्टिमाइज़ेशन के लिए अनुकूलित करता है ताकि शॉर्ट सर्कुलेटिंग सॉर्ट लिस्ट को अधिक तेज़ी से अनुमति दी जा सके।

— ग्लेन मेनार्ड

Ivo van der Wijk के पास दृश्यों के लिए एक बेहतर समाधान है जो सेट से लगभग 5 गुना तेज है और O (1) मेमोरी में है।

— एरोनस्टरलिंग

एक itertoolsनुस्खा भी है जिसे मैंने उत्तर के रूप में जोड़ा है। यह आपके टाइमिंग मैट्रिक्स :-) में फेंकने लायक हो सकता है।

— mgilson

Answer 2

सेट () का उपयोग करने की तुलना में तेजी से एक समाधान जो अनुक्रमों पर काम करता है (पुनरावृत्त नहीं) बस पहले तत्व को गिनना है। यह मानता है कि सूची गैर-रिक्त है (लेकिन यह जांचने के लिए तुच्छ है, और खुद तय करें कि परिणाम एक खाली सूची पर क्या होना चाहिए)

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

Comments

OMG, यह सेट समाधान से 6 गुना तेज है! (280 मिलियन एलिमेंट्स / सेकंड बनाम 45 मिलियन एलिमेंट्स / सेकंड ऑन माय लैपटॉप)। क्यों??? और क्या इसे संशोधित करने का कोई तरीका है ताकि यह शॉर्ट सर्किट (मुझे नहीं लगता ...)

— अधिकतम

मुझे लगता है कि सूची। क्राउन में एक अत्यधिक अनुकूलित सी कार्यान्वयन है, और सूची की लंबाई आंतरिक रूप से संग्रहीत है, इसलिए लेन () भी सस्ती है। शॉर्ट-सर्किट गणना () के लिए एक रास्ता नहीं है क्योंकि आपको सही गणना प्राप्त करने के लिए सभी तत्वों की वास्तव में जांच करने की आवश्यकता होगी।

— Ivo van der Wijk

क्या मैं इसे बदल सकता हूं: x.count(next(x)) == len(x)ताकि यह किसी भी कंटेनर x के लिए काम करे? आह .. एनएम, बस देखा है कि .count केवल दृश्यों के लिए उपलब्ध है .. क्यों यह अन्य अंतर्निहित कंटेनर के लिए लागू नहीं किया गया है? क्या किसी शब्दकोश के अंदर की गिनती किसी सूची के अंदर की तुलना में कम सार्थक है?

— अधिकतम

एक पुनरावृत्त की लंबाई नहीं हो सकती है। जैसे यह अनंत या सिर्फ गतिशील रूप से उत्पन्न हो सकता है। आप केवल इसकी लंबाई को एक सूची में परिवर्तित करके पा सकते हैं जो अधिकांश पुनरावृत्तियों के लाभ उठाती है

— Ivo van der Wijk

क्षमा करें, मेरे कहने का मतलब यह था कि क्यों countइसे पुनरावृत्तियों के लिए लागू नहीं किया गया, क्यों नहीं पुनरावृत्तियों के lenलिए उपलब्ध नहीं है। जवाब शायद यह है कि यह सिर्फ एक निरीक्षण है। लेकिन यह हमारे लिए अविश्वसनीय है क्योंकि .count()दृश्यों के लिए डिफ़ॉल्ट बहुत धीमा (शुद्ध अजगर) है। आपके समाधान का कारण इतना तेज़ है कि यह सी countद्वारा लागू सी-पर निर्भर करता है list। तो मुझे लगता है जो भी countसी में लागू करने के लिए चलने योग्य होता है , आपके दृष्टिकोण से लाभ होगा।

— अधिकतम

Answer 3

सबसे सरल और सबसे सुंदर तरीका इस प्रकार है:

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

(हां, यह खाली सूची के साथ भी काम करता है! यह इसलिए है क्योंकि यह उन कुछ मामलों में से एक है जहां अजगर के पास शब्दार्थ शब्द हैं।)

प्रदर्शन के संबंध में, यह जल्द से जल्द संभव समय पर विफल हो जाएगा, इसलिए यह asymptotically इष्टतम है।

Comments

यह काम करता है, लेकिन यह @KennyTM की तुलना में थोड़ा (1.5x) धीमा है checkEqual1। मुझे यकीन नहीं है कि क्यों।

— अधिकतम

अधिकतम: first=myList[0] all(x==first for x in myList)संभवत : क्योंकि मैंने अनुकूलन प्रदर्शन करने की जहमत नहीं उठाई , शायद

— नवजागेको १ely'१५

मुझे लगता है कि myList [0] का मूल्यांकन प्रत्येक पुनरावृत्ति के साथ किया जाता है। >>> timeit.timeit ('सभी ([y == x [0] में y के लिए x])', 'x = [1] * 4000', संख्या = 10000) 2.707076672740641 >>> timeit.timeit ('x0) = x [0]; सभी ([y == x0 for y में x]) ',' x = [1] * 4000 ', संख्या = 10000) 2.0908854261426484

— मैट लिबर्टी

मुझे निश्चित रूप से स्पष्ट करना चाहिए कि अनुकूलन एक खाली सूची first=myList[0]को फेंक देगा IndexError, इसलिए टिप्पणीकार जो मेरे द्वारा बताए गए अनुकूलन के बारे में बात कर रहे थे, उन्हें खाली सूची के किनारे-मामले से निपटना होगा। हालाँकि मूल ठीक है ( x==myList[0]यह ठीक है allक्योंकि सूची के खाली होने पर इसका मूल्यांकन कभी नहीं किया जाता है)।

— निंजाजेको

यह स्पष्ट रूप से इसका सही तरीका है। यदि आप हर मामले में गति चाहते हैं, तो सुन्न की तरह कुछ का उपयोग करें।

— हेनरी गोमर्सल

Answer 4

एक सेट तुलना कार्य:

len(set(the_list)) == 1

उपयोग करने से setसभी डुप्लिकेट तत्व निकल जाते हैं।

Answer 5

आप सूची को सेट में बदल सकते हैं। एक सेट में डुप्लिकेट नहीं हो सकते। इसलिए यदि मूल सूची में सभी तत्व समान हैं, तो सेट में सिर्फ एक तत्व होगा।

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

Comments

यह अच्छा है, लेकिन यह शॉर्ट सर्किट नहीं करता है और आपको परिणामी सूची की लंबाई की गणना करनी होगी।

— एरोनस्टरलिंग

सिर्फ क्यों नहीं len(set(input_list)) == 1?

— निक डंडौलकिस

@codaddict। इसका मतलब है कि भले ही पहले दो तत्व अलग-अलग हों, फिर भी यह पूरी खोज को पूरा करेगा। यह O (k) अतिरिक्त स्थान का भी उपयोग करता है जहां k सूची में अलग-अलग तत्वों की संख्या है।

— अनारोनस्टरलिंग

@max। क्योंकि सेट का निर्माण C में होता है और आपका कार्यान्वयन खराब है। आपको कम से कम इसे जनरेटर अभिव्यक्ति में करना चाहिए। सेट का उपयोग किए बिना इसे सही ढंग से कैसे करें, इसके लिए केनीटीएम का जवाब देखें।

— एरोनस्टरलिंग

सेट। सेट "2.6 संस्करण से हटा दिया गया है: अंतर्निहित सेट / फ्रोज़ेनसेट प्रकार इस मॉड्यूल को प्रतिस्थापित करते हैं।" ( docs.python.org/2/library/sets.html से )

— Moberg

Answer 6

इसके लायक क्या है, यह हाल ही में अजगर-विचारों की मेलिंग सूची पर आया । यह पता चला है कि पहले से ही ऐसा करने के लिए एक पुनरावृत्ति नुस्खा है : ¹

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 दूसरे शब्दों में, मैं समाधान के साथ आने का श्रेय नहीं ले सकता - और न ही इसे खोजने का श्रेय भी ले सकता हूं ।}

Comments

सबसे खराब स्थिति में यहां सूचीबद्ध सबसे तेज उत्तर की तुलना में बहुत तेज है।

— चैमग

return next(g, f := next(g, g)) == f(पाठ्यक्रम के py3.8 से)

— क्रिस_रैंड्स

Answer 7

यहाँ यह करने के दो सरल तरीके हैं

सेट का उपयोग कर ()

सूची को सेट में परिवर्तित करते समय, डुप्लिकेट तत्वों को हटा दिया जाता है। इसलिए यदि परिवर्तित सेट की लंबाई 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(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] के लिए मान को सूचीबद्ध कर सकते हैं।

Comments

रनटाइम में रुचि रखने वाले लोगों के len(set(a))लिए, 10,000,000 तत्वों की सूची में प्रदर्शन करने में 0.09 सेकेंड लगे, जबकि प्रदर्शन allमें 0.9 सेकंड (10 गुना अधिक समय) लगे।

— एलिप्टिका

मुझे इसकी पाइथोनिक सादगी के लिए यह उत्तर भी पसंद है, @Elliptica

— NickBraunagel

Answer 8

यह एक और विकल्प है, len(set(x))==1लंबी सूचियों की तुलना में तेज़ (शॉर्ट सर्किट का उपयोग करता है)

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

Comments

यह शॉर्ट सर्किट को नजरअंदाज करते हुए मेरे कंप्यूटर पर निर्धारित समाधान से 3 गुना धीमा है। इसलिए यदि सूची के पहले तीसरे में असमान तत्व पाया जाता है, तो यह औसत पर तेज़ है।

— अधिकतम

Answer 9

यह इसे करने का एक सरल तरीका है:

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)

Comments

आप यहाँ उपयोग करके एक निरर्थक तुलना से बच सकते हैं for elem in mylist[1:]। संदेह है कि यह गति में बहुत सुधार करता है, क्योंकि मुझे लगता elem[0] is elem[0]है कि दुभाषिया शायद उस तुलना को बहुत जल्दी कर सकता है।

— ब्रेंडन

Answer 10

जांचें कि क्या सभी तत्व पहले के बराबर हैं।

np.allclose(array, array[0])

Comments

तीसरे पक्ष के मॉड्यूल की आवश्यकता है।

— बछसौ

Answer 11

संदेह यह "सबसे पायथन" है, लेकिन कुछ इस तरह है:

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

चालबाजी करेगा।

Comments

आपके forलूप को अधिक पाइथोनिक बनाया जा सकता है if any(item != list[0] for item in list[1:]): return False, ठीक उसी शब्दार्थ के साथ।

— मुशफिल

Answer 12

यदि आप कुछ अधिक पढ़ने योग्य (लेकिन निश्चित रूप से कुशल नहीं है) में रुचि रखते हैं, तो आप कोशिश कर सकते हैं:

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

Comments

मैं वास्तव में यह देखने की कोशिश कर रहा हूं कि क्या एक सूची के सभी तत्व समान हैं; नहीं तो दो अलग-अलग सूचियाँ समान हैं।

— अधिकतम

Answer 13

सूची को सेट में बदलें और फिर सेट में तत्वों की संख्या ज्ञात करें। यदि परिणाम 1 है, तो इसमें समान तत्व हैं और यदि नहीं, तो सूची में तत्व समान नहीं हैं।

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

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

Answer 14

के reduce()साथ उपयोग करने के संबंध में lambda। यहां एक काम करने वाला कोड है जो मुझे लगता है कि व्यक्तिगत रूप से कुछ अन्य उत्तरों की तुलना में अच्छा है।

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

एक टपल लौटाता है जहां पहला मूल्य बूलियन है यदि सभी आइटम समान हैं या नहीं।

Comments

कोड में एक छोटी सी गलती है जैसा कि लिखा गया है (कोशिश करें [1, 2, 2]): यह पिछले बूलियन मान को ध्यान में नहीं रखता है। यह बदलकर इसे ठीक किया जा सकता है x[1] == yके साथ x[0] and x[1] == y।

— schot

Answer 15

मैं करूंगा:

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

जैसे anyही यह एक Trueस्थिति का पता चलता है के रूप में चलने योग्य खोज बंद कर देता है ।

Comments

यदि यह एकमात्र तर्क है तो आपको जनरेटर अभिव्यक्ति के आसपास अतिरिक्त कोष्ठक की आवश्यकता नहीं है।

— निन्जाएजेको

इसलिए all(), उपयोग क्यों नहीं करता है all(x == seq[0] for x in seq)? अधिक पायथोनिक लगता है और उसी का प्रदर्शन करना चाहिए

— चेन ए।

Answer 16

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

Answer 17

def allTheSame(i):
    j = itertools.groupby(i)
    for k in j: break
    for k in j: return False
    return True

पाइथन 2.4 में काम करता है, जिसमें "सब" नहीं है।

Comments

for k in j: breakके बराबर है next(j)। आप यह भी कर सकते थे def allTheSame(x): return len(list(itertools.groupby(x))<2)अगर आप दक्षता के बारे में परवाह नहीं की।

— नन्हेंजेको

Answer 18

मैप और लैम्ब्डा का उपयोग कर सकते हैं

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

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

Answer 19

या diffसुन्न की विधि का उपयोग करें :

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

और कॉल करने के लिए:

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

आउटपुट:

True

Comments

मुझे लगता है कि not np.any(np.diff(l))थोड़ा तेज हो सकता है।

— GZ0

Answer 20

या सुन्न की विधि का उपयोग करें:

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

और कॉल करने के लिए:

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

आउटपुट:

सच

Comments

यह उत्तर पिछले वर्ष के U9- फारवर्ड के उत्तर के समान है।

— मुहूर्त

अच्छी नज़र! मैंने समान संरचना / API का उपयोग किया है, लेकिन मेरी विधि np.unique और shape का उपयोग करती है। U9 का फ़ंक्शन np.all () और np.diff () का उपयोग करता है - मैं उन कार्यों में से किसी का भी उपयोग नहीं करता।

— लुइस बी

Answer 21

तुम कर सकते हो:

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

यह काफी कष्टप्रद है कि अजगर आपको ऑपरेटरों की तरह आयात करता है operator.and_। Python3 के रूप में, आपको आयात करने की भी आवश्यकता होगी functools.reduce।

(आपको इस पद्धति का उपयोग नहीं करना चाहिए क्योंकि यह गैर-समान मानों को खोजने पर नहीं टूटेगा, बल्कि पूरी सूची की जांच करना जारी रखेगा। इसे पूर्णता के उत्तर के रूप में यहां शामिल किया गया है।)

Comments

यह शॉर्ट सर्किट नहीं होगा। आप इसे अपने अन्य समाधान पर क्यों पसंद करेंगे?

— अधिकतम

@ मोम: आप ठीक उसी कारण से नहीं; मैंने इसे संपूर्णता के लिए शामिल किया। मुझे शायद इसका उल्लेख करने के लिए इसे संपादित करना चाहिए, धन्यवाद।

— नवजागेको

Answer 22

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

Comments

आपका पहला कोड स्पष्ट रूप से गलत था: reduce(lambda a,b:a==b, [2,2,2])पैदावार False... मैंने इसे संपादित किया, लेकिन इस तरह यह अब बहुत सुंदर नहीं है

— बर्डारियो

@berdario फिर आपको अपना जवाब लिखना चाहिए, बजाय इसके कि किसी और ने क्या लिखा है। यदि आपको लगता है कि यह उत्तर गलत था, तो आप इस पर टिप्पणी कर सकते हैं और / या इसे डाउनवोट कर सकते हैं।

— गोर्पिक

कुछ गलत करने के लिए बेहतर है, इसे पढ़ने के लिए सभी लोगों के लिए वहां छोड़ दें, संभवतः उन टिप्पणियों को याद कर रहे हैं जो बताते हैं कि क्यों गलत था

— बर्डारियो

"मुझे पोस्ट कब संपादित करनी चाहिए?" "किसी भी समय आपको लगता है कि आप पोस्ट को बेहतर बना सकते हैं, और ऐसा करने के लिए इच्छुक हैं। संपादन को प्रोत्साहित किया गया है!"

— बर्डारियो

Answer 23

सूची को सेट में बदलें। फिर यदि सेट का आकार केवल 1 है, तो वे समान रहे होंगे।

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

Answer 24

एक शुद्ध पायथन पुनरावर्ती विकल्प भी है:

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

हालांकि किसी कारण से यह कुछ मामलों में अन्य विकल्पों की तुलना में परिमाण के दो क्रम धीमी है। सी भाषा की मानसिकता से आते हुए, मुझे उम्मीद थी कि यह तेज़ होगा, लेकिन ऐसा नहीं है!

दूसरा नुकसान यह है कि पायथन में पुनरावृत्ति सीमा है जिसे इस मामले में समायोजित करने की आवश्यकता है। उदाहरण के लिए इसका उपयोग करते हुए ।

Answer 25

आप .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

Answer 26

आप उपयोग कर सकते हैं set। यह एक सेट बना देगा और दोहराए जाने वाले तत्वों को हटा देगा। फिर जांचें कि इसमें 1 से अधिक तत्व नहीं है।

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

उदाहरण:

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