निकटतम पूर्णांक के लिए गोल संख्या

Question

मैं लंबे समय तक फ्लोट संख्याओं को गोल करने की कोशिश कर रहा हूं:

32.268907563;
32.268907563;
31.2396694215;
33.6206896552;
...

अब तक कोई सफलता नहीं मिली। मैंने कोशिश की math.ceil(x), math.floor(x)(हालांकि यह ऊपर या नीचे गोल होगा, जो कि मैं round(x)जो देख रहा हूं वह नहीं है ) और जो या तो काम नहीं करता था (अभी भी फ्लोट नंबर)।

मैं क्या कर सकता था?

संपादित करें: कोड:

for i in widthRange:
    for j in heightRange:
        r, g, b = rgb_im.getpixel((i, j))
        h, s, v = colorsys.rgb_to_hsv(r/255.0, g/255.0, b/255.0)
        h = h * 360
        int(round(h))
        print(h)

Comments

मैं कोशिश करूँगाint(x)

— ब्रूसेस्टर

क्या वह त्रुटि नहीं देगा? int के लिए अवैध शाब्दिक () आधार 10 के साथ:

— snh_nl

Answer 1

int(round(x))

इसे गोल करके पूर्णांक में बदल देंगे

संपादित करें:

आप किसी भी चर के लिए int (राउंड (h)) असाइन नहीं कर रहे हैं। जब आप इंट (राउंड (एच)) कहते हैं, तो यह पूर्णांक संख्या देता है लेकिन कुछ और नहीं करता है; आपको उस पंक्ति को बदलना होगा:

h = int(round(h))

H को नया मान निर्दिष्ट करने के लिए

संपादित करें 2:

जैसा कि @plowman ने टिप्पणी में कहा, पाइथन round()काम नहीं करता है क्योंकि एक सामान्य रूप से अपेक्षा करेगा, और ऐसा इसलिए है क्योंकि संख्या को चर के रूप में संग्रहीत किया जाता है, आमतौर पर स्क्रीन पर इसे देखने का तरीका नहीं है। इस व्यवहार की व्याख्या करने वाले बहुत सारे उत्तर हैं:

राउंड () ठीक से राउंडिंग नहीं लगता है

इस समस्या से बचने का एक तरीका यह है कि आप इस उत्तर के अनुसार दशमलव का उपयोग करें: https://stackoverflow.com/a/15398691/4345659

इस जवाब के लिए अतिरिक्त पुस्तकालयों का उपयोग किए बिना ठीक से काम करने के लिए यह एक कस्टम गोलाई फ़ंक्शन का उपयोग करना सुविधाजनक होगा। बहुत सारे सुधारों के बाद, मैं निम्नलिखित समाधान के साथ आया, कि जहां तक ​​मैंने परीक्षण किया, सभी भंडारण मुद्दों से बचा रहा। यह स्ट्रिंग प्रतिनिधित्व का उपयोग करने पर आधारित है, repr()( प्राप्त नहीं str()!)। यह हैकिंग लगता है लेकिन यह एकमात्र तरीका था जिससे मैंने सभी मामलों को हल किया। यह Python2 और Python3 दोनों के साथ काम करता है।

def proper_round(num, dec=0):
    num = str(num)[:str(num).index('.')+dec+2]
    if num[-1]>='5':
        return float(num[:-2-(not dec)]+str(int(num[-2-(not dec)])+1))
    return float(num[:-1])

टेस्ट:

>>> print(proper_round(1.0005,3))
1.001
>>> print(proper_round(2.0005,3))
2.001
>>> print(proper_round(3.0005,3))
3.001
>>> print(proper_round(4.0005,3))
4.001
>>> print(proper_round(5.0005,3))
5.001
>>> print(proper_round(1.005,2))
1.01
>>> print(proper_round(2.005,2))
2.01
>>> print(proper_round(3.005,2))
3.01
>>> print(proper_round(4.005,2))
4.01
>>> print(proper_round(5.005,2))
5.01
>>> print(proper_round(1.05,1))
1.1
>>> print(proper_round(2.05,1))
2.1
>>> print(proper_round(3.05,1))
3.1
>>> print(proper_round(4.05,1))
4.1
>>> print(proper_round(5.05,1))
5.1
>>> print(proper_round(1.5))
2.0
>>> print(proper_round(2.5))
3.0
>>> print(proper_round(3.5))
4.0
>>> print(proper_round(4.5))
5.0
>>> print(proper_round(5.5))
6.0
>>> 
>>> print(proper_round(1.000499999999,3))
1.0
>>> print(proper_round(2.000499999999,3))
2.0
>>> print(proper_round(3.000499999999,3))
3.0
>>> print(proper_round(4.000499999999,3))
4.0
>>> print(proper_round(5.000499999999,3))
5.0
>>> print(proper_round(1.00499999999,2))
1.0
>>> print(proper_round(2.00499999999,2))
2.0
>>> print(proper_round(3.00499999999,2))
3.0
>>> print(proper_round(4.00499999999,2))
4.0
>>> print(proper_round(5.00499999999,2))
5.0
>>> print(proper_round(1.0499999999,1))
1.0
>>> print(proper_round(2.0499999999,1))
2.0
>>> print(proper_round(3.0499999999,1))
3.0
>>> print(proper_round(4.0499999999,1))
4.0
>>> print(proper_round(5.0499999999,1))
5.0
>>> print(proper_round(1.499999999))
1.0
>>> print(proper_round(2.499999999))
2.0
>>> print(proper_round(3.499999999))
3.0
>>> print(proper_round(4.499999999))
4.0
>>> print(proper_round(5.499999999))
5.0

अंत में, सही उत्तर होगा:

# Having proper_round defined as previously stated
h = int(proper_round(h))

संपादित करें 3:

टेस्ट:

>>> proper_round(6.39764125, 2)
6.31 # should be 6.4
>>> proper_round(6.9764125, 1)
6.1  # should be 7

यहाँ गोत्र यह है कि dec-th दशमलव 9 हो सकता है और यदि dec+1-th अंक> = 5 तो 9 एक 0 बन जाएगा और 1 को ले जाना चाहिएdec-1 -th अंक तक ।

यदि हम इसे ध्यान में रखते हैं, तो हम प्राप्त करते हैं:

def proper_round(num, dec=0):
    num = str(num)[:str(num).index('.')+dec+2]
    if num[-1]>='5':
      a = num[:-2-(not dec)]       # integer part
      b = int(num[-2-(not dec)])+1 # decimal part
      return float(a)+b**(-dec+1) if a and b == 10 else float(a+str(b))
    return float(num[:-1])

ऊपर वर्णित स्थिति में b = 10और पिछला संस्करण बस समवर्ती होगा aऔर bजिसके परिणामस्वरूप अनुगमन होगा 10जहां अनुगामी 0 गायब हो जाएगा। यह संस्करण एक उचित कैरी के रूप में, bसही दशमलव स्थान पर आधारित है dec।

Comments

प्रिंट ("4.5)", int (राउंड (4.5))) # ने मुझे 4 प्रिंट ("5.5)" दिया, int (राउंड (5.5))) # ने मुझे 6:, (

— कोम

यह पायथन संस्करण से संबंधित है। यह मुझे 5 और 6 पायथन 2.7.9 का उपयोग कर देता है और जैसा कि आपने कहा, 4 और 6 पायथन 3.4.2 का उपयोग करते हुए

— फ्रैंक सिलेमा

वर्थ नोटिंग: यह समाधान उस तरह से गोल नहीं होता है जैसा आप शायद उम्मीद करते हैं। उदाहरण के लिए, int(round(4.5))4 से नीचे चक्कर लगाते हैंint(round(4.500001)) सही ढंग से राउंड 5. के लिए

— प्लोमैन

अगर युवा एक पूर्णांक चाहते हैं round(x) पाइथन 3.6.2 में पर्याप्त है (और शायद कम संस्करण भी)। परिणाम पहले से ही टाइप इंट का है। नोट: round(x, n)टाइप फ्लोट का होगा।

— Elmex80s

यह 112439.50093565206 के लिए काम नहीं करता है। यह o / p -> 11253.0 देता है। बहुत अजीब है .. !!!!

— अजिन

Answer 2

उपयोग round(x, y) । यह आपकी संख्या को आपके इच्छित दशमलव स्थान तक ले जाएगा।

