पहला आइटम या कोई नहीं लौटने के लिए पायथन मुहावरा

Question

मुझे यकीन है कि ऐसा करने का एक सरल तरीका है जो मुझे नहीं हो रहा है।

मैं उन तरीकों का एक गुच्छा कह रहा हूं जो एक सूची लौटाते हैं। सूची खाली हो सकती है। यदि सूची गैर-रिक्त है, तो मैं पहला आइटम वापस करना चाहता हूं; अन्यथा, मैं कोई नहीं लौटना चाहता। यह कोड काम करता है:

my_list = get_list()
if len(my_list) > 0: return my_list[0]
return None

ऐसा लगता है कि ऐसा करने के लिए एक सरल एक-मुहावरा होना चाहिए, लेकिन मेरे जीवन के लिए मैं इसके बारे में सोच भी नहीं सकता। है?

संपादित करें:

कारण यह है कि मैं यहां एक-लाइन अभिव्यक्ति की तलाश कर रहा हूं, ऐसा नहीं है कि मुझे अविश्वसनीय रूप से कोड पसंद है, लेकिन क्योंकि मुझे इस तरह के बहुत सारे कोड लिखने हैं:

x = get_first_list()
if x:
    # do something with x[0]
    # inevitably forget the [0] part, and have a bug to fix
y = get_second_list()
if y:
    # do something with y[0]
    # inevitably forget the [0] part AGAIN, and have another bug to fix

मैं जो करना चाहता हूं वह निश्चित रूप से एक समारोह के साथ पूरा किया जा सकता है (और शायद होगा):

def first_item(list_or_none):
    if list_or_none: return list_or_none[0]

x = first_item(get_first_list())
if x:
    # do something with x
y = first_item(get_second_list())
if y:
    # do something with y

मैंने सवाल पोस्ट किया क्योंकि मैं अक्सर आश्चर्यचकित हूं कि पायथन में सरल अभिव्यक्तियां क्या कर सकती हैं, और मुझे लगा कि एक फ़ंक्शन लिखना एक मूर्खतापूर्ण बात थी अगर कोई सरल अभिव्यक्ति कर सकता था, तो वह कर सकता था। लेकिन इन उत्तरों को देखकर ऐसा लगता है एक समारोह की तरह है सरल उपाय।

Comments

btw, पायथन 2.6+ पर आप यह मानने के next(iter(your_list), None)बजाय उपयोग कर सकते हैं ( और हमेशा एक पुन: चलने योग्य नहीं होना चाहिए)। first_item(your_list)your_listNoneget_first_list()get_second_list()

— jfs

मुझे लगता है कि आपका मतलब है next(iter(your_list)), क्योंकि यदि आप दूसरे तर्क की आपूर्ति iterकरते हैं, तो आप इसे बता रहे हैं कि पहला तर्क कॉल करने योग्य है।

— रॉबर्ट रॉसनी

नहीं, Noneयहाँ दूसरा पैरामीटर है next(), नहीं iter()। यदि खाली है तो next()उठाने के बजाय दिए जाने पर उसका दूसरा पैरामीटर लौटाता है। StopIterationyour_list

— jfs

@JFSebastian द्वारा सुझाए गए समाधान डुप्लिकेट प्रश्न के साथ मौजूद हैं: stackoverflow.com/a/18533669/144408

— shahjapan

Answer 1

अजगर 2.6+

next(iter(your_list), None)

यदि your_listहो सकता है None:

next(iter(your_list or []), None)

अजगर २.४

def get_first(iterable, default=None):
    if iterable:
        for item in iterable:
            return item
    return default

उदाहरण:

x = get_first(get_first_list())
if x:
    ...
y = get_first(get_second_list())
if y:
    ...

एक अन्य विकल्प उपरोक्त फ़ंक्शन को इनलाइन करना है:

for x in get_first_list() or []:
    # process x
    break # process at most one item
for y in get_second_list() or []:
    # process y
    break

बचने के लिए breakआप लिख सकते हैं:

for x in yield_first(get_first_list()):
    x # process x
