एक निश्चित दशमलव स्थान तक एक फ्लोटिंग पॉइंट नंबर कैसे गोल करें?

Question 1

मान लीजिए कि मेरे पास है 8.8333333333333339, और मैं इसे परिवर्तित करना चाहता हूं 8.84। मैं इसे पायथन में कैसे पूरा कर सकता हूं?

round(8.8333333333333339, 2)देता है 8.83और नहीं 8.84। मैं सामान्य रूप से पायथन या प्रोग्रामिंग के लिए नया हूं।

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

Question 2

8.833333333339(या 8.833333333333334, का परिणाम 106.00/12) ठीक से दो दशमलव स्थानों के लिए गोल है 8.83। गणितीय रूप से यह लगता है कि आप जो चाहते हैं वह एक छत फ़ंक्शन है । पायथन के mathमॉड्यूल का नाम है ceil:

import math

v = 8.8333333333333339
print(math.ceil(v*100)/100)  # -> 8.84

क्रमशः, फ़्लोर और सीलिंग फ़ंक्शंस आमतौर पर एक वास्तविक संख्या को सबसे बड़े पिछले या सबसे छोटे पूर्णांक का अनुसरण करते हैं, जिसमें शून्य दशमलव स्थान होते हैं - इसलिए उन्हें 2 दशमलव स्थानों के लिए उपयोग करने के लिए दशमलव को स्थानांतरित करने के लिए संख्या को पहले 10 ² (या 100) से गुणा किया जाता है। बिंदु और उसके बाद क्षतिपूर्ति करने के लिए इसके द्वारा विभाजित किया जाता है।

यदि आप mathकिसी कारण से मॉड्यूल का उपयोग नहीं करना चाहते हैं , तो आप इसे (न्यूनतम परीक्षण किए गए) कार्यान्वयन का उपयोग कर सकते हैं जो मैंने अभी लिखा है:

def ceiling(x):
    n = int(x)
    return n if n-1 < x <= n else n+1

यह सब कैसे जुड़े ऋण और भुगतान कैलकुलेटर समस्या से संबंधित है:

नमूना उत्पादन से ऐसा लगता है कि वे को गिरफ्तार मासिक भुगतान, जो कई कॉल छत समारोह का असर है। इस का मतलब है एक छोटे से हर महीने अधिक है कि ¹ / ₁₂ कुल राशि का भुगतान किया जा रहा है। इसने अंतिम भुगतान को सामान्य से थोड़ा छोटा कर दिया - केवल शेष बकाया भुगतान छोड़ दिया 8.76।

यह समान रूप से मान्य होता है कि मासिक भुगतान के लिए सामान्य राउंडिंग का उपयोग किया जाए 8.83और थोड़ा अधिक भुगतान किया जाए 8.87। हालांकि, वास्तविक दुनिया में आमतौर पर लोग अपने भुगतान को बढ़ाना पसंद नहीं करते हैं, इसलिए प्रत्येक भुगतान को गोल करना आम बात है - यह ऋणदाता को अधिक तेज़ी से पैसा भी लौटाता है।

Question 3

यह सामान्य है (और इसका पायथन से कोई लेना-देना नहीं है) क्योंकि 8.83 को बाइनरी फ्लोट के रूप में बिल्कुल नहीं दर्शाया जा सकता है, जैसे 1/3 को दशमलव (0.333333 ... विज्ञापन infinitum) में बिल्कुल प्रतिनिधित्व नहीं किया जा सकता है।

यदि आप पूर्ण सटीकता सुनिश्चित करना चाहते हैं, तो आपको decimalमॉड्यूल की आवश्यकता है :

>>> import decimal
>>> a = decimal.Decimal("8.833333333339")
>>> print(round(a,2))
8.83

Question 4

आप दशमलव मॉड्यूल का उपयोग करना चाहते हैं, लेकिन आपको गोलाई मोड भी निर्दिष्ट करना होगा। यहाँ एक उदाहरण है:

>>> import decimal
>>> decimal.Decimal('8.333333').quantize(decimal.Decimal('.01'), rounding=decimal.ROUND_UP)
Decimal('8.34')
>>> decimal.Decimal('8.333333').quantize(decimal.Decimal('.01'), rounding=decimal.ROUND_DOWN)
Decimal('8.33')
>>>

Question 5

एक सरल तरीका यह है कि आप केवल राउंड () फ़ंक्शन का उपयोग करें। यहाँ एक उदाहरण है।

total_price = float()
price_1 = 2.99
price_2 = 0.99
total_price = price_1 + price_2

