Python मध्ये “round” आणि “decimal.quantize” मध्ये दशांश आणि पूर्णांक पूर्ण करणे

पायथनमधील संख्यांना सम संख्येवर गोलाकार किंवा गोलाकार करून कसे पूर्ण करायचे ते खाली स्पष्ट केले आहे. संख्या फ्लोटिंग पॉइंट फ्लोट किंवा पूर्णांक इंट प्रकारातील असल्याचे गृहित धरले जाते.

• अंगभूत कार्य (उदा. प्रोग्रामिंग भाषेत):round()
  • अंकांच्या कोणत्याही संख्येसाठी दशांश गोल.
  • अंकांच्या कोणत्याही संख्येसाठी पूर्णांक पूर्णांक.
  • round() सम संख्‍येला राउंड करते, सामाईक राउंडिंगला नाही
• मानक लायब्ररीdecimalquantize()
  • Decimalएखादी वस्तू तयार करणे
  • अंकांच्या कोणत्याही संख्येसाठी दशांशांचे पूर्णांक आणि सम संख्यांवर पूर्णांक करणे
  • अंकांच्या कोणत्याही संख्येवर पूर्णांकांचे पूर्णांक आणि सम संख्यांना पूर्णांक करणे
• नवीन कार्य परिभाषित करा
  • अंकांच्या कोणत्याही संख्येवर दशांश बंद करा.
  • अंकांच्या कोणत्याही संख्येसाठी पूर्णांक पूर्णांक
  • टीप: नकारात्मक मूल्यांसाठी

लक्षात घ्या की, वर नमूद केल्याप्रमाणे, अंगभूत फंक्शन राउंड हे सर्वसाधारण राउंडिंग नसून सम संख्येचे पूर्णांक आहे. तपशीलांसाठी खाली पहा.

अंगभूत कार्य (उदा. प्रोग्रामिंग भाषेत):round()

Round() अंगभूत फंक्शन म्हणून प्रदान केले आहे. हे कोणतेही मॉड्यूल आयात न करता वापरले जाऊ शकते.

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

पहिला युक्तिवाद मूळ संख्या आहे, आणि दुसरा युक्तिवाद अंकांची संख्या आहे (किती अंकांना पूर्ण करायचे आहे).

अंकांच्या कोणत्याही संख्येसाठी दशांश गोल.

फ्लोटिंग-पॉइंट फ्लोट प्रकारासाठी प्रक्रिया करण्याचे खालील उदाहरण आहे.

जर दुसरा युक्तिवाद वगळला असेल, तर तो पूर्णांकावर पूर्ण केला जातो. प्रकार देखील पूर्णांक इंट प्रकार बनतो.

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

अंकांच्या कोणत्याही संख्येसाठी पूर्णांक पूर्णांक.

खालील पूर्णांक इंट प्रकारासाठी प्रक्रिया करण्याचे उदाहरण आहे.

जर दुसरा युक्तिवाद वगळला असेल, किंवा 0 किंवा सकारात्मक पूर्णांक निर्दिष्ट केला असेल, तर मूळ मूल्य जसे आहे तसे परत केले जाईल. ऋण पूर्णांक निर्दिष्‍ट केला असल्‍यास, तो संबंधित पूर्णांक अंकावर गोलाकार केला जातो. दोन्ही प्रकरणांमध्ये, पूर्णांक इंट प्रकार परत केला जातो.

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() सम संख्‍येला राउंड करते, सामाईक राउंडिंगला नाही

लक्षात घ्या की Python 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 पेक्षा जास्त असेल, तर त्यास गोल करा; जर अपूर्णांक अगदी ०.५ असेल, तर त्यास खाली आणि पूर्णांक दरम्यान सम संख्येपर्यंत पूर्ण करा.
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

दशांश वस्तू तयार करणे

Decimal() दशांश प्रकारातील ऑब्जेक्ट्स तयार करण्यासाठी वापरला जाऊ शकतो.

तुम्ही वितर्क म्हणून फ्लोट प्रकार निर्दिष्ट केल्यास, मूल्य प्रत्यक्षात काय मानले जाते ते तुम्ही पाहू शकता.

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

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

उदाहरणात दाखवल्याप्रमाणे, ०.०५ ला ०.०५ असे मानले जात नाही. हेच कारण आहे की वर वर्णन केलेले अंगभूत फंक्शन round() उदाहरणातील 0.05 च्या समावेशासह दशांश मूल्यांसाठी अपेक्षेपेक्षा भिन्न मूल्यावर गोलाकार केले आहे.

0.5 हा अर्धा (2 ची -1 पॉवर) असल्याने, ते बायनरी नोटेशनमध्ये अचूकपणे व्यक्त केले जाऊ शकते.

print(Decimal(0.5))
# 0.5

तुम्ही फ्लोट प्रकाराऐवजी स्ट्रिंग प्रकार str निर्दिष्ट केल्यास, तो अचूक मूल्याचा दशांश प्रकार मानला जाईल.

print(Decimal('0.05'))
# 0.05

अंकांच्या कोणत्याही संख्येसाठी दशांशांचे पूर्णांक आणि सम संख्यांवर पूर्णांक करणे

व्हॅल्यू पूर्ण करण्यासाठी दशांश प्रकारच्या ऑब्जेक्टवरून quantize() ला कॉल करा.

quantize() चा पहिला आर्ग्युमेंट म्हणजे ‘0.1’ किंवा ‘0.01’ सारख्या अंकांची संख्या जितक्या अंकांची संख्या आहे तितक्याच अंकांची स्ट्रिंग आहे.

याव्यतिरिक्त, 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() पद्धत दशांश प्रकार क्रमांक मिळवते, त्यामुळे जर तुम्हाला फ्लोट प्रकार क्रमांकावर ऑपरेट करायचे असेल, तर तुम्हाला float() वापरून फ्लोट प्रकारात रूपांतरित करावे लागेल, अन्यथा त्रुटी येईल.

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

याचे कारण म्हणजे 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

टीप: नकारात्मक मूल्यांसाठी

वरील उदाहरण फंक्शनमध्ये, -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