for y in yield_first(get_second_list()):
    y # process y

कहाँ पे:

def yield_first(iterable):
    for item in iterable or []:
        yield item
        return

Comments

यह अंतिम विकल्प लगभग वही है जो मैं देख रहा हूं: यह स्पष्ट है, यह काम करता है, और इससे मुझे एक नए फ़ंक्शन को परिभाषित करने की आवश्यकता नहीं है। मैं कहता हूँ "ठीक है" अगर ब्रेक किसी तरह की जरूरत नहीं थी, क्योंकि इसे छोड़ने का जोखिम नगण्य नहीं है। लेकिन इस दृष्टिकोण में सच्चाई की अंगूठी है।

— रॉबर्ट रॉसनी

ओह, मुझे यह बिल्कुल पसंद नहीं है। यदि सूची में कोई भी वस्तु गलत का मूल्यांकन करती है, तो उस मूल्य को छोड़ दिया जाता है और बदल दिया जाता है। यदि आपके पास ""सूची में एक खाली स्ट्रिंग है, तो उसे छोड़ दिया गया है और एक खाली सूची द्वारा प्रतिस्थापित किया गया है []। यदि आपके पास 0 है, तो भी बदल दिया जाता है []। यदि आप Falseवहाँ हैं, तो भी बदल दिया गया है। आदि आप एक विशिष्ट मामले में इसके साथ दूर हो सकते हैं, लेकिन यह विकसित करने के लिए एक बुरी आदत है।

— स्टीवेहा

@steveha: bool(lst) हमें बताता है कि क्या len(lst) > 0यह हमें इस बारे में कुछ नहीं बताता है कि आइटम lstमें क्या शामिल है, bool([False]) == True;इसलिए अभिव्यक्ति [False] or []वापस आती है [False], वही इसके लिए [0] or [] रिटर्न है [0]।

— JFS

@RobertRossney: मैंने बयान yield_first()से बचने के लिए जोड़ा है break।

— JFS

@ThomasAhle: दोनों सत्य हैं। मैंने गैर-मामले के लिए समाधान प्रदान करने के लिए उत्तर अपडेट किया है।

— JFS

Answer 2

सबसे अच्छा तरीका यह है:

a = get_list()
return a[0] if a else None

आप इसे एक पंक्ति में भी कर सकते हैं, लेकिन प्रोग्रामर के लिए इसे पढ़ना बहुत कठिन है:

return (get_list()[:1] or [None])[0]

Comments

उफ़। उल्लेख किया जाना चाहिए यह एक पायथन 2.4 ऐप है।

— रॉबर्ट रॉसनी

@Adam: भविष्य का उपयोग कर सकतेnext(iter(your_list), None)

— JFS

@JFSebastian वास्तव next(iter(your_list))में पर्याप्त है

— ब्रैड जॉनसन

@ ब्रैडलगेजहॉसन: गलत। यह Noneओपी के पूछने पर लौटने के बजाय स्टॉपइंटरेशन बढ़ाता है । प्रयास करें: next(iter([]))।

— शाम

Answer 3

(get_list() or [None])[0]

वह काम करना चाहिए।

BTW मैंने वैरिएबल का उपयोग नहीं किया list, क्योंकि यह बिलिन list()फ़ंक्शन को अधिलेखित करता है।

संपादित करें: मेरे पास पहले थोड़ा सरल, लेकिन गलत संस्करण था।

Comments

यह चालाक है और काम करता है, लेकिन मुझे लगता है कि "वापसी फू [0] अगर फू और कोई नहीं" जैसा कि efotinis ने सुझाव दिया है कि रखरखाव के लिए पालन करना थोड़ा आसान है।

— जय

सवाल एक लाइन समाधान के लिए पूछ रहा था, इसलिए मैंने उस पर फैसला सुनाया।

— पुनरावर्ती

