Python मा “round” र “decimal.quantize सँग दशमलव र पूर्णाङ्कहरू गोलाकार गर्दै

निम्नले पाइथनमा अंकहरूलाई समान संख्यामा राउन्डिङ वा राउन्डिङ गरेर कसरी गोल गर्ने भनेर वर्णन गर्दछ। संख्याहरू फ्लोटिंग पोइन्ट फ्लोट वा पूर्णांक int प्रकारको मानिन्छ।

• बिल्ट-इन प्रकार्य (जस्तै प्रोग्रामिङ भाषामा):round()
  • अंकहरूको कुनै पनि संख्यामा दशमलव गोल गर्नुहोस्।
  • अंकहरूको कुनै पनि संख्यामा पूर्णांकहरू राउन्ड गर्नुहोस्।
  • round() सम संख्यामा राउन्ड हुन्छ, सामान्य राउन्डिङमा होइन
• मानक पुस्तकालयdecimalquantize()
  • Decimalवस्तु सिर्जना गर्दै
  • अंकको कुनै पनि संख्यामा दशमलवको राउन्डिङ र सम संख्याहरूमा राउन्डिङ
  • अंकहरूको कुनै पनि सङ्ख्यामा पूर्णाङ्कहरूको राउन्डिङ र सम संख्याहरूमा राउन्डिङ
• नयाँ प्रकार्य परिभाषित गर्नुहोस्
  • अंकको कुनै पनि संख्यामा दशमलव बन्द गर्नुहोस्।
  • अंकहरूको कुनै पनि संख्यामा पूर्णांकहरू राउन्ड गर्नुहोस्
  • नोट: नकारात्मक मानहरूको लागि

ध्यान दिनुहोस् कि, माथि उल्लेख गरिए अनुसार, बिल्ट-इन प्रकार्य राउन्ड सामान्य राउन्डिङ होइन, तर सम संख्यामा राउन्डिङ हो। विवरणका लागि तल हेर्नुहोस्।

बिल्ट-इन प्रकार्य (जस्तै प्रोग्रामिङ भाषामा):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

round() सम संख्यामा राउन्ड हुन्छ, सामान्य राउन्डिङमा होइन

ध्यान दिनुहोस् कि पाइथन 3 राउन्डमा बिल्ट-इन राउन्ड() प्रकार्यको साथ राउन्डिङले सम संख्यामा घुमाउँछ, सामान्य राउन्डिङमा होइन।

आधिकारिक कागजातमा लेखिए अनुसार, ०.५ लाई ० मा राउन्ड गरिएको छ, ५ लाई ० मा राउन्ड गरिएको छ, र यस्तै।

• 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

सम संख्यामा राउन्डिङको परिभाषा निम्नानुसार छ।

यदि अंश ०.५ भन्दा कम छ भने, यसलाई तल घुमाउनुहोस्; यदि अंश ०.५ भन्दा ठूलो छ भने, यसलाई गोलो बनाउनुहोस्; यदि अंश ठ्याक्कै ०.५ छ भने, तल राउन्डिङ र राउन्डिङ अप बीचको सम संख्यामा गोल गर्नुहोस्।
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

यदि तपाइँ सामान्य राउन्डिङ वा दशमलवको सही राउन्डिङ प्राप्त गर्न चाहनुहुन्छ भने, तपाइँ मानक पुस्तकालय दशमलव क्वान्टाइज (तल वर्णन गरिएको) वा नयाँ प्रकार्य परिभाषित गर्न सक्नुहुन्छ।

यो पनि ध्यान दिनुहोस् कि Python 2 मा round() सम संख्यामा राउन्डिङ होइन, तर rounding हो।

मानक पुस्तकालय दशमलव को quantize()

मानक पुस्तकालयको दशमलव मोड्युल सही दशमलव फ्लोटिंग बिन्दु संख्याहरू ह्यान्डल गर्न प्रयोग गर्न सकिन्छ।

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