यदि आप अभी कुल total_price प्रिंट कर रहे थे तो आपको मिलेगा

3.9800000000000004

लेकिन अगर आप इसे एक राउंड () फ़ंक्शन में संलग्न करते हैं तो ऐसा होता है

print(round(total_price,2))

आउटपुट के बराबर है

3.98

राउंड () फ़ंक्शन दो मापदंडों को स्वीकार करके काम करता है। पहला वह नंबर है जिसे आप गोल करना चाहते हैं। दूसरे दौर में दशमलव स्थानों की संख्या है।

Question 6

यदि आप 8.8333333333339 से 2 दशमलव तक गोल करते हैं, तो सही उत्तर 8.83 है, न कि 8.84। आपके द्वारा 8.83000000001 प्राप्त करने का कारण यह है कि 8.83 एक ऐसी संख्या है जिसे बाइनरी में सही ढंग से पुनर्प्रकाशित नहीं किया जा सकता है, और यह आपको निकटतम देता है। यदि आप इसे सभी शून्य के बिना प्रिंट करना चाहते हैं, तो VGE कहते हैं:

print "%.2f" % 8.833333333339   #(Replace number with the variable?)

Question 7

ऐसा करने का सबसे आसान तरीका नीचे दिए गए फ़ंक्शन का उपयोग करके है, जो इसमें बनाया गया है:

format()

उदाहरण के लिए:

format(1.242563,".2f")

उत्पादन होगा:

1.24

इसी तरह:

format(9.165654,".1f")

देना होगा:

9.2

Question 8

यदि आप गोल करना चाहते हैं, तो 8.84 गलत उत्तर है। 8.833333333333 गोल है 8.83 नहीं 8.84। यदि आप हमेशा राउंड अप करना चाहते हैं, तो आप math.ceil का उपयोग कर सकते हैं। स्ट्रिंग प्रारूपण के संयोजन में दोनों करें, क्योंकि एक फ्लोट संख्या को गोल करने से कोई मतलब नहीं है।

"%.2f" % (math.ceil(x * 100) / 100)

Question 9

सिर्फ रिकार्ड के लिए। आप इसे इस तरह से कर सकते हैं:

def roundno(no):
    return int(no//1 + ((no%1)/0.5)//1)

वहां, इसमें शामिल / आयात की कोई आवश्यकता नहीं है

Question 10

यहाँ राउंड अप / डाउन समस्या के लिए मेरा समाधान है

< .5  round down

> = .5  round up

import math

def _should_round_down(val: float):
    if val < 0:
        return ((val * -1) % 1) < 0.5
    return (val % 1) < 0.5

def _round(val: float, ndigits=0):
    if ndigits > 0:
        val *= 10 ** (ndigits - 1)
    is_positive = val > 0
    tmp_val = val
    if not is_positive:
        tmp_val *= -1
    rounded_value = math.floor(tmp_val) if _should_round_down(val) else math.ceil(tmp_val)
    if not is_positive:
        rounded_value *= -1
    if ndigits > 0:
        rounded_value /= 10 ** (ndigits - 1)
    return rounded_value

# test
# nr = 12.2548
# for digit in range(0, 4):
#     print("{} decimals : {} -> {}".format(digit, nr, _round(nr, digit)))

# output
# 0 decimals : 12.2548 -> 12
# 1 decimals : 12.2548 -> 12.0
# 2 decimals : 12.2548 -> 12.3
# 3 decimals : 12.2548 -> 12.25

Question 11

मेरे पास यह कोड है:

tax = (tax / 100) * price

और फिर यह कोड:

tax = round((tax / 100) * price, 2)

दौर मेरे लिए काम किया

Question 12

decimalमॉड्यूल का उपयोग करें : http://docs.python.org/library/decimal.html

ََََََ

Question 13

यहाँ आपके लिए यह करने के लिए एक सरल कार्य है:

def precision(num,x):
    return "{0:.xf}".format(round(num))

यहाँ, संख्या दशमलव संख्या है। x वह दशमलव है जहाँ आप एक फ़्लोटिंग संख्या को राउंड करना चाहते हैं।

अन्य कार्यान्वयन से अधिक लाभ यह है कि यह दशमलव के दाहिने छोर पर शून्य को भर सकता है ताकि x दशमलव स्थानों तक एक deciaml संख्या बना सके।

उदाहरण 1:

precision(10.2, 9)

वापस होगा

10.200000000 (9 दशमलव तक)

उदाहरण 2:

precision(10.2231, 2)

वापस होगा

10.22 (दो दशमलव तक)