न तो उन अभिव्यक्तियों में से कोई भी काम करता है अगर get_list () रिटर्न कोई नहीं; आपको "TypeError: 'noneType' ऑब्जेक्ट unsubscriptable है।" या "TypeError: असमर्थित ऑपरेंड प्रकार (ओं) के लिए +: 'noneType' और 'list'।"

— रॉबर्ट रॉसनी

प्रश्न में, यह कहता है कि विधियां सूची को लौटाती हैं, जिनमें से कोई भी एक नहीं है। इसलिए आवश्यकताओं को देखते हुए, मुझे अभी भी विश्वास है कि वे दोनों काम करते हैं।

— पुनरावर्ती

अब काम करना चाहिए अगर get_list () कोई भी नहीं लौटाता क्योंकि यह सबस्क्रिप्ट या अब और नहीं मिला है।

— रॉबर्ट

Answer 4

सूची से पुनरावृत्त होने के बाद सबसे पायथन मुहावरेदार तरीका एक अगले पर () का उपयोग करना है । जैसे @JFSebastian ने 13 दिसंबर, 2011 को टिप्पणी में कहा था।

next(iter(the_list), None)यदि the_listखाली है तो यह कोई नहीं लौटाता है। अगला देखें () पायथन 2.6+

या अगर आपको पता है कि the_listखाली नहीं है:

iter(the_list).next()देख iterator.next () अजगर 2.2+

Comments

इसका यह फायदा है कि आपको अपनी सूची को एक वैरिएबल पर असाइन नहीं करना है जैसे return l[0] if l else Noneकि सूची एक लिबकंप है। जब सूची वास्तव में एक जीनक्सप्र है तो यह और भी बेहतर है क्योंकि आपको पूरी सूची का निर्माण नहीं करना है जैसेnext(iter(x for x in range(10) if x % 2 == 0), None)

— रुबेनलागुना

यदि आपको पता है कि the_listखाली नहीं है, तो आप लिखेंगे the_list[0]।

— काया ३

Answer 5

यदि आप एक सूची समझ से पहली चीज़ (या कोई नहीं) को गिराने की कोशिश कर रहे हैं, तो आप इसे करने के लिए एक जनरेटर पर स्विच कर सकते हैं:

next((x for x in blah if cond), None)

प्रो: काम करता है अगर ब्लाह इंडेक्सेबल कॉन नहीं है: यह अपरिचित वाक्यविन्यास है। हालाँकि यह उपयोगी है, जबकि इफ़िथॉन में सामान को इधर-उधर से छान रहा है।

Answer 6

ओपी का समाधान लगभग वहां है, इसे और अधिक पायथोनिक बनाने के लिए कुछ चीजें हैं।

एक के लिए, सूची की लंबाई प्राप्त करने की कोई आवश्यकता नहीं है। पायथन में खाली सूचियाँ यदि एक जाँच में झूठी का मूल्यांकन करती हैं। सिर्फ़ कहते हैं

if list:

इसके अतिरिक्त, आरक्षित शब्दों के साथ ओवरलैप होने वाले चर को असाइन करना एक बहुत बुरा विचार है। "सूची" पायथन में एक आरक्षित शब्द है।

तो चलिए उसको बदलते हैं

some_list = get_list()
if some_list:

वास्तव में एक महत्वपूर्ण बिंदु यह है कि यहाँ बहुत सारे समाधान याद आते हैं कि सभी पायथन कार्य / तरीके डिफ़ॉल्ट रूप से कोई भी नहीं लौटाते हैं । नीचे दिए गए प्रयास करें।

def does_nothing():
    pass

foo = does_nothing()
print foo

जब तक आपको किसी फ़ंक्शन को जल्दी समाप्त करने के लिए कोई भी लौटने की आवश्यकता नहीं है, यह स्पष्ट रूप से कोई भी वापस करने के लिए अनावश्यक है। पूरी तरह से, बस पहली प्रविष्टि लौटें, क्या यह मौजूद होना चाहिए।

some_list = get_list()
if some_list:
    return list[0]

