पायथन में '//' रखने का क्या कारण है?

Question

मैं किसी के कोड में यह देखा:

y = img_index // num_images 

जहां img_index चल रहे एक सूचकांक है और num_images 3.

है जब मैं IPython में // के साथ चारों ओर गंदगी, यह सिर्फ एक विभाजन चिन्ह की तरह काम करने के लिए (लगता है यानी एक आगे स्लैश)। मैं बस सोच रहा था कि डबल फॉरवर्ड स्लेश होने का कोई कारण है या नहीं?

Answer 1

अजगर 3 में, वे / ऑपरेटर बने एक फ्लोटिंग प्वाइंट विभाजन करते हैं, और पूर्णांक प्रभाग (शेष बिना अर्थात भागफल) करने के लिए // ऑपरेटर जोड़ा गया; जबकि पायथन 2 में, / ऑपरेटर बस पूर्णांक विभाजन था, जब तक कि एक ऑपरेंड पहले से ही एक फ़्लोटिंग पॉइंट नंबर नहीं था।

पायथन 2.x में:

>>> 10/3 
3 
>>> # to get a floating point number from integer division: 
>>> 10.0/3 
3.3333333333333335 
>>> float(10)/3 
3.3333333333333335 

अजगर 3 में:

>>> 10/3 
3.3333333333333335 
>>> 10//3 
3 

आगे संदर्भ के लिए, PEP238 देखते हैं।

Answer 2

// बिना शर्त "फर्श विभाजन", उदा है:

>>> 4.0//1.5 
2.0 

जैसा कि आप देख, हालांकि दोनों ऑपरेंड float रों, //अभी भी फर्श हैं - तो आप हमेशा पता सुरक्षित रूप से क्या यह वाला है है।

एकल / कर सकते हैं या नहीं मंजिल अजगर रिहाई, भविष्य के आयात, और यहां तक ​​कि झंडे के आधार पर हो सकता है जो अजगर की दौड़, जैसे ... पर:

$ python2.6 -Qold -c 'print 2/3' 
0 
$ python2.6 -Qnew -c 'print 2/3' 
0.666666666667 

जैसा कि आप देख, एकल / हो सकता है मंजिल, या यह एक नाव वापस आ सकते हैं, पूरी तरह से गैर स्थानीय मुद्दों, के लिए और -Q ध्वज के महत्व सहित अप के आधार पर ... ;-)।

तो, अगर और जब आप पता आप फर्श, हमेशा उपयोग // है, जो यह की गारंटी देता है चाहता हूँ। अगर और जब आप जानते हैं कि फर्श चाहते हैं, तो float() अन्य ऑपरेंड के आसपास थप्पड़ मारें और / का उपयोग करें। कोई अन्य संयोजन, और आप संस्करण, आयात और झंडे की दया पर हैं! -)

Answer 3

एलेक्स की प्रतिक्रिया के पूरक के लिए, मैं जोड़ता हूं कि पायथन 2.2.0a2, from __future__ import division से शुरू करने के लिए एक सुविधाजनक विकल्प है float(…)/…। सभी डिवीजनों, नाव डिवीजनों प्रदर्शन // के साथ उन लोगों को छोड़कर। यह 2.2.0a2 से सभी संस्करणों के साथ काम करता है।

Answer 4

//float प्रकार के वापसी मूल्य के साथ विभागों के लिए math.floor() के लिए उपनाम माना जा सकता है। यह के रूप में int के रिटर्न वैल्यू वाले डिवीजनों के लिए no-op के रूप में कार्य करता है।

import math 
# let's examine `float` returns 
# ------------------------------------- 
# divide 
>>> 1.0/2 
0.5 
# divide and round down 
>>> math.floor(1.0/2) 
0.0 
# divide and round down 
>>> 1.0 // 2 
0.0 

# now let's examine `integer` returns 
# ------------------------------------- 
>>> 1/2 
0 
>>> 1//2 
0 

Answer 5

इन अन्य उत्तर की मदद के लिए // ऑपरेटर भी / पर महत्वपूर्ण (3x) प्रदर्शन लाभ प्रदान करता है, यह मानते हुए आप पूर्णांक विभाजन चाहते हैं।

$ python -m timeit '20.5 // 2' 
100000000 loops, best of 3: 0.0149 usec per loop 
$ python -m timeit '20.5/2' 
10000000 loops, best of 3: 0.0484 usec per loop 
$ python -m timeit '20/2' 
10000000 loops, best of 3: 0.043 usec per loop 
$ python -m timeit '20 // 2' 
100000000 loops, best of 3: 0.0144 usec per loop