उदाहरण के लिए:

>>> round(32.268907563, 3)
32.269

Answer 3

round(value,significantDigit)साधारण समाधान है, हालांकि यह तब तक संचालित नहीं होता है जब गोल मूल्यों के समाप्त होने पर कोई गणित के दृष्टिकोण से उम्मीद करता है 5। यदि 5आपके द्वारा राउंड किए जाने के ठीक बाद अंक में है, तो ये मान केवल कभी-कभी अपेक्षित के रूप में गोल किए जाते हैं (यानी 8.005दो दशमलव अंकों को गोल करना)8.01 )। फ्लोटिंग पॉइंट मैथ के प्रश्न के कारण कुछ मूल्यों के लिए, उन्हें इसके बजाय गोल किया जाता है!

अर्थात

>>> round(1.0005,3)
1.0
>>> round(2.0005,3)
2.001
>>> round(3.0005,3)
3.001
>>> round(4.0005,3)
4.0
>>> round(1.005,2)
1.0
>>> round(5.005,2)
5.0
>>> round(6.005,2)
6.0
>>> round(7.005,2)
7.0
>>> round(3.005,2)
3.0
>>> round(8.005,2)
8.01

अजीब।

अपने इरादे को मानते हुए विज्ञान में आँकड़ों के लिए पारंपरिक दौर करना है, यह काम करने के roundलिए importअतिरिक्त सामान की आवश्यकता के अनुसार कार्य करने के लिए एक आसान आवरण है Decimal।

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*5),2)

0.08

अहा! तो इस पर आधारित हम एक समारोह कर सकते हैं ...

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

मूल रूप से यह आपके द्वारा उपयोग roundकिए जा रहे स्ट्रिंग के कम से कम दिए गए अंकों से छोटा होने की गारंटी देता है । उस छोटी मात्रा को जोड़कर, यह roundज्यादातर मामलों में व्यवहार को संरक्षित करता है , जबकि अब यह सुनिश्चित करता है कि अंकों में हीन होने वाले को गोल किया जाता है या 5नहीं और यदि यह है तो4 यह गोल है।

उपयोग करने का तरीका 10**(-len(val)-1) जानबूझकर किया गया था, क्योंकि यह सबसे बड़ी छोटी संख्या है जिसे आप बल को जोड़ने के लिए जोड़ सकते हैं, जबकि यह सुनिश्चित करना कि आप जो मूल्य जोड़ते हैं वह कभी भी गोलाई को नहीं बदलता भले ही दशमलव .गायब हो। मैं और अधिक घटाना करने के लिए बस 10**(-len(val))एक सशर्त के साथ उपयोग कर सकता है ... लेकिन यह हमेशा के रूप में घटाना आसान है क्योंकि यह दशमलव संख्याओं के लागू रेंज को ज्यादा नहीं बदलेगा यह समाधान ठीक से संभाल सकता है। यह दृष्टिकोण विफल हो जाएगा यदि आपके मान प्रकार की सीमा तक पहुंचते हैं, तो यह विफल हो जाएगा, लेकिन मान्य दशमलव मानों की पूरी श्रृंखला के लिए इसे काम करना चाहिए।if (val>1)11

आप भी उपयोग कर सकते हैं इसे पूरा करने के दशमलव लाइब्रेरी का , लेकिन मेरे द्वारा प्रस्तावित आवरण सरल है और कुछ मामलों में पसंद किया जा सकता है।

---

संपादित करें: यह इंगित करने के लिए धन्यवाद ब्लैंकनथ कि 5फ्रिंज केस केवल कुछ मूल्यों के लिए होता है। इस उत्तर के पहले के संस्करण में भी यह स्पष्ट नहीं था कि विषम गोलाई वाला व्यवहार केवल तब होता है, जब अंक उस अंक के अवर से तुरंत हीन हो जाता है जिस पर आप एक होना चाहते हैं5 ।

Comments

