“गोल” और “दशमलव” के साथ पायथन में दशमलव और पूर्णांकों को गोल करना

निम्नलिखित बताता है कि पायथन में संख्याओं को सम संख्या में गोल या गोल करके कैसे गोल किया जाए। संख्याएं फ़्लोटिंग पॉइंट फ्लोट या पूर्णांक int प्रकार की मानी जाती हैं।

• अंतर्निहित फ़ंक्शन (जैसे प्रोग्रामिंग भाषा में):round()
  • अंकों की किसी भी संख्या के लिए गोल दशमलव।
  • अंकों की किसी भी संख्या के पूर्णांकों को गोल करें।
  • राउंड () एक सम संख्या में राउंड करता है, सामान्य राउंडिंग के लिए नहीं
• मानक पुस्तकालयdecimalquantize()
  • Decimalएक वस्तु बनाना
  • दशमलव को किसी भी संख्या में पूर्णांकित करना और सम संख्याओं को पूर्णांकित करना
  • पूर्णांकों को किसी भी संख्या में पूर्णांकित करना और सम संख्याओं को पूर्णांकित करना
• एक नया फ़ंक्शन परिभाषित करें
  • दशमलव को किसी भी संख्या में पूर्णांकित करें।
  • अंकों की किसी भी संख्या के लिए गोल पूर्णांक
  • नोट: ऋणात्मक मानों के लिए

ध्यान दें, जैसा कि ऊपर उल्लेख किया गया है, बिल्ट-इन फ़ंक्शन राउंड एक सामान्य राउंडिंग नहीं है, बल्कि एक सम संख्या के लिए एक राउंडिंग है। विवरण के लिए नीचे देखें।

अंतर्निहित फ़ंक्शन (जैसे प्रोग्रामिंग भाषा में):round()

Round() एक अंतर्निहित फ़ंक्शन के रूप में प्रदान किया जाता है। इसका उपयोग किसी भी मॉड्यूल को आयात किए बिना किया जा सकता है।

• round() — Built-in Functions — Python 3.10.2 Documentation

पहला तर्क मूल संख्या है, और दूसरा तर्क अंकों की संख्या है (कितने अंकों को गोल करना है)।

अंकों की किसी भी संख्या के लिए गोल दशमलव।

फ़्लोटिंग-पॉइंट फ्लोट प्रकार के लिए प्रसंस्करण का एक उदाहरण निम्नलिखित है।

यदि दूसरा तर्क छोड़ दिया जाता है, तो इसे एक पूर्णांक में गोल किया जाता है। प्रकार भी एक पूर्णांक int प्रकार बन जाता है।

f = 123.456

print(round(f))
# 123

print(type(round(f)))
# <class 'int'>

यदि दूसरा तर्क निर्दिष्ट किया गया है, तो यह एक फ़्लोटिंग-पॉइंट फ़्लोट प्रकार देता है।

यदि कोई धनात्मक पूर्णांक निर्दिष्ट किया जाता है, तो दशमलव स्थान निर्दिष्ट किया जाता है; यदि एक ऋणात्मक पूर्णांक निर्दिष्ट किया जाता है, तो पूर्णांक स्थान निर्दिष्ट किया जाता है। -1 राउंड निकटतम दसवें तक, -2 राउंड निकटतम सौवें तक, और 0 राउंड एक पूर्णांक (प्रथम स्थान) के लिए, लेकिन एक फ्लोट प्रकार लौटाता है, जब छोड़े जाने के विपरीत।

print(round(f, 1))
# 123.5

print(round(f, 2))
# 123.46

print(round(f, -1))
# 120.0

print(round(f, -2))
# 100.0

print(round(f, 0))
# 123.0

print(type(round(f, 0)))
# <class 'float'>

अंकों की किसी भी संख्या के पूर्णांकों को गोल करें।

पूर्णांक int प्रकार के लिए प्रसंस्करण का एक उदाहरण निम्नलिखित है।

यदि दूसरा तर्क छोड़ दिया जाता है, या यदि 0 या एक सकारात्मक पूर्णांक निर्दिष्ट किया जाता है, तो मूल मान जैसा है वैसा ही वापस किया जाता है। यदि एक ऋणात्मक पूर्णांक निर्दिष्ट किया जाता है, तो इसे संगत पूर्णांक अंक तक पूर्णांकित किया जाता है। दोनों ही मामलों में, एक पूर्णांक int प्रकार लौटाया जाता है।