और अंत में, शायद यह निहित था, लेकिन सिर्फ स्पष्ट होने के लिए (क्योंकि स्पष्ट अंतर्निहित से बेहतर है ), आपको अपने फ़ंक्शन को किसी अन्य फ़ंक्शन से सूची प्राप्त नहीं करनी चाहिए; बस इसे एक पैरामीटर के रूप में पास करें। तो, अंतिम परिणाम होगा

def get_first_item(some_list): 
    if some_list:
        return list[0]

my_list = get_list()
first_item = get_first_item(my_list)

जैसा कि मैंने कहा, ओपी लगभग वहाँ था, और बस कुछ स्पर्श इसे पायथन स्वाद देते हैं जिसे आप खोज रहे हैं।

Comments

अजगर में 'सूची' एक आरक्षित शब्द क्यों है? या, इस बिंदु पर अधिक, यह कहाँ कहता है कि 'सूची' अजगर में एक पुनर्जीवन शब्द है? या, इस बिंदु से अधिक, आपने यह कैसे सत्यापित किया कि 'सूची' अजगर में आरक्षित शब्द है? यह मानते हुए कि मैं 'सूची' नामक एक चर घोषित कर सकता हूं, यह स्पष्ट रूप से आरक्षित शब्द नहीं है।

— लास वी। कार्लसन

मुद्दा लेना। पायथन में वास्तव में आरक्षित शब्द यहां पाया जा सकता है smallurl.com/424663 हालांकि, यह बिल्टिन कार्यों और प्रकारों पर आरक्षित विचार करने के लिए एक अच्छा विचार है। सूची () वास्तव में एक सूची बनाता है। उसी के लिए चला जाता है

— तानाशाह

मैं अंतिम दो पंक्तियों को जोड़ूंगा, अस्थायी चर को हटा देगा (जब तक आपको my_list आगे की आवश्यकता नहीं है)। इससे पठनीयता में सुधार होता है।

— Svante

यह बहुत ज्यादा जवाब है जिसकी ओर मैं गुरुत्वाकर्षण था।

— रॉबर्ट रॉसनी

get_first_itemएक defaultपैरामीटर (जैसे dict.get) को स्वीकार करना चाहिए जो खुद को किसी के लिए नहीं चूकता है। इस प्रकार फ़ंक्शन इंटरफ़ेस स्पष्ट रूप से बताता है कि क्या होता है यदि my_listखाली है।

— रात 13:00

Answer 7

for item in get_list():
    return item

Comments

यह सक्सेसफुल और ब्यूटीफुल है।

— gotgenes

दुख की बात है, यह काम नहीं करता है; यदि कोई भी get_list () रिटर्न देता है, तो वह "TypeError: 'noneType' ऑब्जेक्ट इटेरेबल नहीं है।

— रॉबर्ट रॉसनी डिक

ठीक करने के लिए: "

— get_list

यह प्रश्न स्पष्ट रूप से get_list को एक सूची देता है। इसके परिणाम पर लेन और गेटिटेम को बुलाया जाता है।

— ए। कोदि

Answer 8

स्पष्ट रूप से, मुझे नहीं लगता कि एक बेहतर मुहावरा है: आपका स्पष्ट और स्पष्ट है - किसी भी चीज के लिए "बेहतर" की आवश्यकता नहीं है। हो सकता है, लेकिन यह वास्तव में स्वाद का मामला है, आप इसके if len(list) > 0:साथ बदल सकते हैं if list:- एक खाली सूची हमेशा गलत का मूल्यांकन करेगी।

एक संबंधित नोट पर, पायथन पेरल नहीं है (कोई भी इरादा नहीं है!), आपको सबसे अच्छे कोड प्राप्त करने की आवश्यकता नहीं है।
दरअसल, पायथन में मैंने जो सबसे खराब कोड देखा है, वह भी बहुत अच्छा था :-) और पूरी तरह से अप्राप्य।

वैसे, मैंने यहां देखा गया अधिकांश समाधान तब ध्यान में नहीं रखा जब सूची [0] झूठी (जैसे खाली स्ट्रिंग, या शून्य) का मूल्यांकन करती है - इस मामले में, वे सभी कोई भी नहीं लौटते हैं और सही तत्व नहीं।

