শিরোনামের পরামর্শ অনুসারে, আমি একটি ভাসমান পয়েন্ট নম্বর নিয়ে এটিকে নিকটতম পূর্ণসংখ্যার কাছে গোল করতে চাই। তবে এটি যদি পুরো না হয় তবে পরবর্তী সংখ্যার যতই কাছাকাছি থাকুক না কেন, আমি সবসময় চলকটিকে সরিয়ে নিতে চাই। এই কাজ করতে একটি উপায় আছে কি?
শিরোনামের পরামর্শ অনুসারে, আমি একটি ভাসমান পয়েন্ট নম্বর নিয়ে এটিকে নিকটতম পূর্ণসংখ্যার কাছে গোল করতে চাই। তবে এটি যদি পুরো না হয় তবে পরবর্তী সংখ্যার যতই কাছাকাছি থাকুক না কেন, আমি সবসময় চলকটিকে সরিয়ে নিতে চাই। এই কাজ করতে একটি উপায় আছে কি?
উত্তর:
সহজ
print int(x)
পাশাপাশি কাজ করবে।
int(-23.3) == 23
এর মধ্যে একটিতে কাজ করা উচিত:
import math
math.trunc(1.5)
> 1
math.trunc(-1.5)
> -1
math.floor(1.5)
> 1
math.floor(-1.5)
> -2
math.trunc
একটি পূর্ণসংখ্যা, যখন আউটপুটটি math.floor
একটি ভাসা।
type(math.floor(1.51)) -> int
এবং type(math.trunc(1.51)) -> int
হিসাবেpython 3.6.0
x//1
//
অপারেটর বিভাগের মেঝে ফেরৎ। যেহেতু 1 দ্বারা ভাগ করা আপনার নম্বর পরিবর্তন করে না, এটি তল সমতুল্য তবে কোনও আমদানির প্রয়োজন নেই। মন্তব্য:
int(-1.1) == -1
যখন -1.1//1 == -2.0
যাইহোক decimal.Decimal('-1.1')//1 == decimal.Decimal('-1')
(যেমন নথিভুক্ত, দাবির 2 না জন্য সত্য decimal
), তাই কিভাবে উপর নির্ভর //
আচরণ করবে সম্পূর্ণরূপে স্থিতিশীল, আজও নেই।
আমি মনে করি আপনার একটি মেঝে ফাংশন প্রয়োজন:
প্রচুর লোক ব্যবহার করতে বলে int(x)
এবং এটি বেশিরভাগ ক্ষেত্রেই ঠিক কাজ করে তবে কিছুটা সমস্যা আছে। যদি ওপির ফলাফল হয়:
x = 1.9999999999999999
এটি গোল হয়ে যাবে
x = 2
16 ম 9 এর পরে এটি গোল হয়ে যাবে। আপনি যদি নিশ্চিত হন যে আপনি কখনই এ জাতীয় জিনিসটি দেখতে পাবেন না এটি কোনও বড় বিষয় নয়। তবে এটি মনে রাখা কিছু।
1.9999999999999999
পক্ষে আসলে সমান 2.0
। আই। ই। এটি একটি ফ্লোটে পার্স হওয়ার সাথে সাথে এটি ইতিমধ্যে গোল হয়ে গেছে, যেহেতু একটি 64 বিট ফ্লোট সেই অনেকগুলি উল্লেখযোগ্য অঙ্ক উপস্থাপন করতে পারে না। আপনি মূল্যায়ন সহ যাচাই করতে পারেন 1.9999999999999999 == 2.0
। এবং যদি আপনার সন্দেহ হয় যে সমান অপারেশনটি ফ্লোটগুলিতে কিছু গোল করে তবে আপনি বাইনারি প্রতিনিধিত্বের সাথে তুলনা করতে পারেন struct.pack("d", 1.9999999999999999) == struct.pack("d", 2.0)
যা সমান।
int()
। মানটি ইতিমধ্যে ২.০ এবং এটি এটিকে আনন্দের সাথে ২ তে রূপান্তরিত করবে
int()
, এটা একমাত্র একটি কি আছে এর অযথাযথ ব্যবহারেরfloat
, যেমন 1.9999999999999999
পর্যন্ত বৃত্তাকার হয় 2.0
কম্পাইল সময়ে (যখন int()
সঞ্চালনের সময় উপর বলা হয়)। আপনি যদি ভেরিয়েবলের জন্য সঠিক ডেটা টাইপ ব্যবহার করেন তবে সবকিছু প্রত্যাশার মতো কাজ করে: int(decimal.Decimal('1.9999999999999999999999999999999999999999999999999999999'))
দেয়1
আপনি যদি গণিত আমদানি করতে না চান তবে আপনি ব্যবহার করতে পারেন:
int(round(x))
এখানে ডকুমেন্টেশনের একটি অংশ রয়েছে:
>>> help(round)
Help on built-in function round in module __builtin__:
round(...)
round(number[, ndigits]) -> floating point number
Round a number to a given precision in decimal digits (default 0 digits).
This always returns a floating point number. Precision may be negative.
round
এক বছর আগে এই প্রশ্নটি জিজ্ঞাসা করা হলে উত্তর হিসাবে ইতিমধ্যে আলোচনা করা হয়েছিল এবং প্রত্যাখ্যান করা হয়েছিল। ওপি চায় math.floor
।
আপনি যদি নাম্পের সাথে কাজ করে থাকেন তবে আপনি নিম্নলিখিত সমাধানটি ব্যবহার করতে পারেন যা নেতিবাচক সংখ্যার সাথেও কাজ করে (এটি অ্যারেতেও কাজ করছে)
import numpy as np
def round_down(num):
if num < 0:
return -np.ceil(abs(num))
else:
return np.int32(num)
round_down = np.vectorize(round_down)
round_down([-1.1, -1.5, -1.6, 0, 1.1, 1.5, 1.6])
> array([-2., -2., -2., 0., 1., 1., 1.])
আমি মনে করি এটি কেবল কাজ করবে যদি আপনি কেবল math
মডিউলটির পরিবর্তে মডিউলটি ব্যবহার করেন numpy
।
কেবল গোলাকার (x-0.5) তৈরি করুন এটি আপনার ফ্লোটের পরবর্তী গোলাকৃত ডাউন ইন্টিজার মানটি সর্বদা ফিরে আসবে। আপনি সহজেই ড রাউন্ড দ্বারা রাউন্ড আপ করতে পারেন (x + 0.5)
এটি খুব সহজ হতে পারে, তবে আপনি কেবল এটি বিয়োগ 1 এর পরেও করতে পারছেন না? উদাহরণ স্বরূপ:
number=1.5
round(number)-1
> 1
integer
।
আমি এই কোডটি ব্যবহার করেছি যেখানে আপনি সংখ্যা থেকে 0.5 বিয়োগ করেন এবং আপনি যখন এটি গোল করেন, এটি মূল সংখ্যাটি গোল হয়।
বৃত্তাকার (ক-0.5)