নিকটতম পূর্ণসংখ্যার নিচে একটি ভাসমান পয়েন্ট সংখ্যাটি গোল করবেন?


127

শিরোনামের পরামর্শ অনুসারে, আমি একটি ভাসমান পয়েন্ট নম্বর নিয়ে এটিকে নিকটতম পূর্ণসংখ্যার কাছে গোল করতে চাই। তবে এটি যদি পুরো না হয় তবে পরবর্তী সংখ্যার যতই কাছাকাছি থাকুক না কেন, আমি সবসময় চলকটিকে সরিয়ে নিতে চাই। এই কাজ করতে একটি উপায় আছে কি?


2
একটি সম্ভাব্য অসুবিধা হ'ল আইইইই ভাসমান পয়েন্ট ফর্ম্যাটগুলি এত বড় সংখ্যার প্রতিনিধিত্ব করতে পারে যে গ্র্যান্ডুলারিটি ১ এর চেয়ে বড় So
ডিএমকেকে --- প্রাক্তন মডারেটর বিড়ালছানা

কিছু উদাহরণ পোস্ট করুন।
অশ্বিনী চৌধুরী চৌধুরী

উত্তর:


178

সহজ

print int(x)

পাশাপাশি কাজ করবে।


7
int (0.6) = 0 1 এর পরিবর্তে
হেলিন ওয়াং

39
@ হেলিনওয়াং ঠিক ওপি এর অনুরোধ জানিয়েছিল।
পেট্র পেলার

5
এটি সর্বাধিক পাইথোনিক পদ্ধতির মতো বলে মনে হচ্ছে।
জ্ঞান বেদ

23
এটি ইতিবাচক সংখ্যার জন্য ভাল কাজ করে তবে নেতিবাচক সংখ্যাগুলি গোল হয়ে যাবে:int(-23.3) == 23
অ্যালেক্স রিলি

2
এবং পূর্ণসংখ্যার পরিসীমা যেমন 600851475143 এর বাইরে সংখ্যার জন্য কাজ করে না, এটি মূলত একটি স্মৃতি ত্রুটির পতাকাঙ্কিত করবে।
Muyide Ibukun

77

এর মধ্যে একটিতে কাজ করা উচিত:

import math
math.trunc(1.5)
> 1
math.trunc(-1.5)
> -1
math.floor(1.5)
> 1
math.floor(-1.5)
> -2

14
থেকে প্রাপ্ত আউটপুটটি math.truncএকটি পূর্ণসংখ্যা, যখন আউটপুটটি math.floorএকটি ভাসা।
ইভডোভেলি

6
@ ইভদভেল্লি: আসলেই আর হয় না। type(math.floor(1.51)) -> intএবং type(math.trunc(1.51)) -> intহিসাবেpython 3.6.0
এসকেপিএস

4
এই বিকল্পগুলি "ইনট (এক্স)" এর চেয়ে বেশি স্পষ্ট এবং তাই আরও পাইথোনিক।
ত্রিস্তান

44
x//1

//অপারেটর বিভাগের মেঝে ফেরৎ। যেহেতু 1 দ্বারা ভাগ করা আপনার নম্বর পরিবর্তন করে না, এটি তল সমতুল্য তবে কোনও আমদানির প্রয়োজন নেই। মন্তব্য:

  1. এটি একটি ভাসা ফিরে
  2. এই রাউন্ডে-towards

ভাল সংযোজন। int(-1.1) == -1যখন -1.1//1 == -2.0যাইহোক decimal.Decimal('-1.1')//1 == decimal.Decimal('-1')(যেমন নথিভুক্ত, দাবির 2 না জন্য সত্য decimal), তাই কিভাবে উপর নির্ভর //আচরণ করবে সম্পূর্ণরূপে স্থিতিশীল, আজও নেই।
টিনো

28

ভাসমান পয়েন্টের ফলাফল পেতে কেবল ব্যবহার করুন:

round(x-0.5)

এটি নেতিবাচক সংখ্যার জন্যও কাজ করে।


6
অত্যন্ত পরিশীলিত তা হ'ল
অ্যালন


9

প্রচুর লোক ব্যবহার করতে বলে int(x)এবং এটি বেশিরভাগ ক্ষেত্রেই ঠিক কাজ করে তবে কিছুটা সমস্যা আছে। যদি ওপির ফলাফল হয়:

x = 1.9999999999999999

এটি গোল হয়ে যাবে

x = 2

16 ম 9 এর পরে এটি গোল হয়ে যাবে। আপনি যদি নিশ্চিত হন যে আপনি কখনই এ জাতীয় জিনিসটি দেখতে পাবেন না এটি কোনও বড় বিষয় নয়। তবে এটি মনে রাখা কিছু।


17
এর কারণ অভ্যন্তরীণ ফ্লোট 64 প্রতিনিধিত্বের 1.9999999999999999পক্ষে আসলে সমান 2.0। আই। ই। এটি একটি ফ্লোটে পার্স হওয়ার সাথে সাথে এটি ইতিমধ্যে গোল হয়ে গেছে, যেহেতু একটি 64 বিট ফ্লোট সেই অনেকগুলি উল্লেখযোগ্য অঙ্ক উপস্থাপন করতে পারে না। আপনি মূল্যায়ন সহ যাচাই করতে পারেন 1.9999999999999999 == 2.0। এবং যদি আপনার সন্দেহ হয় যে সমান অপারেশনটি ফ্লোটগুলিতে কিছু গোল করে তবে আপনি বাইনারি প্রতিনিধিত্বের সাথে তুলনা করতে পারেন struct.pack("d", 1.9999999999999999) == struct.pack("d", 2.0)যা সমান।
blubberdiblub