Comments

पायथन में, इसके if lst:बजाय लिखने के लिए अच्छी शैली माना जाता है if len(lst) > 0:। इसके अलावा, चर नाम के रूप में पायथन कीवर्ड का उपयोग न करें; यह आँसू में समाप्त होता है। यह आम उपयोग करने के लिए Lया lstकुछ सूची के लिए चर नाम के रूप में। मुझे यकीन है कि इस मामले में आपको वास्तव listमें एक चर नाम के रूप में उपयोग करने का सुझाव देने का मतलब नहीं था , आपको बस "कुछ सूची" का मतलब था। और, +1 के लिए "जब lst [0] गलत मूल्यांकन करता है"।

— स्टीवेहा

हां, मैं केवल ओपी के नाम को बेहतर स्पष्टता के लिए बनाए रख रहा था। लेकिन आप निश्चित रूप से सही हैं: कुछ ध्यान हमेशा पायथन कीवर्ड को ओवरराइड नहीं करने के लिए लिया जाना चाहिए।

— लूटने

Answer 9

पहला आइटम वापस करने के लिए पायथन मुहावरे या कोई नहीं?

सबसे पाइथोनिक दृष्टिकोण वह है जो सबसे उत्कट उत्तर प्रदर्शित करता है, और जब मैंने प्रश्न पढ़ा तो मेरे दिमाग में यह पहली बात आई। यहां इसका उपयोग करने का तरीका बताया गया है, यदि संभवत: खाली सूची को एक समारोह में पारित किया जाता है:

def get_first(l): 
    return l[0] if l else None

और अगर सूची एक get_listसमारोह से वापस आ गई है :

l = get_list()
return l[0] if l else None

अन्य तरीकों ने यहां ऐसा करने के लिए प्रदर्शन किया, स्पष्टीकरण के साथ

for

जब मैंने ऐसा करने के लिए चतुर तरीकों के बारे में सोचना शुरू किया, तो यह दूसरी बात है जो मैंने सोचा था:

for item in get_list():
    return item

यह मानकर चलता है कि समारोह समाप्त हो गया है, Noneयदि get_listखाली सूची लौटाती है , तो स्पष्ट रूप से वापस आ जाएगी । नीचे स्पष्ट कोड बिल्कुल बराबर है:

for item in get_list():
    return item
return None

if some_list

निम्नलिखित भी प्रस्तावित किया गया था (मैंने गलत चर नाम को सही किया था) जो निहित का भी उपयोग करता है None। यह उपर्युक्त के लिए बेहतर होगा, क्योंकि यह एक पुनरावृत्ति के बजाय तार्किक जांच का उपयोग करता है जो कि नहीं हो सकता है। यह समझना आसान होना चाहिए कि क्या हो रहा है। लेकिन अगर हम पठनीयता और स्थिरता के लिए लिख रहे हैं, तो हमें return Noneअंत में स्पष्ट जोड़ना चाहिए :

some_list = get_list()
if some_list:
    return some_list[0]

स्लाइस or [None]और शून्य सूचकांक का चयन करें

यह सबसे ज्यादा वोट देने वाले उत्तर में भी है:

return (get_list()[:1] or [None])[0]

टुकड़ा अनावश्यक है, और स्मृति में एक अतिरिक्त एक आइटम सूची बनाता है। निम्नलिखित अधिक प्रदर्शन करने वाला होना चाहिए। समझाने के लिए, orदूसरा तत्व लौटाता है यदि पहला Falseबूलियन संदर्भ में है, इसलिए यदि get_listकोई खाली सूची देता है , तो कोष्ठक में निहित अभिव्यक्ति 'कोई नहीं' के साथ एक सूची लौटाएगा, जो तब 0सूचकांक द्वारा एक्सेस की जाएगी :

return (get_list() or [None])[0]

