পাইথনে বৃত্তাকার দশমিক এবং পূর্ণসংখ্যাকে “বৃত্তাকার” এবং “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-এ অন্তর্নির্মিত রাউন্ড() ফাংশনের সাথে রাউন্ডিং একটি জোড় সংখ্যায় রাউন্ড করে, সাধারণ রাউন্ডিংয়ে নয়।

অফিসিয়াল ডকুমেন্টেশনে যেমন লেখা আছে, 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-এ round() একটি জোড় সংখ্যায় রাউন্ডিং নয়, কিন্তু রাউন্ডিং।

মান লাইব্রেরি দশমিক এর 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

কোয়ান্টাইজ() পদ্ধতির আর্গুমেন্ট রাউন্ডিংয়ের জন্য সেট মানগুলির যথাক্রমে নিম্নলিখিত অর্থ রয়েছে।

• ROUND_HALF_UP:সাধারণ রাউন্ডিং
• ROUND_HALF_EVEN:জোড় সংখ্যায় রাউন্ডিং

দশমিক মডিউল একটি আদর্শ লাইব্রেরি, তাই কোন অতিরিক্ত ইনস্টলেশন প্রয়োজন হয় না, কিন্তু আমদানি করা আবশ্যক।

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

একটি দশমিক বস্তু তৈরি করা

Decimal() Decimal টাইপের অবজেক্ট তৈরি করতে ব্যবহার করা যেতে পারে।

আপনি যদি একটি আর্গুমেন্ট হিসাবে একটি ফ্লোট টাইপ নির্দিষ্ট করেন, তাহলে আপনি দেখতে পাবেন যে মানটিকে আসলে কী হিসাবে বিবেচনা করা হয়।

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

যদি Decimal() এর আর্গুমেন্টটি 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 সঠিকভাবে ফ্লোট টাইপ দ্বারা পরিচালনা করা যেতে পারে, তাই পূর্ণসংখ্যাতে রাউন্ডিং করার সময় ফ্লোট টাইপটিকে দশমিক() এর আর্গুমেন্ট হিসাবে নির্দিষ্ট করতে কোন সমস্যা নেই, তবে দশমিক স্থানে রাউন্ডিং করার সময় স্ট্রিং স্ট্র টাইপ নির্দিষ্ট করা নিরাপদ।

উদাহরণস্বরূপ, 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

রাউন্ডের বিপরীতে, সাধারণ রাউন্ডিং অনুসারে 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