i = 99518

print(round(i))
# 99518

print(round(i, 2))
# 99518

print(round(i, -1))
# 99520

print(round(i, -2))
# 99500

print(round(i, -3))
# 100000

राउंड () एक सम संख्या में राउंड करता है, सामान्य राउंडिंग के लिए नहीं

ध्यान दें कि पाइथन 3 राउंड में बिल्ट-इन राउंड () फ़ंक्शन के साथ राउंडिंग एक सम संख्या में, सामान्य राउंडिंग के लिए नहीं।

जैसा कि आधिकारिक दस्तावेज़ीकरण में लिखा गया है, 0.5 को 0 से गोल किया गया है, 5 को 0 पर गोल किया गया है, और इसी तरह।

• round() — Built-in Functions — Python 3.10.2 Documentation

print('0.4 =>', round(0.4))
print('0.5 =>', round(0.5))
print('0.6 =>', round(0.6))
# 0.4 => 0
# 0.5 => 0
# 0.6 => 1

print('4 =>', round(4, -1))
print('5 =>', round(5, -1))
print('6 =>', round(6, -1))
# 4 => 0
# 5 => 0
# 6 => 10

एक सम संख्या में पूर्णांकन की परिभाषा इस प्रकार है।

यदि भिन्न 0.5 से कम है, तो इसे नीचे गोल करें; यदि भिन्न 0.5 से अधिक है, तो इसे गोल करें; यदि भिन्न ठीक 0.5 है, तो इसे नीचे और गोल करने के बीच सम संख्या तक गोल करें।
Rounding – Wikipedia

0.5 हमेशा छोटा नहीं किया जाता है।

print('0.5 =>', round(0.5))
print('1.5 =>', round(1.5))
print('2.5 =>', round(2.5))
print('3.5 =>', round(3.5))
print('4.5 =>', round(4.5))
# 0.5 => 0
# 1.5 => 2
# 2.5 => 2
# 3.5 => 4
# 4.5 => 4

कुछ मामलों में, एक सम संख्या में पूर्णांकन की परिभाषा दो दशमलव स्थानों के बाद प्रसंस्करण पर भी लागू नहीं होती है।

print('0.05 =>', round(0.05, 1))
print('0.15 =>', round(0.15, 1))
print('0.25 =>', round(0.25, 1))
print('0.35 =>', round(0.35, 1))
print('0.45 =>', round(0.45, 1))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

यह इस तथ्य के कारण है कि दशमलव को फ़्लोटिंग पॉइंट नंबरों के रूप में बिल्कुल प्रदर्शित नहीं किया जा सकता है, जैसा कि आधिकारिक दस्तावेज़ीकरण में बताया गया है।

फ़्लोटिंग पॉइंट नंबरों के लिए राउंड () का व्यवहार आपको आश्चर्यचकित कर सकता है:उदाहरण के लिए, राउंड (2.675, 2) आपको उम्मीद के मुताबिक 2.68 के बजाय 2.67 देगा। यह एक बग नहीं है।:यह इस तथ्य का परिणाम है कि अधिकांश दशमलवों को फ़्लोटिंग पॉइंट नंबरों द्वारा बिल्कुल प्रदर्शित नहीं किया जा सकता है।
round() — Built-in Functions — Python 3.10.2 Documentation

यदि आप दशमलव को सम संख्याओं में सामान्य पूर्णांकन या सटीक गोलाई प्राप्त करना चाहते हैं, तो आप मानक पुस्तकालय दशमलव परिमाणीकरण (नीचे वर्णित) का उपयोग कर सकते हैं या एक नया फ़ंक्शन परिभाषित कर सकते हैं।

यह भी ध्यान दें कि पायथन 2 में राउंड () एक सम संख्या के लिए गोल नहीं है, बल्कि गोल है।

मानक पुस्तकालय दशमलव का परिमाणीकरण ()

मानक पुस्तकालय के दशमलव मॉड्यूल का उपयोग सटीक दशमलव फ़्लोटिंग पॉइंट नंबरों को संभालने के लिए किया जा सकता है।

• decimal — Decimal fixed point and floating point arithmetic — Python 3.10.2 Documentation

