राउंडिंग पॉइंट पॉइंट नंबर डाउन टू एवरेस्ट इंटेगर?

Question

जैसा कि शीर्षक से पता चलता है, मैं एक फ्लोटिंग पॉइंट नंबर लेना चाहता हूं और इसे निकटतम पूर्णांक तक गोल करना चाहता हूं। हालांकि, अगर यह पूरी तरह से नहीं है, तो मैं हमेशा चर के नीचे चक्कर लगाना चाहता हूं, भले ही यह अगले पूर्णांक तक कितना करीब हो। क्या इसे करने का कोई तरीका है?

Comments

एक संभावित कठिनाई यह है कि IEEE फ़्लोटिंग पॉइंट फॉरमेट संख्याओं को इतनी बड़ी संख्या में प्रस्तुत कर सकता है कि भव्यता 1. से अधिक हो। इसलिए, जब आप राउंड x को राउंडिंग x + 1 से नीचे कर सकते हैं, तो आपको वह परिणाम नहीं मिलेगा जिसकी आप अपेक्षा करते हैं।

— dmckee --- पूर्व-संचालक ने

कृपया कुछ उदाहरण पोस्ट करें।

— अश्विनी चौधरी

Answer 1

सरल

print int(x)

साथ ही काम करेंगे।

Comments

int (0.6) = 0 बल्कि 1

— Helin Wang

@ हेलिनवांग वही है जो ओपी ने मांगा था।

— पेट्र पेलर

यह सबसे पायथोनिक दृष्टिकोण की तरह लगता है।

— ज्ञान वेद

यह सकारात्मक संख्याओं के लिए अच्छी तरह से काम करता है, लेकिन नकारात्मक संख्याओं को गोल किया जाएगा:int(-23.3) == 23

— एलेक्स रिले

और पूर्णांक सीमा से परे संख्या के लिए काम नहीं करता है जैसे कि 600851475143, यह मूल रूप से एक मेमोरी त्रुटि को चिह्नित करेगा।

— मुईद इबुकुन

Answer 2

इनमें से एक काम करना चाहिए:

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

Comments

से आउटपुट math.truncएक पूर्णांक है, जबकि आउटपुट math.floorएक फ्लोट है।

— evedovelli

@evedovelli: वास्तव में अब और नहीं। type(math.floor(1.51)) -> intऔर type(math.trunc(1.51)) -> intजैसेpython 3.6.0

— SKPS

ये विकल्प "इंट (x)" की तुलना में अधिक स्पष्ट हैं और इसलिए अधिक पायथोनिक हैं।

— ट्रिस्टन

Answer 3

x//1

//ऑपरेटर विभाजन के फर्श देता है। चूंकि 1 से विभाजित करने से आपकी संख्या नहीं बदलती है, यह फर्श के बराबर है, लेकिन आयात की आवश्यकता नहीं है। टिप्पणियाँ:

1. यह एक फ्लोट देता है
2. यह दौर -∞ की ओर

Comments

इसके अलावा अच्छा है। int(-1.1) == -1जबकि -1.1//1 == -2.0तथापि decimal.Decimal('-1.1')//1 == decimal.Decimal('-1')(के रूप में दस्तावेज, दावा 2 नहीं के लिए सच है decimal), तो कैसे पर निर्भर //बर्ताव करता है पूरी तरह से स्थिर, आज भी नहीं है।

— टिनो

Answer 4

फ्लोटिंग पॉइंट परिणाम प्राप्त करने के लिए बस उपयोग करें:

round(x-0.5)

यह नकारात्मक संख्याओं के लिए भी काम करता है।

Comments

अत्यंत परिष्कृत है कि

— एलोन

Answer 5

मुझे लगता है कि आपको एक मंजिल समारोह की आवश्यकता है:

math.floor (एक्स)

Comments

अजगर 2 में यह एक फ्लोट देता है जबकि अजगर 3 में यह इंट

— voidMainReturn

int (math.floor (x)) या फ्लोट (math.floor (x))

— Jeff

Answer 6

बहुत से लोग उपयोग करने के लिए कहते हैं int(x), और यह ज्यादातर मामलों के लिए ठीक काम करता है, लेकिन थोड़ी समस्या है। यदि ओपी का परिणाम है:

x = 1.9999999999999999

यह दौर होगा

x = 2

16 9 के बाद यह दौर होगा। यह एक बड़ी बात नहीं है यदि आप सुनिश्चित हैं कि आप कभी भी इस तरह के काम नहीं करेंगे। लेकिन यह ध्यान में रखने के लिए कुछ है।

Comments

