अजगर: * और ** / और sqrt () से अधिक तेज़ क्यों हैं?

Question 1

अपने कोड का अनुकूलन करते समय मुझे निम्नलिखित का एहसास हुआ:

>>> from timeit import Timer as T
>>> T(lambda : 1234567890 / 4.0).repeat()
[0.22256922721862793, 0.20560789108276367, 0.20530295372009277]
>>> from __future__ import division
>>> T(lambda : 1234567890 / 4).repeat()
[0.14969301223754883, 0.14155197143554688, 0.14141488075256348]
>>> T(lambda : 1234567890 * 0.25).repeat()
[0.13619112968444824, 0.1281130313873291, 0.12830305099487305]

और भी:

>>> from math import sqrt
>>> T(lambda : sqrt(1234567890)).repeat()
[0.2597470283508301, 0.2498021125793457, 0.24994492530822754]
>>> T(lambda : 1234567890 ** 0.5).repeat()
[0.15409398078918457, 0.14059877395629883, 0.14049601554870605]

मुझे लगता है कि यह सी में अजगर को लागू करने के तरीके के साथ करना है, लेकिन मुझे आश्चर्य है कि अगर कोई यह समझाने की परवाह करेगा कि ऐसा क्यों है?

Question 2

आपके परिणामों के लिए (कुछ अप्रत्याशित) कारण यह है कि पायथन फ्लोटिंग-पॉइंट गुणा और घातांक को शामिल करने वाले निरंतर अभिव्यक्तियों को मोड़ना लगता है, लेकिन विभाजन नहीं। math.sqrt()पूरी तरह से एक अलग जानवर है क्योंकि इसके लिए कोई बायटेकोड नहीं है और इसमें एक फ़ंक्शन कॉल शामिल है।

पायथन 2.6.5 पर, निम्न कोड:

x1 = 1234567890.0 / 4.0
x2 = 1234567890.0 * 0.25
x3 = 1234567890.0 ** 0.5
x4 = math.sqrt(1234567890.0)

निम्नलिखित बायोटेक के संकलन:

  # x1 = 1234567890.0 / 4.0
  4           0 LOAD_CONST               1 (1234567890.0)
              3 LOAD_CONST               2 (4.0)
              6 BINARY_DIVIDE       
              7 STORE_FAST               0 (x1)

  # x2 = 1234567890.0 * 0.25
  5          10 LOAD_CONST               5 (308641972.5)
             13 STORE_FAST               1 (x2)

  # x3 = 1234567890.0 ** 0.5
  6          16 LOAD_CONST               6 (35136.418286444619)
             19 STORE_FAST               2 (x3)

  # x4 = math.sqrt(1234567890.0)
  7          22 LOAD_GLOBAL              0 (math)
             25 LOAD_ATTR                1 (sqrt)
             28 LOAD_CONST               1 (1234567890.0)
             31 CALL_FUNCTION            1
             34 STORE_FAST               3 (x4)

जैसा कि आप देख सकते हैं, कोड के संकलित होने के बाद से गुणा और घातांक में कोई समय नहीं लगता है। डिवीजन को रनटाइम पर होने में अधिक समय लगता है। स्क्वायर रूट न केवल चार का सबसे कम्प्यूटेशनल महंगा ऑपरेशन है, यह विभिन्न ओवरहेड्स को भी उकसाता है जो अन्य नहीं करते हैं (विशेषता देखने, फ़ंक्शन कॉल आदि)।

यदि आप निरंतर तह के प्रभाव को समाप्त करते हैं, तो अलग गुणन और विभाजन के लिए बहुत कम है:

In [16]: x = 1234567890.0

In [17]: %timeit x / 4.0
10000000 loops, best of 3: 87.8 ns per loop

In [18]: %timeit x * 0.25
10000000 loops, best of 3: 91.6 ns per loop

math.sqrt(x)वास्तव में थोड़ी तेजी से x ** 0.5, संभवतः इसलिए है क्योंकि यह बाद का एक विशेष मामला है और इसलिए ओवरहेड्स के बावजूद इसे अधिक कुशलता से किया जा सकता है:

In [19]: %timeit x ** 0.5
1000000 loops, best of 3: 211 ns per loop

In [20]: %timeit math.sqrt(x)
10000000 loops, best of 3: 181 ns per loop

2011-11-16 को संपादित करें: निरंतर अभिव्यक्ति तह पायथन के पीपहोल अनुकूलक द्वारा किया जाता है। स्रोत कोड ( peephole.c) में निम्न टिप्पणी है जो बताती है कि निरंतर विभाजन क्यों नहीं मुड़ा है:

    case BINARY_DIVIDE:
        /* Cannot fold this operation statically since
           the result can depend on the run-time presence
           of the -Qnew flag */
        return 0;

-Qnewझंडा "सच विभाजन" में परिभाषित सक्षम बनाता है पीईपी 238 ।