अगला व्यक्ति इस तथ्य का उपयोग करता है कि अगर दूसरा Trueबूलियन संदर्भ में है और दूसरा आइटम लौटाता है , और चूंकि यह दो बार my_list को संदर्भित करता है, तो यह टर्नरी अभिव्यक्ति (और तकनीकी रूप से एक-लाइनर नहीं) से बेहतर है:

my_list = get_list() 
return (my_list and my_list[0]) or None

next

फिर हमारे पास बिलिन के निम्नलिखित चतुर उपयोग हैं nextऔरiter

return next(iter(get_list()), None)

समझाने के लिए, iterएक .nextविधि के साथ एक पुनरावृत्ति देता है । ( .__next__पायथन 3. में) तब बिलिन nextउस .nextविधि को कॉल करता है, और यदि पुनरावृत्ति समाप्त हो जाती है, तो हम जो डिफ़ॉल्ट देते हैं, उसे वापस करता है None।

निरर्थक टर्नरी अभिव्यक्ति ( a if b else c) और वापस चक्कर

नीचे प्रस्तावित किया गया था, लेकिन व्युत्क्रम बेहतर होगा, क्योंकि तर्क को आमतौर पर नकारात्मक के बजाय सकारात्मक में समझा जाता है। चूंकि get_listदो बार कहा जाता है, जब तक कि परिणाम किसी तरह से याद नहीं किया जाता है, यह खराब प्रदर्शन करेगा:

return None if not get_list() else get_list()[0]

बेहतर उलटा:

return get_list()[0] if get_list() else None

इससे भी बेहतर, एक स्थानीय चर का उपयोग करें, get_listजिसे केवल एक समय कहा जाता है, और आपके पास पहले अनुशंसित पायथोनिक समाधान है:

l = get_list()
return l[0] if l else None

Answer 10

मुहावरों के संबंध में, एक इटर्टूलस नुस्खा कहा जाता है nth।

Itertools व्यंजनों से:

def nth(iterable, n, default=None):
    "Returns the nth item or a default value"
    return next(islice(iterable, n, None), default)

यदि आप एक-लाइनर चाहते हैं, तो एक पुस्तकालय स्थापित करने पर विचार करें जो आपके लिए यह नुस्खा लागू करता है, जैसे more_itertools:

import more_itertools as mit

mit.nth([3, 2, 1], 0)
# 3

mit.nth([], 0)                                             # default is `None`
# None

एक और उपकरण उपलब्ध है जो केवल पहले आइटम को लौटाता है, जिसे कहा जाता है more_itertools.first।

mit.first([3, 2, 1])
# 3

mit.first([], default=None)
# None

न केवल सूचियों के लिए, बल्कि किसी भी पुनरावृत्ति के लिए ये पुनरावृत्त पैमाने उदारतापूर्वक हैं।

Answer 11

my_list[0] if len(my_list) else None

Comments

आप lenबिना किसी कारण के उपयोग करते हैं। यदि आप इसे हटाना चाहते थे तो उपरोक्त कोड भी यही काम करेगा।

— डैनियल मोस्कोविच

Answer 12

जिज्ञासा से बाहर, मैं समाधान के दो पर समय चला गया। जो समाधान समय से पहले लूप के लिए रिटर्न स्टेटमेंट का उपयोग करता है, वह पायथन 2.5.1 के साथ मेरी मशीन पर थोड़ा अधिक महंगा है, मुझे संदेह है कि इसे चलने योग्य स्थापित करने के साथ क्या करना है।

import random
import timeit

def index_first_item(some_list):
    if some_list:
        return some_list[0]


def return_first_item(some_list):
    for item in some_list:
        return item


empty_lists = []
for i in range(10000):
    empty_lists.append([])

assert empty_lists[0] is not empty_lists[1]

full_lists = []
for i in range(10000):
    full_lists.append(list([random.random() for i in range(10)]))

mixed_lists = empty_lists[:50000] + full_lists[:50000]
random.shuffle(mixed_lists)