दशमलव मॉड्यूल की मात्रा () विधि का उपयोग करके, पूर्णांकन मोड निर्दिष्ट करके संख्याओं को गोल करना संभव है।

• decimal quantize() — Decimal fixed point and floating point arithmetic — Python 3.10.2 Documentation
• Rounding modes — Decimal fixed point and floating point arithmetic — Python 3.10.2 Documentation

परिमाणीकरण () विधि के आर्ग्युमेंट राउंडिंग के लिए निर्धारित मानों के क्रमशः निम्नलिखित अर्थ हैं।

• ROUND_HALF_UP:सामान्य गोलाई
• ROUND_HALF_EVEN:सम संख्याओं तक गोलाई

दशमलव मॉड्यूल एक मानक पुस्तकालय है, इसलिए कोई अतिरिक्त स्थापना की आवश्यकता नहीं है, लेकिन आयात करना आवश्यक है।

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

दशमलव वस्तु बनाना

दशमलव () का उपयोग दशमलव प्रकार की वस्तुओं को बनाने के लिए किया जा सकता है।

यदि आप एक फ्लोट प्रकार को तर्क के रूप में निर्दिष्ट करते हैं, तो आप देख सकते हैं कि मूल्य वास्तव में किस प्रकार माना जाता है।

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

print(type(Decimal(0.05)))
# <class 'decimal.Decimal'>

जैसा कि उदाहरण में दिखाया गया है, 0.05 को ठीक 0.05 के रूप में नहीं माना जाता है। यही कारण है कि ऊपर वर्णित बिल्ट-इन फ़ंक्शन राउंड () उदाहरण में 0.05 सहित दशमलव मानों के लिए अपेक्षा से भिन्न मान के लिए गोल है।

चूंकि 0.5 आधा है (2 की -1 शक्ति), इसे बाइनरी नोटेशन में बिल्कुल व्यक्त किया जा सकता है।

print(Decimal(0.5))
# 0.5

यदि आप फ्लोट प्रकार के बजाय स्ट्रिंग प्रकार str निर्दिष्ट करते हैं, तो इसे सटीक मान के दशमलव प्रकार के रूप में माना जाएगा।

print(Decimal('0.05'))
# 0.05

दशमलव को किसी भी संख्या में पूर्णांकित करना और सम संख्याओं को पूर्णांकित करना

दशमलव प्रकार की वस्तु से मूल्य को पूर्णांकित करने के लिए परिमाणित करें () को कॉल करें।

क्वांटिज़ () का पहला तर्क एक स्ट्रिंग है जिसमें अंकों की संख्या उतनी ही होती है, जितने अंक आप खोजना चाहते हैं, जैसे कि ‘0.1’ या ‘0.01’।

इसके अलावा, तर्क राउंडिंग राउंडिंग मोड को निर्दिष्ट करता है; यदि ROUND_HALF_UP निर्दिष्ट है, तो सामान्य गोलाई का उपयोग किया जाता है।

f = 123.456

