अजगर कई वापसी मूल्य पर ध्यान न दें

Question

कहो मेरे पास एक पायथन फ़ंक्शन है जो एक टपल में कई मान लौटाता है:

def func():
    return 1, 2

क्या एक अस्थायी चर को निर्दिष्ट करने के बजाय परिणामों में से एक को अनदेखा करने का एक अच्छा तरीका है? कहो कि क्या मुझे केवल पहले मूल्य में दिलचस्पी थी, क्या इससे बेहतर तरीका है:

x, temp = func()

Comments

मुझे भी इस बात की उत्सुकता हुई कि मैटलैब के इग्नोर फंक्शन आउटपुट की ऐसी ही धारणा से आ रहा है जहाँ वे ~एक विशेष रिटर्न वैरिएबल को अनदेखा करने के लिए वाक्यविन्यास के रूप में उपयोग करते हैं

— jxramos

आपने गलत उत्तर को समाधान के रूप में चुना

— AGP

Answer 1

एक सामान्य सम्मेलन "_" का उपयोग करना है जिसे टुपल के तत्वों के लिए एक चर नाम के रूप में आप अनदेखा करना चाहते हैं। उदाहरण के लिए:

def f():
    return 1, 2, 3

_, _, x = f()

Comments

-1: यह "कन्वेंशन" तब बेकार हो जाता है जब आप किसी अन्य के कोड में गेटेक्स्ट कार्यक्षमता जोड़ते हैं (जो '_' नामक फ़ंक्शन को परिभाषित करता है) इसलिए इसे प्रतिबंधित किया जाना चाहिए

— nosklo

अच्छा बिंदु - हालांकि यह बहस का मुद्दा है कि क्या " " नामक एक फ़ंक्शन को स्थापित करने के लिए गेटटेक्स्ट का आग्रह अच्छा विचार है। व्यक्तिगत रूप से, मुझे यह थोड़ा बदसूरत लगता है। बावजूद, " " का एक प्रचलित चर के रूप में उपयोग व्यापक है।

— ब्रायन क्लैपर

-1: _ का मतलब IPython में "अंतिम आउटपुट" है। मैं इसे कभी कुछ असाइन नहीं करूंगा।

— एंडोलिथ

ठीक है, मैंने "मैं" नोटिस नहीं किया - संदर्भ के लिए धन्यवाद। IMHO आप दूसरों से एक चर का उपयोग न करने की उम्मीद नहीं कर सकते हैं क्योंकि एक पायथन ऐप इसके लिए अपने जादुई उपयोग को परिभाषित करता है।

— ड्रेमन

कुछ IDEs जैसे PyDev आपको इस पर चेतावनी देगा, क्योंकि आपके पास अप्रयुक्त चर हैं।

— teeks99

Answer 2

आप x = func()[0]पहले मूल्य को वापस करने के लिए उपयोग कर सकते हैं , x = func()[1]दूसरे को वापस करने के लिए, और इसी तरह।

यदि आप एक बार में कई मान प्राप्त करना चाहते हैं, तो कुछ का उपयोग करें x, y = func()[2:4]।

Comments

यह स्वीकृत उत्तर होना चाहिए। आप चीजों का उपयोग भी कर सकते हैं जैसे func()[2:4]कि आप केवल कुछ रिटर्न मान चाहते हैं।

— एंडोलिथ

यह फ़ंक्शन को कई बार कॉल नहीं करता है: >>> डिफ टेस्ट (): ... "यहां" प्रिंट करें ... 1,2,3 ... >>> ए, बी = टेस्ट () [: 2 ] यहाँ [संपादित करें: खेद है कि कोड के माध्यम से नहीं आया था, आप टिप्पणी में केवल एक लाइन प्राप्त करते हैं। उन लोगों के लिए जो परिचित नहीं हैं >>> और ... अजगर खोल में एक नई रेखा की शुरुआत है]

— Teeks99

@ टायलरलॉन्ग: मुझे लगता _, _, _, _, _, _, _, _, _, _, _, _, _, a, _, _, _, _, _, _, _, _, _, _, _, b, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, c, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, d, _, _, _, _, _, _, _, _, e, _ = func()है कि फ़ंक्शन को कई बार कॉल करने से कम स्पष्ट है, लेकिन यह सिर्फ मेरी राय है। यदि आपका समारोह रिटर्न कई मदों, मैं numpy का उपयोग कर बेहतर होगा लगता है कि:a, b, c, d, e = func()[[13, 25, 58, 89, 98]]

— endolith

@endolith मुझे लगता है कि यह बेहतर है और इसके लिए सुन्न की जरूरत नहीं है और कई बार func () को कॉल करने की आवश्यकता नहीं है: result = func() a = result[13] b = result[25]...