4
এবং যদি এটি হ'ল আপনার বক্তব্য, তবে আমি কী দেখছি তাতে ভুল নেই int()। মানটি ইতিমধ্যে ২.০ এবং এটি এটিকে আনন্দের সাথে ২ তে রূপান্তরিত করবে
blubberdiblub

1
যদি ওপির (বা ভবিষ্যতে যারাই এটি পড়েন) উদ্দেশ্যটি যে কোনও কারণের জন্য নিকটতম পূর্ণসংখ্যার (এবং চূড়ান্ত মান নয়) ব্যবহার করা হয় তবে তা মনে রাখার মতো কিছু হবে।
লোকিলিন্দ

3
@lokilindo কিন্তু এই সঙ্গে কিছুই করার আছে int(), এটা একমাত্র একটি কি আছে এর অযথাযথ ব্যবহারেরfloat , যেমন 1.9999999999999999পর্যন্ত বৃত্তাকার হয় 2.0 কম্পাইল সময়ে (যখন int()সঞ্চালনের সময় উপর বলা হয়)। আপনি যদি ভেরিয়েবলের জন্য সঠিক ডেটা টাইপ ব্যবহার করেন তবে সবকিছু প্রত্যাশার মতো কাজ করে: int(decimal.Decimal('1.9999999999999999999999999999999999999999999999999999999'))দেয়1
টিনো

6

আপনি যদি গণিত আমদানি করতে না চান তবে আপনি ব্যবহার করতে পারেন:

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.

আপনার উত্তরের জন্য ধন্যবাদ. আপনি সঠিক কোড (নিকট বন্ধনী) লিখলে এবং কিছু ডকুমেন্টেশন দিলে পরবর্তী সময় আপনি আরও ভাল অভ্যর্থনা পাবেন।
জিওফ

2
roundএক বছর আগে এই প্রশ্নটি জিজ্ঞাসা করা হলে উত্তর হিসাবে ইতিমধ্যে আলোচনা করা হয়েছিল এবং প্রত্যাখ্যান করা হয়েছিল। ওপি চায় math.floor
অ্যাডাম স্মিথ

3

আপনি যদি নাম্পের সাথে কাজ করে থাকেন তবে আপনি নিম্নলিখিত সমাধানটি ব্যবহার করতে পারেন যা নেতিবাচক সংখ্যার সাথেও কাজ করে (এটি অ্যারেতেও কাজ করছে)

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


1

আপনি এটি সমাধান করেছেন কিনা তা জানেন না, তবে আমি কেবল এই প্রশ্নের উপর হোঁচট খেয়েছি। আপনি যদি দশমিক পয়েন্টগুলি থেকে মুক্তি পেতে চান তবে আপনি ইনট (এক্স) ব্যবহার করতে পারেন এবং এটি সমস্ত দশমিক সংখ্যা মুছে ফেলবে। রাউন্ড (এক্স) ব্যবহার করার দরকার নেই।


1

কেবল গোলাকার (x-0.5) তৈরি করুন এটি আপনার ফ্লোটের পরবর্তী গোলাকৃত ডাউন ইন্টিজার মানটি সর্বদা ফিরে আসবে। আপনি সহজেই ড রাউন্ড দ্বারা রাউন্ড আপ করতে পারেন (x + 0.5)


-1

এটি খুব সহজ হতে পারে, তবে আপনি কেবল এটি বিয়োগ 1 এর পরেও করতে পারছেন না? উদাহরণ স্বরূপ:

number=1.5
round(number)-1
> 1

4
এটি পুরো পূর্ণসংখ্যার জন্য ভুল উত্তর দেয়। উদাহরণস্বরূপ, ২.০ গোলাকার হয় ২, এবং আপনি যদি ১ টি বিয়োগ করেন তবে আপনি ভুল ফলাফল পেয়েছেন
পাস্কাল কুয়াক

@ পাসলকুউক আমি আপনার সমস্যা বুঝতে পারি না। আপনি কি ফলাফল হিসাবে 1.0 চান? কারণ ওপি স্পষ্টভাবে গোল করতে চেয়েছিল তখন নিকটতমের দিকে সংখ্যাটি integer
Bad_keypPoint

1
@ বাড_কিপয়েন্টস আমি মনে করি না যে ওপি ২.০ থেকে ১ গোল করতে চায়
পাস্কেল কুয়াক

@ পাসলকুউক দুঃখিত, আমি যে মন্তব্য করছি তার মন্তব্যে আমি কেবল উত্তরটি ফিরে দেখলাম back
Bad_keypPoint

-3

আমি এই কোডটি ব্যবহার করেছি যেখানে আপনি সংখ্যা থেকে 0.5 বিয়োগ করেন এবং আপনি যখন এটি গোল করেন, এটি মূল সংখ্যাটি গোল হয়।

বৃত্তাকার (ক-0.5)


1
এই বিদ্যমান উত্তর থেকে পার্থক্য কি ?
xskxzr
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.