दशमलव मोड्युलको quantize() विधि प्रयोग गरेर, राउन्डिङ मोड निर्दिष्ट गरेर अंकहरू गोल गर्न सम्भव छ।

• 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

quantize() विधिको तर्क राउन्डिङका लागि सेट मानहरू क्रमशः निम्न अर्थहरू छन्।

• 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'>

उदाहरणमा देखाइए अनुसार, ०.०५ लाई ठीक ०.०५ मानिदैन। यही कारणले गर्दा माथि वर्णन गरिएको बिल्ट-इन प्रकार्य राउन्ड() उदाहरणमा ०.०५ सहित दशमलव मानहरूको लागि अपेक्षा गरिएको भन्दा फरक मानमा राउन्ड गरिएको छ।

०.५ एक आधा (२ को -१ पावर) भएको हुनाले, यसलाई बाइनरी नोटेशनमा ठ्याक्कै व्यक्त गर्न सकिन्छ।

print(Decimal(0.5))
# 0.5

यदि तपाईंले फ्लोट प्रकारको सट्टा स्ट्रिङ प्रकार str निर्दिष्ट गर्नुभयो भने, यसलाई सही मानको दशमलव प्रकारको रूपमा व्यवहार गरिनेछ।

print(Decimal('0.05'))
# 0.05

अंकको कुनै पनि संख्यामा दशमलवको राउन्डिङ र सम संख्याहरूमा राउन्डिङ

मान राउन्ड अफ गर्न दशमलव प्रकारको वस्तुबाट quantize() कल गर्नुहोस्।

quantize() को पहिलो तर्क भनेको तपाईले फेला पार्न चाहनुहुने अंकहरूको संख्या जस्तै ‘०.१’ वा ‘०.०१’ जस्तै अंकहरूको संख्या भएको स्ट्रिङ हो।

थप रूपमा, तर्क ROUNDING ले राउन्डिङ मोड निर्दिष्ट गर्दछ; यदि 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 मा सेट गरिएको छ भने, बिल्ट-इन प्रकार्य राउन्ड() मा जस्तै सम संख्याहरूमा राउन्डिङ गरिन्छ।

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

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

यदि दशमलव() को तर्क str प्रकारको स्ट्रिङको रूपमा निर्दिष्ट गरिएको छ भने, यसलाई ठ्याक्कै त्यो मानको दशमलव वस्तुको रूपमा व्यवहार गरिन्छ, त्यसैले परिणाम अपेक्षित रूपमा हुन्छ।

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

ध्यान दिनुहोस् कि quantize() विधिले दशमलव प्रकार संख्या फर्काउँछ, त्यसैले यदि तपाइँ फ्लोट प्रकार नम्बरमा काम गर्न चाहनुहुन्छ भने, तपाइँ यसलाई फ्लोट () प्रयोग गरेर फ्लोट प्रकारमा रूपान्तरण गर्न आवश्यक छ, अन्यथा त्रुटि देखा पर्नेछ।

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

यो ’cause quantize() ले दशमलव वस्तुको घातांक अनुसार राउन्डिङ गर्छ, तर दशमलव(’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)

यो जस्तो छ, परिणाम E प्रयोग गरी घातांक अंकमा हुनेछ। यदि तपाइँ सामान्य नोटेशन प्रयोग गर्न चाहनुहुन्छ भने, वा यदि तपाइँ राउन्डिङ पछि पूर्णांक 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

राउन्डको विपरीत, ०.५ सामान्य राउन्डिङ अनुसार १ बन्छ।

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

नोट: नकारात्मक मानहरूको लागि

माथिको उदाहरण प्रकार्यमा, -०.५ लाई ० मा राउन्ड गरिएको छ।

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

नकारात्मक मानहरूको लागि राउन्डिङ ’bout सोच्ने विभिन्न तरिकाहरू छन्, तर यदि तपाइँ -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