— Tyler Long

जब आप बीच में एक या कुछ मूल्यों को अनदेखा करना चाहते हैं तो यह शैली अच्छी नहीं है, जैसेx, __, y = func()

— ndemou

Answer 3

यदि आप पायथन 3 का उपयोग कर रहे हैं, तो आप इसे अनपैकिंग में सूची में रखने के लिए एक चर (असाइनमेंट के बाईं ओर) से पहले स्टार का उपयोग कर सकते हैं।

# Example 1: a is 1 and b is [2, 3]

a, *b = [1, 2, 3]

# Example 2: a is 1, b is [2, 3], and c is 4

a, *b, c = [1, 2, 3, 4]

# Example 3: b is [1, 2] and c is 3

*b, c = [1, 2, 3]       

# Example 4: a is 1 and b is []

a, *b = [1]

Comments

आप a, *_ = f()बाद में दिए गए मानों की मनमानी संख्या को अनदेखा करने के लिए भी उपयोग कर सकते हैं a।

— THN

Answer 4

याद रखें, जब आप एक से अधिक आइटम वापस करते हैं, तो आप वास्तव में एक टुपल लौटा रहे हैं। तो आप इस तरह की चीजें कर सकते हैं:

def func():
    return 1, 2

print func()[0] # prints 1
print func()[1] # prints 2

Answer 5

सामान्य अभ्यास डमी चर _(एकल अंडरस्कोर) का उपयोग करना है , जैसा कि कई पहले यहां संकेत कर चुके हैं।

हालाँकि, उस परिवर्तनशील नाम के अन्य उपयोगों ( इस प्रतिक्रिया को देखें ) के साथ टकराव से बचने के लिए यह __एक फेंकने योग्य चर के रूप में उपयोग करने के लिए (डबल अंडरस्कोर) एक बेहतर अभ्यास हो सकता है , जैसा कि ncoghlan द्वारा बताया गया है । उदाहरण के लिए:

x, __ = func()

Comments

ये बिलकुल बुरा ख़याल नहीं है। लेकिन तब '_ _' नाम स्थान में एक चर घोषित करेगा। जबकि, '_' तब तक घोषित नहीं करता है जब तक कि ऊपर दिए गए असाइनमेंट स्टेटमेंट के बायीं ओर विशेष रूप से उपयोग नहीं किया जाता है (जैसे:) a, _, _ = 1,8,9। उस बिंदु तक, यह निष्पादित अंतिम कथन के परिणाम को संग्रहीत करता है जिसे यदि आप पकड़ना चाहते हैं, तो आप सामान्य रूप से उस मूल्य को संग्रहीत करने के लिए एक चर का उपयोग करेंगे। और यही कारण है कि, '_' कबाड़ मूल्यों को पकड़ने के लिए सुझाया गया चर नाम है। किसी अन्य कथन के निष्पादित होने पर '_' मान जल्द ही अधिलेखित हो जाते हैं। '_ _' के मामले में, मान तब तक बना रहेगा जब तक कि GC इसे बंद नहीं कर देता।

— अर्चित कपूर

Answer 6

तीन सरल विकल्प।

ज़ाहिर

x, _ = func()

x, junk = func()

भयंकर

x = func()[0]

और एक डेकोरेटर के साथ ऐसा करने के तरीके हैं।

def val0( aFunc ):
    def pick0( *args, **kw ):
        return aFunc(*args,**kw)[0]
    return pick0

func0= val0(func)

Comments

मैं वास्तव में _चर को पसंद करता हूं । यह बहुत स्पष्ट है कि आप एक मूल्य की अनदेखी कर रहे हैं

— क्लाउडी

आपके उदाहरण पीछे की ओर हैं। x, _ = func()गुप्त है, और x = func()[0]स्पष्ट है। एक चर को असाइन करना और फिर इसका उपयोग नहीं करना? फ़ंक्शन एक टपल लौटा रहा है; इसे टपल की तरह अनुक्रमित करें।

— एंडोलिथ

पैटर्न मिलान भाषाओं में, जिसमें से पायथन ने इस पैटर्न को निकाला, 'स्पष्ट' विधि वास्तव में स्पष्ट है, न कि छिपी हुई और विहित। हालाँकि, ऐसी भाषाओं में वाइल्डकार्ड एक समर्थित भाषा विशेषता है जबकि पायथन में यह एक वास्तविक चर है और बाध्य हो जाता है, जो थोड़ा तिरछा है।

— जो

