क्या मुझे एलिफ का उपयोग करना चाहिए यदि मैं पिछले ब्लॉक में फ़ंक्शन से पहले ही लौटा चुका हूं?

Question

def size(number): 
    if number<100: 
     return Small() 

    if number<1000: 
     return Medium() 

    return Big() 

def size1(number): 
    if number<100: 
     return Small() 
    elif number<1000: 
     return Medium() 
    else: 
     return Big() 

कोडिंग शैली के संबंध में: मैं अक्सर पूर्व का उपयोग करता हूं जब निम्न ब्लॉक, या अंतिम ब्लॉक कोड का एक बड़ा हिस्सा है। यह पठनीयता में मदद करता है।

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

क्या इन दो मूल्यवान नोटिंग (एएसपी प्रदर्शन के अनुसार) के बीच कोई अंतर है?

Answer 1

स्टाइल-वार, मुझे आंख पर दूसरा उदाहरण आसान लगता है।

अन्य सभी मामलों में, कोई अंतर नहीं है। दो कार्य समान bytecodes के संकलन:

In [3]: dis.dis(size) 
    2   0 LOAD_FAST    0 (number) 
       3 LOAD_CONST    1 (100) 
       6 COMPARE_OP    0 (<) 
       9 POP_JUMP_IF_FALSE  19 

    3   12 LOAD_GLOBAL    0 (Small) 
      15 CALL_FUNCTION   0 
      18 RETURN_VALUE   

    5  >> 19 LOAD_FAST    0 (number) 
      22 LOAD_CONST    2 (1000) 
      25 COMPARE_OP    0 (<) 
      28 POP_JUMP_IF_FALSE  38 

    6   31 LOAD_GLOBAL    1 (Medium) 
      34 CALL_FUNCTION   0 
      37 RETURN_VALUE   

    8  >> 38 LOAD_GLOBAL    2 (Big) 
      41 CALL_FUNCTION   0 
      44 RETURN_VALUE   

In [4]: dis.dis(size1) 
11   0 LOAD_FAST    0 (number) 
       3 LOAD_CONST    1 (100) 
       6 COMPARE_OP    0 (<) 
       9 POP_JUMP_IF_FALSE  19 

12   12 LOAD_GLOBAL    0 (Small) 
      15 CALL_FUNCTION   0 
      18 RETURN_VALUE   

13  >> 19 LOAD_FAST    0 (number) 
      22 LOAD_CONST    2 (1000) 
      25 COMPARE_OP    0 (<) 
      28 POP_JUMP_IF_FALSE  38 

14   31 LOAD_GLOBAL    1 (Medium) 
      34 CALL_FUNCTION   0 
      37 RETURN_VALUE   

16  >> 38 LOAD_GLOBAL    2 (Big) 
      41 CALL_FUNCTION   0 
      44 RETURN_VALUE   
      45 LOAD_CONST    0 (None) 
      48 RETURN_VALUE   

(। 100% सही, दूसरा संस्करण अंत में एक अंतर्निहित return None है होना करने के लिए हालांकि, बाद से इस कोड को पहुंच योग्य नहीं है, यह प्रदर्शन को प्रभावित नहीं करेगा।)

Answer 2

आप केवल बेंचमार्किंग/समय (या @aix शो के रूप में, एक विशेष मामले के प्रदर्शन के बारे में जानते हैं, अनुवाद कोड को देखते हुए, कोड सेगमेंट पर्याप्त रूप से छोटा है)।

ऐसा कहकर, मुझे लगता है कि दूसरे उदाहरण के अर्थशास्त्र स्पष्ट हैं क्योंकि भाषा निर्माण से पता चलता है कि विकल्प पारस्परिक रूप से अनन्य हैं।

सामान्य तौर पर, एक ही कार्यक्षमता को देखते हुए एक if/elif/else खंड if -statement जहां कई if बयान निष्पादित किया जा सकता/अनुक्रम में मूल्यांकन किया है, भले ही पिछले एक if सच होना पाया गया है की एक श्रृंखला से अधिक कुशल होना चाहिए। इस विशिष्ट कोड उदाहरण में यह मामला नहीं है क्योंकि को if कथन के उचित निकाय के रूप में निष्पादित किया गया है।