ऐसा इसलिए है क्योंकि 1.9999999999999999वास्तव 2.0में आंतरिक फ्लोट64 प्रतिनिधित्व में बराबर है । अर्थात। जैसे ही यह एक फ्लोट में पार्स किया जाता है, यह पहले से ही गोल है, क्योंकि 64 बिट फ्लोट उस कई महत्वपूर्ण अंकों का प्रतिनिधित्व नहीं कर सकता है। आप मूल्यांकन के साथ इसे सत्यापित कर सकते हैं 1.9999999999999999 == 2.0। और आपको संदेह है कि आपरेशन के बराबर होती है तैरता पर कुछ राउंडिंग, आप के साथ द्विआधारी प्रतिनिधित्व तुलना कर सकते हैं करता है struct.pack("d", 1.9999999999999999) == struct.pack("d", 2.0), जो भी बराबर है।

— ब्लबरडाइब्लूब

और अगर आपकी बात ठीक है, तो मैं नहीं देखता कि क्या गलत है int()। मान पहले से ही 2.0 है और यह इसे खुशी से 2. में परिवर्तित कर देगा

— blubberdiblub

यदि ओपी (या भविष्य में इसे पढ़ता है) का इरादा किसी भी कारण से निकटतम पूर्णांक (और गोल-अप मूल्य) का उपयोग करना है, तो यह कुछ ध्यान में रखना होगा।

— lokilindo

@lokilindo लेकिन इसका कोई लेना-देना नहीं है int(), इसका पूरी तरह से अनुचित उपयोग करना हैfloat , जैसा 1.9999999999999999कि 2.0 संकलन समयint() पर किया जाता है (जबकि निष्पादन समय पर कहा जाता है)। यदि आप चर के लिए सही डेटा प्रकार का उपयोग करते हैं, तो सब कुछ अपेक्षित रूप से काम करता है: int(decimal.Decimal('1.9999999999999999999999999999999999999999999999999999999'))देता है1

— Tino

Answer 7

यदि आप गणित आयात नहीं करना चाहते हैं, तो आप उपयोग कर सकते हैं:

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.

Comments

आपके उत्तर के लिए धन्यवाद। अगली बार जब आप उचित कोड (करीब कोष्ठक) लिखेंगे, तो आपको एक बेहतर स्वागत मिलेगा और कुछ दस्तावेज दे सकते हैं।

— ज्योफ

roundएक साल पहले यह सवाल पूछे जाने पर जवाब के रूप में पहले ही चर्चा और खारिज कर दिया गया था। ओपी चाहता है math.floor।

— एडम स्मिथ

Answer 8

यदि आप सुन्न के साथ काम करते हैं, तो आप निम्न समाधान का उपयोग कर सकते हैं जो नकारात्मक संख्याओं के साथ भी काम करता है (यह सरणियों पर भी काम कर रहा है)

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।

Answer 9

अगर आप इसे हल नहीं जानते, लेकिन मैं इस सवाल पर सिर्फ ठोकर खाता हूं। यदि आप दशमलव अंकों से छुटकारा चाहते हैं, तो आप int (x) का उपयोग कर सकते हैं और यह सभी दशमलव अंकों को समाप्त कर देगा। Theres दौर (x) का उपयोग करने की कोई जरूरत नहीं है।

Answer 10

बस राउंड (x-0.5) करें इससे आपके फ़्लोट के इंटेगर वैल्यू का अगला राउंड डाउन हो जाएगा। तुम भी आसानी से कर गोल कर सकते हैं (x + 0.5)

Answer 11

यह बहुत सरल हो सकता है, लेकिन क्या आप इसे फिर से घटाकर 1 नहीं कर सकते हैं? उदाहरण के लिए:

number=1.5
round(number)-1
> 1

Comments

यह पूरे पूर्णांक के लिए गलत उत्तर देता है। उदाहरण के लिए, 2.0 का राउंड 2 है, और यदि आप 1 घटाते हैं तो आपको गलत परिणाम मिलता है। 1.

— पास्कल कुआक

@PascalCuoq मैं आपकी समस्या को नहीं समझता। क्या आप परिणाम के रूप में 1.0 चाहते हैं? क्योंकि ओपी स्पष्ट रूप से गोल करना चाहता था, इसलिए निकटतम संख्या में बंद हो गया integer।

— bad_keypoint

@bad_keypoint मुझे नहीं लगता है कि ओपी 2.0 से 1. को गोल करना चाहता है

— पास्कल कूक

@PascalCuoq क्षमा करें, मैंने अभी टिप्पणी थ्रेड में उत्तर पर ध्यान दिया है जिसमें हम हैं।

— bad_keypoint

Answer 12

मैंने इस कोड का उपयोग किया है जहां आप संख्या से 0.5 घटाते हैं और जब आप इसे राउंड करते हैं, तो यह मूल संख्या नीचे गोल है।

दौर (एक-0.5)

Comments

इस मौजूद उत्तर से क्या अंतर है ?

— xskxzr