software - python tutorial pdf




जबकि(1) बनाम। जबकि(सच)-एक अंतर क्यों है? (2)

पर्ल में अनंत लूप के बारे में इस सवाल से चिंतित: जबकि (1) बनाम। के लिए (;;) क्या कोई गति अंतर है? , मैंने पायथन में एक समान तुलना चलाने का फैसला किया। मुझे उम्मीद थी कि संकलक वही बाइट कोड उत्पन्न करेगा while(True): pass और while(1): pass , लेकिन यह वास्तव में Python2.7 में मामला नहीं है।

निम्नलिखित लिपि:

import dis

def while_one():
    while 1:
        pass

def while_true():
    while True:
        pass

print("while 1")
print("----------------------------")
dis.dis(while_one)

print("while True")
print("----------------------------")
dis.dis(while_true)

निम्नलिखित परिणाम उत्पन्न करता है:

while 1
----------------------------
  4           0 SETUP_LOOP               3 (to 6)

  5     >>    3 JUMP_ABSOLUTE            3
        >>    6 LOAD_CONST               0 (None)
              9 RETURN_VALUE        
while True
----------------------------
  8           0 SETUP_LOOP              12 (to 15)
        >>    3 LOAD_GLOBAL              0 (True)
              6 JUMP_IF_FALSE            4 (to 13)
              9 POP_TOP             

  9          10 JUMP_ABSOLUTE            3
        >>   13 POP_TOP             
             14 POP_BLOCK           
        >>   15 LOAD_CONST               0 (None)
             18 RETURN_VALUE        

while True उपयोग करना अधिक जटिल है। ऐसा क्यों है?

अन्य संदर्भों में, अजगर कार्य करता है जैसे कि True बराबर 1:

>>> True == 1
True

>>> True + True
2

दोनों while अलग while क्यों?

मैंने देखा कि Python3 समान संचालन का उपयोग कर बयानों का मूल्यांकन करता है:

while 1
----------------------------
  4           0 SETUP_LOOP               3 (to 6) 

  5     >>    3 JUMP_ABSOLUTE            3 
        >>    6 LOAD_CONST               0 (None) 
              9 RETURN_VALUE         
while True
----------------------------
  8           0 SETUP_LOOP               3 (to 6) 

  9     >>    3 JUMP_ABSOLUTE            3 
        >>    6 LOAD_CONST               0 (None) 
              9 RETURN_VALUE         

क्या पुलोन 3 में बूलियन का मूल्यांकन किया जाता है?


पायथन 2.x में, True एक कीवर्ड नहीं है, लेकिन केवल एक अंतर्निहित वैश्विक स्थिर है जिसे bool प्रकार में 1 में परिभाषित किया गया है। इसलिए दुभाषिया को अभी भी True की सामग्री लोड करना है। दूसरे शब्दों में, True पुन: असाइन करने योग्य है:

Python 2.7 (r27:82508, Jul  3 2010, 21:12:11) 
[GCC 4.0.1 (Apple Inc. build 5493)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> True = 4
>>> True
4

पायथन 3.x में यह वास्तव में एक कीवर्ड और वास्तविक स्थिर बन जाता है :

Python 3.1.2 (r312:79147, Jul 19 2010, 21:03:37) 
[GCC 4.2.1 (Apple Inc. build 5664)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> True = 4
  File "<stdin>", line 1
SyntaxError: assignment to keyword

इस प्रकार दुभाषिया while True: को प्रतिस्थापित कर सकता है while True: एक अनंत लूप के साथ लूप।


यह एक 7 साल का सवाल है कि पहले से ही एक अच्छा जवाब है, लेकिन सवाल में एक गलतफहमी, जिसे किसी भी उत्तर में संबोधित नहीं किया गया है, यह डुप्लिकेट के रूप में चिह्नित कुछ अन्य प्रश्नों के लिए संभावित रूप से भ्रमित हो जाता है।

अन्य संदर्भों में, अजगर कार्य करता है जैसे कि सत्य बराबर 1:

>>> True == 1
True

>>> True + True
2

दोनों को अलग करते समय क्यों?

वास्तव में, यहां कुछ भी अलग नहीं कर रहा है। यह 1 को True और ठीक उसी तरह से सही होता है जैसे + उदाहरण करता है।

यहां 2.7 है:

>>> dis.dis('True == 1')
  1           0 LOAD_GLOBAL              0 (True)
              3 LOAD_CONST               1 (1)
              6 COMPARE_OP               2 (==)
              9 RETURN_VALUE

>>> dis.dis('True == 1')
  1           0 LOAD_GLOBAL              0 (True)
              3 LOAD_GLOBAL              0 (True)
              6 BINARY_ADD
              9 RETURN_VALUE

अब तुलना करें:

>>> dis.dis('1 + 1')
  1           0 LOAD_CONST               1 (2)
              3 RETURN_VALUE

यह प्रत्येक True लिए LOAD_GLOBAL (True) उत्सर्जित कर रहा है, और कुछ भी नहीं है जो ऑप्टिमाइज़र वैश्विक के साथ कर सकता है। इसलिए, वही सही कारण के लिए 1 और True है जो करता है + करता है। (और == उन्हें अलग नहीं करता है क्योंकि अनुकूलक तुलना को अनुकूलित नहीं करता है।)

अब 3.6 की तुलना करें:

>>> dis.dis('True == 1')
  1           0 LOAD_CONST               0 (True)
              2 LOAD_CONST               1 (1)
              4 COMPARE_OP               2 (==)
              6 RETURN_VALUE

>>> dis.dis('True + True')
  1           0 LOAD_CONST               1 (2)
              2 RETURN_VALUE

यहां, यह कीवर्ड के लिए LOAD_CONST (True) उत्सर्जित कर रहा है, जिसे ऑप्टिमाइज़र का लाभ उठा सकता है। तो, True + 1 नहीं है, वही कारण है while True नहीं है। (और == अभी भी उन्हें अलग नहीं करता है क्योंकि अनुकूलक तुलना को अनुकूलित नहीं करता है।)

इस बीच, यदि कोड अनुकूलित नहीं किया गया है, तो दुभाषिया True इलाज कर रहा है और 1 इन तीनों मामलों में बिल्कुल वही है। bool int उप-वर्ग है, और int से इसकी अधिकांश विधियों को प्राप्त करता है, और True का आंतरिक पूर्णांक मान 1 है। तो, चाहे आप while परीक्षण कर रहे हों (3.x में __nonzero__ , 2.x में __nonzero__ ), एक तुलना ( __eq__ ), या अंकगणित ( __add__ ), आप एक ही विधि को बुला रहे हैं चाहे आप True या 1 उपयोग करें।







python