पायथन डिवीजन


133

मैं संख्याओं के एक सेट को -100 से 0 से 10-100 की सीमा तक सामान्य करने की कोशिश कर रहा था और केवल यह ध्यान देने में समस्या हो रही थी कि कोई भी चर नहीं होने के बावजूद, यह उस तरीके का मूल्यांकन नहीं करता है जिससे मैं इसकी उम्मीद करूंगा:

>>> (20-10) / (100-10)
0

फ्लोट डिवीजन भी काम नहीं करता है:

>>> float((20-10) / (100-10))
0.0

यदि दोनों में से किसी एक हिस्से में एक फ्लोट डाली जाती है तो यह काम करेगा:

>>> (20-10) / float((100-10))
0.1111111111111111

पहले उदाहरण में प्रत्येक पक्ष एक ऐसे उदाहरण के रूप में मूल्यांकन कर रहा है जिसका अर्थ है कि अंतिम उत्तर को एक इंट में डाला जाएगा। चूँकि 0.111, .5 से कम है, यह 0. से गोल है। यह मेरी राय में पारदर्शी नहीं है, लेकिन मुझे लगता है कि यह जिस तरह से है।

स्पष्टीकरण क्या है?



3
एडम, मुझे अभी भी आपका स्पष्टीकरण पसंद नहीं है। पहला उदाहरण पूर्णांक विभाजन है, जो केवल 0. लौटाता है। दूसरा उदाहरण आपके इच्छित प्रभाव के लिए गलत तरीके से संक्षिप्त किया गया है।
राष्ट्रपति जेम्स के। पोल्क

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

1
एडम, कृपया अपने पिछले EDIT को सही करें। सही पक्ष के पास इसके लिए कुछ खास नहीं है; विभाजन के लिए नाव को या तो अंश या हर (या दोनों) को तैरने की आवश्यकता होती है। अगर आपको लगता है कि आप डॉक्स में पढ़ते हैं कि राइट हैंड साइड को फ्लोट करना है, तो या तो डॉक्यूमेंटेशन खराब है और इसे सही किया जाना चाहिए, या आपने इसे गलत समझा। क्या आपने एक उदाहरण देखा, शायद, और फिर उसमें से एक नियम को हटा दें?
tzot

जवाबों:


246

आप पायथन 2.x का उपयोग कर रहे हैं, जहां पूर्णांक विभाजन एक अस्थायी बिंदु संख्या बनने के बजाय कम हो जाएगा।

>>> 1 / 2
0

आपको उनमें से एक बनाना चाहिए float:

>>> float(10 - 20) / (100 - 10)
-0.1111111111111111

या from __future__ import division, जो /पायथन 3.x के व्यवहार को अपनाने के लिए मजबूर करता है जो हमेशा एक फ्लोट लौटाता है।

>>> from __future__ import division
>>> (10 - 20) / (100 - 10)
-0.1111111111111111

