पायथन, पता लगाएं कि एक सूची में विशिष्ट आइटम नहीं है

Question

मान लें कि एक सूची है जिसमें संख्याएं और अक्षर दोनों शामिल हैं। क्या यह पता लगाने का कोई त्वरित तरीका है कि सूची में कुछ विशिष्ट तत्व नहीं हैं। मैं इसे परिस्थितियों में उपयोग करने की योजना बना रहा हूं।

Answer 1

शायद

3 not in [1, 2, "a"] 
# True 

Answer 2

नोट: यदि आप एक dict की कुंजी के रूप में तत्वों डाल सकते हैं तो सदस्यता के लिए परीक्षण हैशिंग एल्गोरिथ्म के लिए बहुत जल्दी धन्यवाद है। यदि आपकी सूची बहुत लंबी है या आपका ऐप इस तरह की चीज करता है तो केवल एक मुद्दा होगा। अन्यथा, "एक्स एक्स इन वाई" के रूप में स्वेन कहते हैं।

any(isinstance(x, int) for x in alist) 

:

Answer 3

आप

bool([x for x in alist if isinstance(x, int)]) 

बेहतर (स्वेन Marnach द्वारा) संस्करण मतलब है?

Answer 4

यह इस बात पर निर्भर करता है कि आप क्या करने की कोशिश कर रहे हैं। यदि गति कोई फर्क नहीं पड़ता है, तो एक एलएसटी का उपयोग करें। यदि इससे कोई फर्क पड़ता है, तो यह इस बात पर निर्भर करेगा कि क्या आप अपनी सूची को किसी भिन्न डेटा संरचना में परिवर्तित कर सकते हैं (यानी आप अक्सर कहानियों की सूची में आइटम देखेंगे), आकार, आदि ...

कोई विचार देने के लिए :

import timeit 

a = range(10000) 
da = dict(zip(a, [None for i in a])) 

def list_first(): 
    return 0 in a 

def dict_first(): 
    return 0 in da 

def list_last(): 
    return 9999 in a 

def dict_last(): 
    return 9999 in da 

if __name__ == "__main__": 
    for f in ["list_first", "dict_first", "list_last", "dict_last"]: 
     t = timeit.Timer("%s()" % f, setup="from __main__ import %s" % f) 
     print min(t.repeat(number=10000)) 

यह मैं देता है:

0.00302004814148 
0.00318598747253 
4.21943712234 
0.004145860672 

आप किसी आइटम जो सूची की शुरुआत में है के लिए देखो, एक dict का उपयोग कर चीज़ों को गति नहीं करता है, के रूप में उम्मीद है। यदि आप अंत में किसी आइटम की तलाश करते हैं, तो अंतर बहुत महत्वपूर्ण है (परिमाण का 3 क्रम), हालांकि अपेक्षित है: dict हैशटेबल का उपयोग करें, सूचियों को प्रत्येक आइटम को एक दूसरे के बाद देखने की आवश्यकता है।

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