print(Decimal(str(f)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
# 123

print(Decimal(str(f)).quantize(Decimal('0.1'), rounding=ROUND_HALF_UP))
# 123.5

print(Decimal(str(f)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 123.46

बिल्ट-इन फंक्शन राउंड () के विपरीत, 0.5 को 1 तक गोल किया जाता है।

print('0.4 =>', Decimal(str(0.4)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
print('0.5 =>', Decimal(str(0.5)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
print('0.6 =>', Decimal(str(0.6)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
# 0.4 => 0
# 0.5 => 1
# 0.6 => 1

यदि आर्ग्युमेंट राउंडिंग को ROUND_HALF_EVEN पर सेट किया जाता है, तो बिल्ट-इन फंक्शन राउंड () की तरह, राउंडिंग को सम संख्याओं में भी किया जाता है।

जैसा कि ऊपर उल्लेख किया गया है, यदि एक फ्लोटिंग-पॉइंट फ्लोट प्रकार को दशमलव () के तर्क के रूप में निर्दिष्ट किया जाता है, तो इसे एक दशमलव वस्तु के रूप में माना जाता है, जिसका मान फ्लोट प्रकार के वास्तविक मूल्य के बराबर होता है, इसलिए मात्रा का उपयोग करने का परिणाम () विधि अपेक्षा से भिन्न होगी, ठीक उसी तरह जैसे बिल्ट-इन फंक्शन राउंड ()।

print('0.05 =>', round(0.05, 1))
print('0.15 =>', round(0.15, 1))
print('0.25 =>', round(0.25, 1))
print('0.35 =>', round(0.35, 1))
print('0.45 =>', round(0.45, 1))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

print('0.05 =>', Decimal(0.05).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.15 =>', Decimal(0.15).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.25 =>', Decimal(0.25).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.35 =>', Decimal(0.35).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.45 =>', Decimal(0.45).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

यदि दशमलव () के तर्क को स्ट्रिंग प्रकार की स्ट्रिंग के रूप में निर्दिष्ट किया जाता है, तो इसे ठीक उसी मान की दशमलव वस्तु के रूप में माना जाता है, इसलिए परिणाम अपेक्षित है।

print('0.05 =>', Decimal(str(0.05)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.15 =>', Decimal(str(0.15)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.25 =>', Decimal(str(0.25)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.35 =>', Decimal(str(0.35)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.45 =>', Decimal(str(0.45)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
# 0.05 => 0.0
# 0.15 => 0.2
# 0.25 => 0.2
# 0.35 => 0.4
# 0.45 => 0.4

चूंकि 0.5 को फ्लोट प्रकार द्वारा सही ढंग से नियंत्रित किया जा सकता है, इसलिए फ्लोट प्रकार को दशमलव () के तर्क के रूप में निर्दिष्ट करने में कोई समस्या नहीं है, जब पूर्णांक को गोल किया जाता है, लेकिन दशमलव स्थान पर गोल करते समय स्ट्रिंग str प्रकार को निर्दिष्ट करना सुरक्षित होता है।

उदाहरण के लिए, फ्लोट प्रकार में 2.675 वास्तव में 2.67499… है। इसलिए, यदि आप दो दशमलव स्थानों तक चक्कर लगाना चाहते हैं, तो आपको दशमलव () के लिए एक स्ट्रिंग निर्दिष्ट करनी होगी, अन्यथा परिणाम अपेक्षित परिणाम से भिन्न होगा, चाहे आप निकटतम पूर्ण संख्या (ROUND_HALF_UP) या सम संख्या (ROUND_HALF_EVEN) पर गोल करें। )

print(Decimal(2.675))
# 2.67499999999999982236431605997495353221893310546875

print(Decimal(2.675).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 2.67

print(Decimal(str(2.675)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 2.68

print(Decimal(2.675).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN))
# 2.67

print(Decimal(str(2.675)).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN))
# 2.68

ध्यान दें कि क्वांटिज़ () विधि एक दशमलव प्रकार संख्या लौटाती है, इसलिए यदि आप एक फ्लोट प्रकार संख्या पर काम करना चाहते हैं, तो आपको इसे फ्लोट () का उपयोग करके एक फ्लोट प्रकार में बदलने की आवश्यकता है, अन्यथा एक त्रुटि होगी।

d = Decimal('123.456').quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)

print(d)
# 123.46

print(type(d))
# <class 'decimal.Decimal'>

# print(1.2 + d)
# TypeError: unsupported operand type(s) for +: 'float' and 'decimal.Decimal'

print(1.2 + float(d))
# 124.66

पूर्णांकों को किसी भी संख्या में पूर्णांकित करना और सम संख्याओं को पूर्णांकित करना

यदि आप एक पूर्णांक अंक तक गोल करना चाहते हैं, तो पहले तर्क के रूप में ’10’ जैसा कुछ निर्दिष्ट करने से आपको वांछित परिणाम नहीं मिलेगा।

i = 99518

print(Decimal(i).quantize(Decimal('10'), rounding=ROUND_HALF_UP))
# 99518

ऐसा इसलिए है क्योंकि परिमाण () दशमलव वस्तु के प्रतिपादक के अनुसार गोलाई करता है, लेकिन दशमलव (’10’) का प्रतिपादक 0 है, 1 नहीं।

आप एक घातांक स्ट्रिंग (जैसे, ‘1E1’) के रूप में E का उपयोग करके एक मनमाना घातांक निर्दिष्ट कर सकते हैं। एक्सपोनेंट एक्सपोनेंट को as_tuple विधि में चेक किया जा सकता है।

print(Decimal('10').as_tuple())
# DecimalTuple(sign=0, digits=(1, 0), exponent=0)

print(Decimal('1E1').as_tuple())
# DecimalTuple(sign=0, digits=(1,), exponent=1)

वैसे भी, परिणाम ई का उपयोग करके घातीय संकेतन में होगा। यदि आप सामान्य नोटेशन का उपयोग करना चाहते हैं, या यदि आप पूर्णांक के साथ पूर्णांक int प्रकार के साथ काम करना चाहते हैं, तो परिणाम को परिवर्तित करने के लिए int() का उपयोग करें।

print(Decimal(i).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP))
# 9.952E+4

print(int(Decimal(i).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
# 99520

print(int(Decimal(i).quantize(Decimal('1E2'), rounding=ROUND_HALF_UP)))
# 99500

print(int(Decimal(i).quantize(Decimal('1E3'), rounding=ROUND_HALF_UP)))
# 100000

यदि आर्ग्युमेंट राउंडिंग को ROUND_HALF_UP पर सेट किया जाता है, तो सामान्य राउंडिंग होगी, उदा., 5 को 10 पर पूर्णांकित किया जाएगा।

print('4 =>', int(Decimal(4).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
print('5 =>', int(Decimal(5).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
print('6 =>', int(Decimal(6).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
# 4 => 0
# 5 => 10
# 6 => 10

बेशक, यदि आप इसे एक स्ट्रिंग के रूप में निर्दिष्ट करते हैं तो कोई समस्या नहीं है।

एक नया फ़ंक्शन परिभाषित करें

दशमलव मॉड्यूल का उपयोग करने की विधि सटीक और सुरक्षित है, लेकिन यदि आप टाइप रूपांतरण के साथ सहज नहीं हैं, तो आप सामान्य राउंडिंग प्राप्त करने के लिए एक नया फ़ंक्शन परिभाषित कर सकते हैं।

ऐसा करने के कई संभावित तरीके हैं, उदाहरण के लिए, निम्नलिखित फ़ंक्शन।

def my_round(val, digit=0):
    p = 10 ** digit
    return (val * p * 2 + 1) // 2 / p

यदि आपको अंकों की संख्या निर्दिष्ट करने और हमेशा पहले दशमलव स्थान पर गोल करने की आवश्यकता नहीं है, तो आप एक सरल रूप का उपयोग कर सकते हैं।

my_round_int = lambda x: int((x * 2 + 1) // 2)

यदि आपको सटीक होना है, तो दशमलव का उपयोग करना सुरक्षित है।

निम्नलिखित केवल संदर्भ के लिए है।

दशमलव को किसी भी संख्या में पूर्णांकित करें।

print(int(my_round(f)))
# 123

print(my_round_int(f))
# 123

print(my_round(f, 1))
# 123.5

print(my_round(f, 2))
# 123.46

राउंड के विपरीत, 0.5 सामान्य राउंडिंग के अनुसार 1 हो जाता है।

print(int(my_round(0.4)))
print(int(my_round(0.5)))
print(int(my_round(0.6)))
# 0
# 1
# 1

अंकों की किसी भी संख्या के लिए गोल पूर्णांक

i = 99518

print(int(my_round(i, -1)))
# 99520

print(int(my_round(i, -2)))
# 99500

print(int(my_round(i, -3)))
# 100000

राउंड के विपरीत, 5 सामान्य राउंडिंग के अनुसार 10 हो जाता है।

print(int(my_round(4, -1)))
print(int(my_round(5, -1)))
print(int(my_round(6, -1)))
# 0
# 10
# 10

नोट: ऋणात्मक मानों के लिए

उपरोक्त उदाहरण फ़ंक्शन में, -0.5 को 0 पर गोल किया गया है।

print(int(my_round(-0.4)))
print(int(my_round(-0.5)))
print(int(my_round(-0.6)))
# 0
# 0
# -1

ऋणात्मक मानों के लिए पूर्णांकन के बारे में सोचने के कई तरीके हैं, लेकिन यदि आप -0.5 को -1 बनाना चाहते हैं, तो आप इसे निम्नानुसार संशोधित कर सकते हैं, उदाहरण के लिए

import math

def my_round2(val, digit=0):
    p = 10 ** digit
    s = math.copysign(1, val)
    return (s * val * p * 2 + 1) // 2 / p * s

print(int(my_round2(-0.4)))
print(int(my_round2(-0.5)))
print(int(my_round2(-0.6)))
# 0
# -1
# -1