10
यदि आप उपयोग from __future__ import divisionकरते हैं तो आप दो स्लैश का उपयोग करके पुराने सी-स्टाइल डिवीजन व्यवहार प्राप्त कर सकते हैं (जैसे 1 // 20 में परिणाम होगा)। Pep 238 को संचालक ऑपरेटर बदलते
उपयोगकर्ता

1
@ उपयोगकर्ता से आयात की कोई आवश्यकता नहीं है __future__। दोनों में पायथन 2 और 3 डिफ़ॉल्ट रूप //से संदर्भित करता है __floordiv__()
कासिमिर

21

आप इंटिजर्स डाल रहे हैं ताकि अजगर आपको एक पूर्णांक वापस दे रहा है :

>>> 10 / 90
0

यदि आप इसे एक फ्लोट के लिए डालते हैं तो बाद में गोलाई पहले ही हो चुकी होगी, दूसरे शब्दों में, 0 पूर्णांक हमेशा फ्लोट बन जाएगा।

यदि आप विभाजन के दोनों ओर फ़्लोट्स का उपयोग करते हैं तो पायथन आपको वह उत्तर देगा जिसकी आप अपेक्षा करते हैं।

>>> 10 / 90.0
0.1111111111111111

तो आपके मामले में:

>>> float(20-10) / (100-10)
0.1111111111111111
>>> (20-10) / float(100-10)
0.1111111111111111

11

आपको इसे एक फ्लोट से पहले बदलने की आवश्यकता है जब आप विभाजन करते हैं। अर्थात्:

float(20 - 10) / (100 - 10)

4
@ एडम नेल्सन: मेरे लिए सही ढंग से काम करता है। अपने कोष्ठकों की जाँच करें।
फ्रेड लार्सन

दरअसल, मैं गलत हूं - लेकिन डॉक्स को देखने के बाद, पहले दाईं ओर कास्ट करना चाहिए।
एडम नेल्सन

10
@ एडम: यह कोई बात नहीं है जो पहले पक्ष में है।
kennytm

11

अजगर 2.7 में, /यदि इनपुट पूर्णांक हैं , तो ऑपरेटर एक पूर्णांक विभाजन है:

>>>20/15
1

>>>20.0/15.0
1.33333333333

>>>20.0/15
1.33333333333

पायथन 3.3 में, /ऑपरेटर एक फ्लोट डिवीजन है, भले ही इनपुट पूर्णांक हो।

>>> 20/15
1.33333333333

>>>20.0/15
1.33333333333

अजगर 3 में पूर्णांक विभाजन के लिए, हम //ऑपरेटर का उपयोग करेंगे ।

//ऑपरेटर दोनों अजगर 2.7 और अजगर 3.3 में एक पूर्णांक विभाजन ऑपरेटर है।

पायथन 2.7 और पायथन 3.3 में:

>>>20//15
1

अब, तुलना देखें

>>>a = 7.0/4.0
>>>b = 7/4
>>>print a == b

उपरोक्त कार्यक्रम के लिए, आउटपुट पायथन में फाल्स 2.7 और पायथन 3.3 में ट्रू होगा।

पायथन में 2.7 a = 1.75 और b = 1।

पायथन में 3.3 ए = 1.75 और बी = 1.75, सिर्फ इसलिए /कि एक फ्लोट डिवीजन है।


8

यह अजगर के संस्करण के साथ करना है जो आप उपयोग करते हैं। मूल रूप से यह सी व्यवहार को अपनाता है: यदि आप दो पूर्णांकों को विभाजित करते हैं, तो परिणाम एक पूर्णांक तक नीचे हो जाएंगे। यह भी ध्यान रखें कि पायथन ऑपरेशन को बाएं से दाएं करता है, जो टाइपकास्ट होने पर एक भूमिका निभाता है।

उदाहरण: चूंकि यह एक सवाल है जो हमेशा मेरे सिर में होता है जब मैं अंकगणितीय ऑपरेशन कर रहा होता हूं (क्या मुझे फ्लोट और कौन सी संख्या में बदलना चाहिए), उस पहलू से एक उदाहरण प्रस्तुत किया गया है:

>>> a = 1/2/3/4/5/4/3
>>> a
0

जब हम पूर्णांकों को विभाजित करते हैं, तो आश्चर्य नहीं कि यह कम गोल हो जाता है।

>>> a = 1/2/3/4/5/4/float(3)
>>> a
0.0

यदि हम अंतिम पूर्णांक को फ्लोट करने के लिए टाइप करते हैं, तो हम अभी भी शून्य हो जाएंगे, क्योंकि तब तक हमारी संख्या फ्लोट से विभाजित हो जाती है, पूर्णांक विभाजन के कारण पहले से ही 0 हो गई है।

>>> a = 1/2/3/float(4)/5/4/3
>>> a
0.0

ऊपर जैसा ही परिदृश्य, लेकिन फ्लोट टाइपकास्ट को शिफ्ट करना बाईं ओर थोड़ा करीब है।

>>> a = float(1)/2/3/4/5/4/3
>>> a
0.0006944444444444445

अंत में, जब हम पहले पूर्णांक को फ्लोट करने के लिए टाइप करते हैं, तो परिणाम वांछित होता है, क्योंकि पहले विभाजन से शुरुआत होती है, यानी सबसे बाईं ओर, हम फ्लोट का उपयोग करते हैं।

अतिरिक्त 1: आपको लगता है कि अंकगणित मूल्यांकन में सुधार करने के जवाब देने के लिए कोशिश कर रहे हैं, तो आप की जाँच करनी चाहिए इस

अतिरिक्त 2: कृपया निम्नलिखित परिदृश्य से सावधान रहें:

>>> a = float(1/2/3/4/5/4/3)
>>> a
0.0

4

'' लगाकर एक फ्लोट निर्दिष्ट करना। संख्या के बाद यह भी डिफ़ॉल्ट रूप से फ्लोट करने का कारण होगा।

>>> 1 / 2
0

>>> 1. / 2.
0.5

2

उनमें से कम से कम एक फ्लोट बनाओ, तो यह फ्लोट डिवीजन होगा, पूर्णांक नहीं:

>>> (20.0-10) / (100-10)
0.1111111111111111

फ्लोट करने के लिए परिणाम कास्टिंग बहुत देर हो चुकी है।


1

अजगर cv2में विभाजन गणना को अद्यतन नहीं किया गया। इसलिए, आपको from __future__ import division कार्यक्रम की पहली पंक्ति में शामिल होना चाहिए ।


0

किसी भी तरह से, यह पूर्णांक विभाजन है। 10/90 = 0. दूसरे मामले में, आप केवल 0 को फ़्लोट में डाल रहे हैं।

फ्लोट होने के लिए "/" के ऑपरेंड में से एक को कास्टिंग करने का प्रयास करें:

float(20-10) / (100-10)

0

आपके दूसरे उदाहरण में विभाजन पहले ही हो जाने के बाद आप तैरने के लिए कास्टिंग कर रहे हैं। इसे इस्तेमाल करे:

float(20-10) / float(100-10)

0

मुझे कुछ आश्चर्य हुआ कि किसी ने यह उल्लेख नहीं किया है कि मूल पोस्टर परिणाम के लिए तर्कसंगत संख्याओं को पसंद कर सकता है । क्या आपको इसमें दिलचस्पी लेनी चाहिए, पायथन-आधारित कार्यक्रम ऋषि आपकी पीठ है । (वर्तमान में अभी भी पायथन 2.x पर आधारित है, हालांकि 3.x चल रहा है।)

sage: (20-10) / (100-10)
1/9

यह हर किसी के लिए एक समाधान नहीं है, क्योंकि यह कुछ पूर्वसर्ग करता है इसलिए ये संख्याएं नहीं हैं int, लेकिन ऋषि Integerवर्ग तत्व हैं। फिर भी, पायथन पारिस्थितिकी तंत्र के एक हिस्से के रूप में उल्लेख के लायक है।


0

व्यक्तिगत रूप से मैंने 1. *बहुत शुरुआत में सम्मिलित होना पसंद किया । तो अभिव्यक्ति कुछ इस तरह हो जाती है:

1. * (20-10) / (100-10)

जैसा कि मैं हमेशा कुछ सूत्र के लिए एक विभाजन करता हूं जैसे:

accuracy = 1. * (len(y_val) - sum(y_val)) / len(y_val)

इसलिए इसे बस एक .0तरह से जोड़ना असंभव है 20.0। और मेरे मामले में, लपेटने से float()थोड़ी सी पठनीयता खो सकती है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.