मैं एक ऐसा कार्यक्रम बना रहा हूं, जिसके कारणों की व्याख्या करने की आवश्यकता नहीं है, इसके लिए एक फ्लोट को एक स्ट्रिंग में बदलने की आवश्यकता होती है जिसे लेन () के साथ गिना जाता है। हालांकि, str (फ्लोट (x)) का परिणाम x में होता है जब इसे स्ट्रिंग में परिवर्तित किया जाता है, जो पूरी चीज को फेंक देता है। क्या किसी को इसके लिए एक तय पता है? यदि आप जानना चाहते हैं तो यहां कोड का उपयोग किया जा रहा है:
len(str(float(x)/3))
x। उदाहरणों के बिना, हम केवल अनुमान लगा सकते हैं कि समस्या क्या है।
जवाबों:
फ्लोटिंग पॉइंट नंबरों से निपटने के दौरान गोलाई का कुछ रूप अक्सर अपरिहार्य होता है। इसका कारण यह है कि संख्याएँ जो आप बेस 10 में बिल्कुल व्यक्त कर सकते हैं, हमेशा बेस 2 (जिसे आपका कंप्यूटर उपयोग करता है) में बिल्कुल व्यक्त नहीं किया जा सकता है।
उदाहरण के लिए:
>>> .1
0.10000000000000001
इस स्थिति में, आप देख रहे हैं .1 का उपयोग करके स्ट्रिंग में परिवर्तित किया जाता है repr:
>>> repr(.1)
'0.10000000000000001'
मेरा मानना है कि इस समस्या को हल करने के लिए जब आप str () का उपयोग करते हैं तो अजगर पिछले कुछ अंकों को काट देता है, लेकिन यह एक आंशिक रूप से हल है जो समझने के लिए विकल्प नहीं है कि क्या हो रहा है।
>>> str(.1)
'0.1'
मुझे यकीन नहीं है कि "गोलाई" के कारण आपको क्या समस्याएं हो रही हैं। शायद आप अपने आउटपुट को अधिक सटीक रूप से नियंत्रित करने के लिए स्ट्रिंग स्वरूपण के साथ बेहतर करेंगे?
जैसे
>>> '%.5f' % .1
'0.10000'
>>> '%.5f' % .12345678
'0.12346'
len(repr(float(x)/3))
हालाँकि मुझे कहना होगा कि यह उतना विश्वसनीय नहीं है जितना आप सोचते हैं।
फ़्लैट्स को दशमलव संख्याओं के रूप में दर्ज / प्रदर्शित किया जाता है, लेकिन आपका कंप्यूटर (वास्तव में, आपकी मानक सी लाइब्रेरी) उन्हें बाइनरी के रूप में संग्रहीत करता है। इस संक्रमण से आपको कुछ दुष्प्रभाव होते हैं:
>>> print len(repr(0.1))
19
>>> print repr(0.1)
0.10000000000000001
ऐसा क्यों होता है, इस बारे में स्पष्टीकरण अजगर ट्यूटोरियल के इस अध्याय में है।
एक प्रकार एक प्रकार का उपयोग करना होगा जो विशेष रूप से दशमलव संख्याओं को ट्रैक करता है, जैसे कि अजगर decimal.Decimal:
>>> print len(str(decimal.Decimal('0.1')))
3
अन्य उत्तरों ने पहले ही बताया कि फ्लोटिंग नंबरों का प्रतिनिधित्व कम से कम कहने के लिए एक कांटेदार मुद्दा है।
चूंकि आप अपने प्रश्न में पर्याप्त संदर्भ नहीं देते हैं, इसलिए मैं नहीं जान सकता कि दशमलव मॉड्यूल आपकी आवश्यकताओं के लिए उपयोगी हो सकता है या नहीं:
http://docs.python.org/library/decimal.html
अन्य बातों के अलावा आप स्पष्ट रूप से उस सटीकता को निर्दिष्ट कर सकते हैं जिसे आप प्राप्त करना चाहते हैं (डॉक्स से):
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
मेरे संकेत से एक सरल उदाहरण (अजगर 2.6):
>>> import decimal
>>> a = decimal.Decimal('10.000000001')
>>> a
Decimal('10.000000001')
>>> print a
10.000000001
>>> b = decimal.Decimal('10.00000000000000000000000000900000002')
>>> print b
10.00000000000000000000000000900000002
>>> print str(b)
10.00000000000000000000000000900000002
>>> len(str(b/decimal.Decimal('3.0')))
29
शायद यह मदद कर सकता है? दशमलव 2.4 के बाद से अजगर stdlib में है, अजगर 2.6 में परिवर्धन के साथ।
आशा है कि यह मदद करता है, फ्रांसेस्को
मुझे पता है कि यह बहुत देर हो चुकी है, लेकिन जो लोग पहली बार यहां आ रहे हैं, उनके लिए मैं एक समाधान पोस्ट करना चाहता हूं। मेरे पास एक फ्लोट मूल्य indexऔर एक स्ट्रिंग है imgfileऔर मुझे आपके समान ही समस्या थी। इस तरह मैंने इस मुद्दे को ठीक किया
index = 1.0
imgfile = 'data/2.jpg'
out = '%.1f,%s' % (index,imgfile)
print out
आउटपुट है
1.0,data/2.jpg
आप अपनी सुविधा के अनुसार इस स्वरूपण उदाहरण को संशोधित कर सकते हैं।