if __name__ == '__main__':
    ENV = 'import firstitem'
    test_data = ('empty_lists', 'full_lists', 'mixed_lists')
    funcs = ('index_first_item', 'return_first_item')
    for data in test_data:
        print "%s:" % data
        for func in funcs:
            t = timeit.Timer('firstitem.%s(firstitem.%s)' % (
                func, data), ENV)
            times = t.repeat()
            avg_time = sum(times) / len(times)
            print "  %s:" % func
            for time in times:
                print "    %f seconds" % time
            print "    %f seconds avg." % avg_time

ये वो समय हैं जो मुझे मिले:

empty_lists:
  index_first_item:
    0.748353 सेकंड
    0.741086 सेकंड
    0.741191 सेकंड
    0.743543 सेकंड avg।
  return_first_item:
    0.785511 सेकंड
    0.822178 सेकंड
    0.782846 सेकंड
    0.796845 सेकंड avg।
full_lists:
  index_first_item:
    0.762618 सेकंड
    0.788040 सेकंड
    0.786849 सेकंड
    0.779169 सेकंड avg।
  return_first_item:
    0.802735 सेकंड
    0.878706 सेकंड
    0.808781 सेकंड
    0.830074 सेकंड avg।
mixed_lists:
  index_first_item:
    0.791129 सेकंड
    0.743526 सेकंड
    0.744441 सेकंड
    0.759699 सेकंड avg।
  return_first_item:
    0.784801 सेकंड
    0.785146 सेकंड
    0.840193 सेकंड
    0.803380 सेकंड avg।

Answer 13

try:
    return a[0]
except IndexError:
    return None

Comments

अपवाद आमतौर पर प्रवाह नियंत्रण के लिए उपयोग नहीं किए जाते हैं।

— मैट ग्रीन

मुझे नहीं लगता कि यह कोड अधिक लंबा है और इसमें अपवाद-हैंडलिंग जोड़ना बिल्कुल उसी मुहावरे की तलाश है जिसे मैं खोज रहा था।

— रॉबर्ट रॉसनी

लेकिन यह एक सामान्य अजगर मुहावरा है! प्रदर्शन कारणों से, आप इसका उपयोग नहीं कर सकते हैं; आपको बेहतर प्रदर्शन मिलेगा if len(a) > 0:लेकिन यह अच्छी शैली मानी जाती है। ध्यान दें कि यह समस्या कितनी अच्छी तरह व्यक्त करता है: "एक सूची के प्रमुख को निकालने की कोशिश करें, और यदि वह काम नहीं करता है, तो वापस लौटें None"। "ईएएफपी" के लिए Google खोज या यहां देखें: python.net/~goodger/projects/pycon/2007/idiomatic/…

— स्टीवेहा

@steveha यह आपके डेटा पर निर्भर करता है। अगर len (a) आमतौर पर> 0 है और len (a) <1 एक दुर्लभ स्थिति है, तो अपवाद को पकड़ना वास्तव में अधिक महत्वपूर्ण होगा।

— limscoder

@SMcoder, मैं आपसे सहमत हूँ। जब आप प्रदर्शन कारणों से इसका उपयोग नहीं कर सकते हैं , तो मैं अभी इसके विवरण में नहीं आया हूं ; मैंने यह नहीं कहा कि आप इसका उपयोग कभी नहीं करेंगे।

— स्टीवेहा

Answer 14

def head(iterable):
    try:
        return iter(iterable).next()
    except StopIteration:
        return None