मुझे यकीन नहीं है कि आप क्यों सोचते हैं कि 5उनका अंतिम अंक हमेशा गोल होगा। यही कारण है कि एक त्वरित परीक्षण मैं बस की तरह संख्या के साथ किया था में ऐसा नहीं है 1.5, 2.5, 3.5और इतने पर और 1.05, 1.15, 1.25, 1.35एक दशमलव स्थान तक गोलाई। पहला सेट (सटीक पूर्णांक छोटे पूर्णांक के लिए) हमेशा एक पूर्णांक के लिए गोल होता है। उत्तरार्द्ध सेट लगातार गोल नहीं होता है, शायद कुछ मूल्यों के अटूट द्विआधारी प्रतिनिधित्व के कारण। जिन झांकियों में सटीक द्विआधारी निरूपण होता है जैसे 1.25कि एक कम से कम महत्वपूर्ण अंक होता है, लेकिन दूसरे यादृच्छिक रूप से गोल होते हैं।

— ब्लकिंक्थ

दिलचस्प ... आप सही कह रहे हैं। round(4.0005,3)देता है 4.0और round(1.0005,3)देता है 1.0, लेकिन round(2.0005,3)देता है 2.001और round(3.0005,3)देता है 3.001। लेकिन यही कारण है कि मेरा प्रस्तावित समाधान आवश्यक है ... आपको नहीं पता कि इस महत्वपूर्ण मामले पर स्टॉक राउंड से क्या उम्मीद है!

— जेसन आर। मिक

इसके लिए धन्यवाद। जब यह समस्या सामने आएगी तो आपका काम आएगा।

— TMWP

क्या आपका मतलब , digitsउस रिटर्न स्टेटमेंट के अंत में है? मजाक नहीं। ( मतलब मेरा मतलब है)

— user3342816

आह सही है, वास्तव में वहाँ होना चाहिए था। अच्छी पकड़ ... आश्चर्य किसी और का ध्यान नहीं गया था! उन लोगों को बचाएगा जो समाधान का उपयोग करते हैं कुछ निराशा। :-)

— जेसन आर। मिक

Answer 4

सकारात्मक के लिए, प्रयास करें

int(x + 0.5)

इसे नकारात्मक के लिए भी काम करने के लिए, प्रयास करें

int(x + (0.5 if x > 0 else -0.5))

int()एक मंजिल समारोह की तरह काम करता है और इसलिए आप इस संपत्ति का फायदा उठा सकते हैं। यह निश्चित रूप से सबसे तेज़ तरीका है।

Comments

नकारात्मक के लिए काम नहीं करता है>>> x=-0.999 >>> int(x), round(x), int(x+0.5) (0, -1.0, 0)

— user2907934

यदि आप कोने के मामलों की परवाह करते हैं, तो "0.5 और फ़्लोर" तकनीक का उपयोग न करें - कुछ मूल्य हैं जो आपकी अपेक्षा के अनुरूप नहीं हो सकते हैं! C ++ लेने के लिए stackoverflow.com/a/47302585/2732969 देखें और इस बहुत ही सवाल में stackoverflow.com/a/38744026/2732969 का जवाब दें।

— आनन

मुझे एक तेज़ विधि की आवश्यकता थी, यह सटीक नहीं था और इसमें कई कोने मामले नहीं होंगे, और कोने के मामलों में त्रुटि मेरे परिदृश्य में महत्वपूर्ण नहीं है। तो यह निश्चित रूप से कुछ विशेष मामलों के लिए मेरा जाना है जहां गति प्राथमिकता है। सटीक या सटीकता के लिए अनुशंसा न करें।

— एजेंटएम

Answer 5

IEEE 754 के अनुसार, क्या पायथन सिर्फ आधा ही नहीं कर रहा है ?

सावधान रहें, या "गैर-मानक" गोलाई का उपयोग करें ...

