Python માં દશાંશ અને પૂર્ણાંકોને “round” અને “decimal.quantize” સાથે રાઉન્ડિંગ

નીચે આપેલ સમજાવે છે કે કેવી રીતે Python માં સંખ્યાઓને ગોળાકાર કરીને અથવા એક સમાન સંખ્યા પર ગોળાકાર કરી શકાય. સંખ્યાઓ ફ્લોટિંગ પોઈન્ટ ફ્લોટ અથવા પૂર્ણાંક પૂર્ણાંક પ્રકારનો હોવાનું માનવામાં આવે છે.

• બિલ્ટ-ઇન ફંક્શન (દા.ત. પ્રોગ્રામિંગ ભાષામાં):round()
  • અંકોની કોઈપણ સંખ્યા માટે ગોળ દશાંશ.
  • અંકોની કોઈપણ સંખ્યાના પૂર્ણાંકો.
  • રાઉન્ડ() એક સમાન સંખ્યા પર રાઉન્ડ કરે છે, સામાન્ય રાઉન્ડિંગ માટે નહીં
• પ્રમાણભૂત પુસ્તકાલયdecimalquantize()
  • Decimalઑબ્જેક્ટ બનાવવું
  • અંકોની કોઈપણ સંખ્યા માટે દશાંશનું ગોળાકાર અને સમ સંખ્યાઓ પર રાઉન્ડિંગ
  • અંકોની કોઈપણ સંખ્યા માટે પૂર્ણાંકોનું ગોળાકાર અને સમ સંખ્યાઓ પર રાઉન્ડિંગ
• નવું કાર્ય વ્યાખ્યાયિત કરો
  • અંકોની કોઈપણ સંખ્યા પર દશાંશને પૂર્ણ કરો.
  • અંકોની કોઈપણ સંખ્યા માટે ગોળ પૂર્ણાંક
  • નોંધ: નકારાત્મક મૂલ્યો માટે

નોંધ કરો કે, ઉપર સૂચવ્યા મુજબ, બિલ્ટ-ઇન ફંક્શન રાઉન્ડ એ સામાન્ય રાઉન્ડિંગ નથી, પરંતુ એક સમાન સંખ્યા માટે રાઉન્ડિંગ છે. વિગતો માટે નીચે જુઓ.

બિલ્ટ-ઇન ફંક્શન (દા.ત. પ્રોગ્રામિંગ ભાષામાં):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

રાઉન્ડ() એક સમાન સંખ્યા પર રાઉન્ડ કરે છે, સામાન્ય રાઉન્ડિંગ માટે નહીં

નોંધ કરો કે Python 3 માં બિલ્ટ-ઇન round() ફંક્શન સાથે રાઉન્ડિંગ એક સમાન સંખ્યા પર રાઉન્ડ કરે છે, સામાન્ય રાઉન્ડિંગમાં નહીં.

અધિકૃત દસ્તાવેજોમાં લખ્યા મુજબ, 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

જો તમે સામાન્ય ગોળાકાર અથવા દશાંશનું સચોટ ગોળાકાર સરખું નંબર મેળવવા માંગતા હો, તો તમે પ્રમાણભૂત લાઇબ્રેરી દશાંશ પરિમાણ (નીચે વર્ણવેલ) નો ઉપયોગ કરી શકો છો અથવા એક નવું કાર્ય વ્યાખ્યાયિત કરી શકો છો.

એ પણ નોંધ લો કે Python 2 માં round() એ સમ સંખ્યા પર રાઉન્ડિંગ નથી, પરંતુ રાઉન્ડિંગ છે.

પ્રમાણભૂત લાઇબ્રેરી દશાંશનું quantize()

સ્ટાન્ડર્ડ લાઇબ્રેરીના દશાંશ મોડ્યુલનો ઉપયોગ ચોક્કસ દશાંશ ફ્લોટિંગ પોઇન્ટ નંબરોને હેન્ડલ કરવા માટે કરી શકાય છે.

• 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

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

ઉદાહરણમાં બતાવ્યા પ્રમાણે, 0.05 ને બરાબર 0.05 તરીકે ગણવામાં આવતું નથી. આ જ કારણ છે કે ઉપર વર્ણવેલ બિલ્ટ-ઇન ફંક્શન રાઉન્ડ() ઉદાહરણમાં 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 પર સેટ કરેલ હોય, તો બિલ્ટ-ઇન ફંક્શન રાઉન્ડ() માં સમાન સંખ્યાઓ પર રાઉન્ડિંગ કરવામાં આવે છે.

ઉપર જણાવ્યા મુજબ, જો ફ્લોટિંગ-પોઇન્ટ ફ્લોટ પ્રકારને દશાંશ() ની દલીલ તરીકે ઉલ્લેખિત કરવામાં આવે છે, તો તેને ફ્લોટ પ્રકારના વાસ્તવિક મૂલ્યની સમાન કિંમત સાથે દશાંશ ઑબ્જેક્ટ તરીકે ગણવામાં આવે છે, તેથી ક્વોન્ટાઇઝ() નો ઉપયોગ કરવાનું પરિણામ બિલ્ટ-ઇન ફંક્શન રાઉન્ડ()ની જેમ જ પદ્ધતિ અપેક્ષિત છે તેનાથી અલગ હશે.

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 નથી.

તમે ઘાતાંક શબ્દમાળા તરીકે E નો ઉપયોગ કરીને મનસ્વી ઘાતાંકનો ઉલ્લેખ કરી શકો છો (દા.ત., ‘1E1’). ઘાતાંક ઘાતાંક 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

રાઉન્ડથી વિપરીત, સામાન્ય રાઉન્ડિંગ મુજબ 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