print head(xrange(42, 1000)  # 42
print head([])               # None

BTW: मैं इस तरह से अपने सामान्य कार्यक्रम के प्रवाह को फिर से काम करूँगा:

lists = [
    ["first", "list"],
    ["second", "list"],
    ["third", "list"]
]

def do_something(element):
    if not element:
        return
    else:
        # do something
        pass

for li in lists:
    do_something(head(li))

(जब भी संभव हो पुनरावृत्ति से बचना)

Answer 15

इस बारे में कैसा है:

(my_list and my_list[0]) or None

नोट: यह वस्तुओं की सूचियों के लिए ठीक काम करना चाहिए, लेकिन यह नीचे दिए गए टिप्पणियों के अनुसार संख्या या स्ट्रिंग सूची के मामले में गलत उत्तर दे सकता है।

Comments

इसके बारे में क्या ([0,1] and 0) or None?

— केली

यह एक अच्छा बिंदु है ... मौजूदा रूप में संख्या संग्रह के साथ उपयोग करने के लिए असुरक्षित :(

— विटाली बी

साथ ही बात (['','A'] and '') or None।

— केली

यदि के my_list[0]रूप में मूल्यांकन किया जाता है False, तो परिणाम होना चाहिए None।

— केनली

my_list[0] if len(my_list) else None

— निकोलस हैमिल्टन

Answer 16

पाइथोनिक यह कैसे है यह सुनिश्चित नहीं है, लेकिन जब तक पुस्तकालय में पहला कार्य नहीं होता है, तब तक मैं इसे स्रोत में शामिल करता हूं:

first = lambda l, default=None: next(iter(l or []), default)

यह सिर्फ एक लाइन है (काले रंग के अनुरूप) और निर्भरता से बचा जाता है।

Answer 17

और-या चाल का उपयोग करना:

a = get_list()
return a and a[0] or None

Answer 18

संभवतः सबसे तेज़ समाधान नहीं है, लेकिन किसी ने भी इस विकल्प का उल्लेख नहीं किया है:

dict(enumerate(get_list())).get(0)

यदि get_list()आप वापस आ सकते हैं Noneतो आप इसका उपयोग कर सकते हैं:

dict(enumerate(get_list() or [])).get(0)

लाभ:

-एक पंक्ति

-तुम बस get_list()एक बार फोन करो

-समझने में आसान

Answer 19

मेरा उपयोग मामला केवल स्थानीय चर का मान सेट करने के लिए था।

व्यक्तिगत रूप से मैंने कोशिश की और स्टाइल क्लीनर को छोड़कर पढ़ने के लिए मिला

items = [10, 20]
try: first_item = items[0]
except IndexError: first_item = None
print first_item

एक सूची को काटने से।

items = [10, 20]
first_item = (items[:1] or [None, ])[0]
print first_item

Answer 20

कई लोगों ने कुछ ऐसा करने का सुझाव दिया है:

list = get_list()
return list and list[0] or None

यह कई मामलों में काम करता है, लेकिन यह केवल तभी काम करेगा जब सूची [0] 0 के बराबर नहीं है, गलत है, या एक खाली स्ट्रिंग है। यदि सूची [0] 0 है, गलत है, या एक रिक्त स्ट्रिंग है, तो विधि गलत तरीके से कोई भी नहीं लौटेगी।

मैंने कई बार अपने स्वयं के कोड में इस बग को बनाया है!

Comments

यह एक स्टैंड-अलोन जवाब के बजाय त्रुटिपूर्ण उत्तर के तहत एक टिप्पणी होनी चाहिए।

— IJ कैनेडी

Answer 21

आप एक्सट्रैक्ट मेथड का उपयोग कर सकते हैं । दूसरे शब्दों में उस कोड को एक विधि में निकालें, जिसे आप फिर कॉल करेंगे।

मैं इसे और अधिक संपीड़ित करने की कोशिश नहीं करूंगा, एक लाइनर वर्बोज़ संस्करण की तुलना में पढ़ने में कठिन लगता है। और यदि आप एक्सट्रैक्ट विधि का उपयोग करते हैं, तो यह एक लाइनर है;)

Answer 22

if mylist != []:

       print(mylist[0])

   else:

       print(None)

Answer 23

मुहावरेदार अजगर नहीं है, जो सी-शैली के टर्नरी ऑपरेटरों के बराबर है

cond and true_expr or false_expr

अर्थात।

list = get_list()
return list and list[0] or None

Comments

यदि एक [0] संख्या 0 या खाली स्ट्रिंग (या कुछ और जो झूठी का मूल्यांकन करता है) है, तो यह वास्तव में जो भी है उसके बजाय कोई नहीं लौटाएगा।

— एडम रोसेनफील्ड