सूची प्रसंस्करण भाषाओं के लिए, जिसमें से पायथन व्युत्पन्न है ;), सूची एक्सेसर्स जैसे a[0], a[:](सूची प्रतिलिपि), a[::2](प्रत्येक दो तत्व), और a[i:] + a[:i](सूची को घुमाएं), वास्तव में, स्पष्ट और विहित भी हैं।

— Cod3monk3y

Answer 7

सबसे अच्छा उपाय शायद व्यर्थ की तुगलकी बातों को लौटाने के बजाय चीजों को नाम देना है। जब तक कि लौटी वस्तुओं के क्रम के पीछे कुछ तर्क नहीं है।

def func():
    return {'lat': 1, 'lng': 2}

latitude = func()['lat']

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

from collections import namedtuple 

Coordinates = namedtuple('Coordinates', ['lat', 'lng'])

def func():
    return Coordinates(lat=1, lng=2)

latitude = func().lat

यदि आपके शब्दकोश / टपल के भीतर की वस्तुएँ दृढ़ता से एक साथ बंधी हुई हैं, तो इसके लिए एक वर्ग को परिभाषित करना भी एक अच्छा विचार हो सकता है। इस तरह आप इस प्रकार की वस्तुओं के बीच परस्पर क्रिया को भी परिभाषित कर पाएंगे और उनके साथ काम करने के तरीके के बारे में एक एपीआई दे पाएंगे। एक प्राकृतिक प्रश्न जो इस प्रकार है: मुझे पायथन में कक्षाओं का उपयोग कब करना चाहिए? ।

Answer 8

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

val1, val2, ignored1, ignored2 = some_function()

यह गुप्त या बदसूरत नहीं है (जैसे कि फंक () [सूचकांक] विधि), और स्पष्ट रूप से आपके उद्देश्य को बताता है।

Answer 9

यह सवाल का सीधा जवाब नहीं है। बल्कि यह इस सवाल का जवाब देता है: "मैं कई संभावित विकल्पों में से एक विशिष्ट फ़ंक्शन आउटपुट कैसे चुनूं?"।

यदि आप फ़ंक्शन को लिखने में सक्षम हैं (यानी, यह उस लाइब्रेरी में नहीं है जिसे आप संशोधित नहीं कर सकते हैं), तो एक इनपुट तर्क जोड़ें जो इंगित करता है कि आप फ़ंक्शन से बाहर क्या चाहते हैं। इसे "सामान्य स्थिति" में डिफ़ॉल्ट मान के साथ नामांकित तर्क दें, आपको इसे निर्दिष्ट करने की आवश्यकता नहीं है।

    def fancy_function( arg1, arg2, return_type=1 ):
        ret_val = None
        if( 1 == return_type ):
            ret_val = arg1 + arg2
        elif( 2 == return_type ):
            ret_val = [ arg1, arg2, arg1 * arg2 ]
        else:
            ret_val = ( arg1, arg2, arg1 + arg2, arg1 * arg2 ) 
        return( ret_val )

यह विधि वांछित आउटपुट के संबंध में फ़ंक्शन "उन्नत चेतावनी" देती है। नतीजतन यह अनावश्यक प्रसंस्करण को छोड़ सकता है और केवल अपना वांछित उत्पादन प्राप्त करने के लिए आवश्यक कार्य कर सकता है। इसके अलावा क्योंकि पायथन डायनामिक टाइपिंग करता है, रिटर्न प्रकार बदल सकता है। ध्यान दें कि उदाहरण कैसे एक स्केलर, एक सूची या टपल देता है ... जो भी आपको पसंद है!

Answer 10

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

def func():
    return 1, 2

func_ = lambda: func()[0] 

func_()  # Prints 1 

Answer 11

जब आपके पास किसी फ़ंक्शन से कई आउटपुट होते हैं और आप इसे कई बार कॉल नहीं करना चाहते हैं, तो मुझे लगता है कि परिणाम चुनने का सबसे स्पष्ट तरीका होगा:

results = fct()
a,b = [results[i] for i in list_of_index]

एक न्यूनतम कार्य उदाहरण के रूप में, यह प्रदर्शित करना कि फ़ंक्शन केवल एक बार कहा जाता है:

def fct(a):
    b=a*2
    c=a+2
    d=a+b
    e=b*2
    f=a*a
    print("fct called")
    return[a,b,c,d,e,f]

results=fct(3)
> fct called

x,y = [results[i] for i in [1,4]]

और मान अपेक्षित हैं:

results
> [3,6,5,9,12,9]
x
> 6
y
> 12

सुविधा के लिए, पायथन सूची अनुक्रमित का भी उपयोग किया जा सकता है:

x,y = [results[i] for i in [0,-2]]

रिटर्न: एक = 3 और बी = 12