ट्विस्टेड Deferred.addCallBack() बनाम उपज और @inlineDeferred

Question

क्या किसी दूसरे का उपयोग करने का कोई कारण है?

क्या उनके पास समान प्रदर्शन है?

Answer 1

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

@defer.inlineCallbacks 
def some_func(): 
    res1 = yield call1() 
    res2 = yield call2() 
    ... do something with res1 and res2 ... 

call1 हैं और call2, इस समारोह खत्म हो जाएगा serializing उन कॉल:

यहाँ एक उदाहरण है। एक parallelizing में बदलने के लिए फोन आपको:

@defer.inlineCallbacks 
def some_func_better(): 
    d1 = call1() 
    d2 = call2() 
    res1 = yield d1 
    res2 = yield d2 

इस तरह आप call1 हो और एक साथ चल call2, लेकिन आप परिणामों पर इंतजार आते ही उन्हें तो, जबकि इससे बाहर ही लाभ पाने के लिए संभव है। स्टॉक स्थगित, ऐसा लगता है कि inlineCallbacks बस पूर्व समाधान को लागू करना बहुत आसान बना देता है।

इसके अलावा, ध्यान रखें कि आपको अभी भी अपने सभी उपज कॉलों के आसपास try...except ब्लॉक लपेटना है, क्योंकि वे आपके कोड में त्रुटियों को फँसाने का एकमात्र तरीका हैं (जब तक inlineCallbacks फ़ंक्शन का कॉलिंग फ़ंक्शन उस पर त्रुटि को संभालता है स्तर)।

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

Answer 2

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

संपादित करें: यदि आप वास्तव में जानना चाहते हैं, तो यह पता चलता है कि यह कैसे पता चलता है (यह सब कुछ आपके पाइथन संस्करण के लिए कार्यान्वित हो सकता है): दोनों संस्करण को एक तंग लूप में चलाएं और समय को मापें। लूप गिनती बढ़ाएं जब तक कि संस्करणों के बीच का समय अंतर कई रनों में एक ही संस्करण के समय भिन्नता से कहीं अधिक न हो। पाइथन संस्करण, ओएस इत्यादि बदलने के बाद दोहराएं

Answer 3

उपयोग defer.inlineCallbacks .. अपने कोड easiler को पढ़ने के लिए कर सकते हैं

और यह किसी भी तरह corountine शैली की तरह: आप न तो कॉल को ब्लॉक और न ही कॉलबैक की श्रृंखला का उपयोग पूरे तर्क का निर्माण। यह सहज है।