(यह भी देखें https://stackoverflow.com/a/33019948/10989839 )

Comments

यह उत्तर थोड़ा अस्पष्ट है। Round half to evenआईईईई 754 द्वारा बिल्कुल निर्धारित नहीं है, लेकिन इसके बजाय मानक द्वारा वर्णित कई राउंडिंग विकल्पों में से केवल एक है । Round to nearest, ties away from zero(अर्थात वह व्यवहार जो ज्यादातर लोग उम्मीद करते हैं) भी एक विकल्प है, और उदाहरण के लिए, C / C ++ में डिफ़ॉल्ट है।

— तेल

मैं मानता हूं, शब्दांकन काफी भ्रामक है। मैं क्या मतलब है कि अजगर (के अंत में तालिका देखें Heven को आधा गोलाई है docs.python.org/3.7/library/... जहां roundसे समझाया गया है) और यह रास्ता "भी दौर आधा" के अनुसार ऐसा करने से है निर्धारित है मानक द्वारा काम करना (या वर्णित)।

— मापियो

Answer 6

यदि आप python3.x का उपयोग कर रहे हैं, तो आप सुन्न अनुमान का उपयोग भी कर सकते हैं

import numpy as np
x = 2.3
print(np.rint(x))
>>> 2.0

Answer 7

दूसरा तर्क (दशमलव स्थानों की संख्या) निर्दिष्ट किए बिना आपका समाधान कॉल कर रहा है

>>> round(0.44)
0
>>> round(0.64)
1

जो एक बेहतर परिणाम है

>>> int(round(0.44, 2))
0
>>> int(round(0.64, 2))
0

Https://docs.python.org/3/library/functions.html#round पर पायथन डॉक्यूमेंटेशन से

दौर (संख्या [, ndigits])

दशमलव बिंदु के बाद ndigits के चक्कर में वापसी संख्या। यदि ndigits को छोड़ दिया गया है या कोई भी नहीं है, तो वह अपने इनपुट में निकटतम पूर्णांक लौटाता है।

ध्यान दें

फ़्लोट्स के लिए राउंड () का व्यवहार आश्चर्यजनक हो सकता है: उदाहरण के लिए, राउंड (2.675, 2) अपेक्षित 2.68 के बजाय 2.67 देता है। यह बग नहीं है: यह इस तथ्य का परिणाम है कि अधिकांश दशमलव अंशों को एक फ्लोट के रूप में प्रतिनिधित्व नहीं किया जा सकता है। फ़्लोटिंग पॉइंट अंकगणित देखें: अधिक जानकारी के लिए मुद्दे और सीमाएँ।

Answer 8

यदि आपको (उदाहरण के लिए) ए के लिए दो अंकों का सन्निकटन चाहिए, तो int(A*100+0.5)/100.0 आप वही करेंगे जो आप देख रहे हैं।

यदि आपको तीन अंकों के सन्निकटन की आवश्यकता है तो 1000 और इतने पर विभाजित करें।

Answer 9

कुछ इस तरह से भी काम करना चाहिए

import numpy as np    

def proper_round(a):
    '''
    given any real number 'a' returns an integer closest to 'a'
    '''
    a_ceil = np.ceil(a)
    a_floor = np.floor(a)
    if np.abs(a_ceil - a) < np.abs(a_floor - a):
        return int(a_ceil)
    else:
        return int(a_floor)

Answer 10

इस प्रयोजन के लिए मैं निम्नलिखित बात करना चाहूँगा -

int(round(x))

यह आपको निकटतम पूर्णांक देगा।

उम्मीद है की यह मदद करेगा!!

Answer 11

मैं उपयोग करता हूं और निम्नलिखित समाधान की सलाह दे सकता हूं (python3.6):

y = int(x + (x % (1 if x >= 0 else -1)))

यह अर्ध-संख्याओं (सकारात्मक और नकारात्मक) के लिए ठीक काम करता है और इंट (राउंड (x)) से भी तेज काम करता है:

round_methods = [lambda x: int(round(x)), 
                 lambda x: int(x + (x % (1 if x >= 0 else -1))),
                 lambda x: np.rint(x).astype(int),
                 lambda x: int(proper_round(x))]

for rm in round_methods:
    %timeit rm(112.5)
Out:
201 ns ± 3.96 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
159 ns ± 0.646 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
925 ns ± 7.66 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
1.18 µs ± 8.66 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

for rm in round_methods:
    print(rm(112.4), rm(112.5), rm(112.6))
    print(rm(-12.4), rm(-12.5), rm(-12.6))
    print('=' * 11)

Out:
112 112 113
-12 -12 -13
===========
112 113 113
-12 -13 -13
===========
112 112 113
-12 -12 -13
===========
112 113 113
-12 -13 -13
===========