अजगर में पूर्णांक को फ्लोट में बदलने का सबसे सुरक्षित तरीका?

Question

पायथन के गणित मॉड्यूल में floor& जैसे काम शामिल हैं ceil। ये फ़ंक्शन एक फ्लोटिंग पॉइंट नंबर लेते हैं और निकटतम पूर्णांक को इसके नीचे या ऊपर लौटाते हैं। हालाँकि ये फ़ंक्शन उत्तर को फ़्लोटिंग पॉइंट संख्या के रूप में वापस करते हैं। उदाहरण के लिए:

import math
f=math.floor(2.3)

अब fरिटर्न:

2.0

राउंडिंग त्रुटियों के जोखिम को चलाने के बिना, इस फ्लोट से पूर्णांक प्राप्त करने का सबसे सुरक्षित तरीका क्या है (उदाहरण के लिए यदि फ्लोट 1.99999 के बराबर है) या शायद मुझे एक और फ़ंक्शन का उपयोग करना चाहिए?

Comments

math.floor v2.6 में एक फ्लोट देता है , लेकिन यह v3 में पूर्णांक देता है । इस बिंदु पर (ओपी के लगभग छह साल बाद), यह मुद्दा शायद ही कभी दिखाई दे।

— sancho.s ReinstateMonicaCellio

हालाँकि, अभी भी सुस्ती तैरती है, इसलिए यह सवाल वैध है।

— Vincenzooo

Answer 1

सभी पूर्णांक जिन्हें फ्लोटिंग पॉइंट संख्याओं द्वारा दर्शाया जा सकता है, उनका सटीक प्रतिनिधित्व है। तो आप intपरिणाम पर सुरक्षित रूप से उपयोग कर सकते हैं । यदि आप दो की शक्ति नहीं है एक हरक के साथ एक परिमेय संख्या का प्रतिनिधित्व करने की कोशिश कर रहे हैं, तो केवल विदेशी प्रतिनिधित्व होता है।

यह काम बिल्कुल भी मामूली नहीं है! यह IEEE फ़्लोटिंग पॉइंट प्रतिनिधित्व की एक संपत्ति है जो int propertyfloor = the है यदि प्रश्न में संख्याओं का परिमाण काफी छोटा है, लेकिन विभिन्न प्रतिनिधित्व संभव हैं जहां int (मंजिल (2.3)) 1 हो सकता है।

विकिपीडिया से उद्धृत करने के लिए ,

2 से कम या ^{24 के} बराबर निरपेक्ष मान वाले किसी भी पूर्णांक को एकल परिशुद्धता प्रारूप में ठीक-ठीक दर्शाया जा सकता है, और 2 ^{53 के} बराबर या उससे कम निरपेक्ष मूल्य वाले किसी भी पूर्णांक को दोहरे सटीक प्रारूप में ^{दिखाया} जा सकता है।

Comments

थोड़ा और गहराई में जाने के लिए +1। आप संक्षिप्त विवरण में यह भी बता सकते हैं कि क्यों: en.wikipedia.org/wiki/Floating_point : D

— गॉर्डन गुस्ताफ़सन

पायथन 2 में, एक "int" C "int" के समान है। पायथन 3 में, ऐसा प्रतीत होता है कि "int, stackoverflow.com/questions/13795758/… " के आकार की कोई सीमा नहीं है । "int" का अर्थ ऑपरेटिंग सिस्टम और अंतर्निहित हार्डवेयर पर भी निर्भर है। en.wikipedia देखें । org / wiki / 64-bit_computing # 64-bit_data_models । यदि आप C-API, python 3 के साथ प्रोग्रामिंग कर रहे हैं, तो आपको अपने प्लेटफॉर्म पर long और size_t की परिभाषा क्या है में बहुत सावधान रहना होगा। docs.python.org/3 /c-api/long.html

— जुआन

Answer 2

उपयोग int(your non integer number)इसे नाखून देगा।

print int(2.3) # "2"
print int(math.sqrt(5)) # "2"

Comments

यह ऋणात्मक संख्याओं के लिए काम नहीं करेगा: floorराउंड डाउन जबकि intराउंड 0. की ओर

— जुलेंन

@jochen मैंने int(-2.3)पायथन वितरण चंदवा 2.7.6 में परीक्षण किया और -2उम्मीद के मुताबिक मिला । पूर्णांक संख्या नकारात्मक हो सकती है, औपचारिक मठ परिभाषा में उसी तरह।

— सूरोड्रिग्स

मैं मानता हूँ, int(-2.3)देता है -2, क्योंकि यह की ओर दौर के रूप में आप कहते हैं, 0, यानी इस मामले में ऊपर। इसके विपरीत, मूल प्रश्न का उपयोग किया जाता है math.floor, जो हमेशा गोल होता है: math.floor(-2.3)देता है -3.0।

— जॉचेन

यह वास्तव में कोई समस्या नहीं है। ओपी सिर्फ एक पूर्णांक के परिणाम से बाहर चाहता है math.floor, और यह उत्तर दिखाता है कि फ्लोट को पूर्णांक में कैसे परिवर्तित किया जाए। फ्लोट से लें math.floorऔर इसे पाइप करें int, समस्या हल हो गई:int(math.floor(2.3))

— JMTyler

क्या आपने प्रश्न भी पढ़ा है? वह इंट () फ़ंक्शन के बारे में जानते हैं , लेकिन यह पूछा है कि क्या आप 2.0 के बजाय 1.9999 में परेशानी में पड़ सकते हैं। आपका उत्तर एक उत्तर के बिल्कुल भी समीप नहीं है, आप पूरे बिंदु से चूक गए ...

— मयउ ३६

Answer 3

आप गोल फ़ंक्शन का उपयोग कर सकते हैं। यदि आप कोई दूसरा पैरामीटर (# महत्वपूर्ण अंकों का) का उपयोग करते हैं तो मुझे लगता है कि आपको वह व्यवहार मिलेगा जो आप चाहते हैं।

IDLE आउटपुट।

>>> round(2.99999999999)
3
>>> round(2.6)
3
>>> round(2.5)
3
>>> round(2.4)
2

Comments

roundकम से कम पायथन 2.6 में एक फ्लोट संख्या देता है।

— फिलिप

पायथन 3.1.2 में, गोल एक इंट रिटर्न देता है।

— रॉबर्ट

दरअसल, अजगर 3.x में दोनों roundऔर floorपूर्णांक लौटाता है। इसलिए मुझे लगता है कि सवाल पायथन 2.x की चिंता करता है।

— फिलिप

हो सकता है int(round(2.65))?

— तेयुएन

round(6.5)6 क्यों देता है? ऐसा लगता है ceil()कि फ्लोट तब होता है जब अन्य सभी मामलों में दशमलव के बाद तत्काल 5 (या 9 से अधिक) होता है। इस मामले में काम क्यों नहीं हो रहा है? या किसी अन्य मामले में जब संख्या एक छह के साथ समाप्त होती है और दशमलव के बाद एक 5 अधिकार होता है ...

— candh

Answer 4

पिछले परिणामों में से दो को मिलाकर, हमारे पास है:

int(round(some_float))

यह फ्लोट को पूर्ण रूप से काफी हद तक पूर्णांक में परिवर्तित करता है।

Comments

यदि आप बहुत लंबे समय तक तैरने का प्रयास करते हैं तो क्या होता है? क्या यह कम से कम एक अपवाद को बढ़ाएगा?

— अगस्तियो

@ एगोस्टिनो क्या मतलब है "बहुत लंबी नाव"?

— क्राल्यक

@kralyk मेरा मतलब है कि एक floatसंख्या एक सामान्य से अधिक संख्या का प्रतिनिधित्व intकर सकती है। पायथन 2 में, क्या ऐसे floatमूल्य हैं जो आप केवल long(राउंडिंग के बाद) का उपयोग करके प्रतिनिधित्व कर सकते हैं ?

— एगोस्टिनो

@kralyk आप मतलब है, दौर के बाद? तो, उन्हें कास्टिंग करने के लिए एक अपवाद बढ़ाने के लिए, या बस उन्हें काट दिया जाएगा?

— एगोस्टिनो

@Agostino नहीं, int()फ़ंक्शन या तो जरूरत के आधार पर intया उत्पादन करता longहै ...

— kralyk

Answer 5

यह काम बिल्कुल भी मामूली नहीं है! यह IEEE फ़्लोटिंग पॉइंट प्रतिनिधित्व की एक संपत्ति है जो int propertyfloor = the है यदि प्रश्न में संख्याओं का परिमाण काफी छोटा है, लेकिन विभिन्न प्रतिनिधित्व संभव हैं जहां int (मंजिल (2.3)) 1 हो सकता है।

यह पोस्ट बताती है कि यह उस रेंज में क्यों काम करता है ।

एक डबल में, आप बिना किसी समस्या के 32 बिट पूर्णांक का प्रतिनिधित्व कर सकते हैं। कोई भी गोल मुद्दे नहीं हो सकते । अधिक सटीक रूप से, डबल्स 2 और ⁵³ और -2 ⁵³ सहित सभी पूर्णांकों का प्रतिनिधित्व कर सकते हैं ।

संक्षिप्त विवरण : एक डबल 53 बाइनरी अंक तक संग्रहीत कर सकता है। जब आपको अधिक की आवश्यकता होती है, तो संख्या सही पर शून्य के साथ गद्देदार होती है।

यह इस प्रकार है कि 53 नंबर सबसे बड़ी संख्या है जिसे बिना पैडिंग के संग्रहीत किया जा सकता है। स्वाभाविक रूप से, कम अंकों की आवश्यकता वाले सभी (पूर्णांक) संख्याओं को सटीक रूप से संग्रहीत किया जा सकता है।

एक (111) ( 111) ( 111 वाले) जोड़ने से पैदावार 100 ... 000, (53 शून्य) होती है। जैसा कि हम जानते हैं, हम 53 अंकों को संग्रहीत कर सकते हैं, जो सबसे सही शून्य पैडिंग बनाता है।

यह वह जगह है जहां 2 ^{53 से} आता है।

---

अधिक विस्तार: हमें यह विचार करने की आवश्यकता है कि IEEE-754 फ़्लोटिंग पॉइंट कैसे काम करता है।

  1 bit    11 / 8     52 / 23      # bits double/single precision
[ sign |  exponent | mantissa ]

संख्या की गणना इस प्रकार की जाती है (विशेष मामलों को छोड़कर जो यहां अप्रासंगिक हैं):

-1 ^साइन × 1. मंटिसा × 2 ^{एक्सपोनेंट - पूर्वाग्रह}

जहां पूर्वाग्रह = 2 ^{घातांक - 1} - 1 , अर्थात 1023 और 127 के लिए क्रमशः डबल / एकल परिशुद्धता।

यह जानते हुए कि 2 ^{एक्स से} गुणा करने पर बस सभी बिट्स एक्स स्थानों को बाईं ओर शिफ्ट कर देता है, यह देखना आसान है कि किसी भी पूर्णांक में सभी बिट्स में होना चाहिए जो कि मंटिसा में दशमलव बिंदु के दाईं ओर शून्य तक होता है।

शून्य को छोड़कर किसी भी पूर्णांक में बाइनरी में निम्न रूप है:

1x ... x जहां x -es MSB (सबसे महत्वपूर्ण बिट) के दाईं ओर बिट्स का प्रतिनिधित्व करता है।

क्योंकि हमने शून्य को बाहर रखा है, हमेशा एक एमएसबी होगा जो एक है - यही कारण है कि यह संग्रहीत नहीं है। पूर्णांक को संग्रहीत करने के लिए, हमें इसे पूर्वोक्त रूप में लाना होगा: -1 ^साइन × 1.mantissa × 2 ^{प्रतिपादक - पूर्वाग्रह} ।

यह दशमलव बिंदु पर बिट्स को स्थानांतरित करने के समान है, जब तक कि MSB के बाईं ओर केवल MSB न हो। दशमलव बिंदु के सभी बिट्स को फिर मंटिसा में संग्रहीत किया जाता है।

इससे, हम देख सकते हैं कि हम MSB के अलावा अधिकांश 52 बाइनरी अंकों को संग्रहीत कर सकते हैं।

यह इस प्रकार है कि उच्चतम संख्या जहां सभी बिट स्पष्ट रूप से संग्रहीत हैं

111(omitted)111.   that's 53 ones (52 + implicit 1) in the case of doubles.

इसके लिए, हमें प्रतिपादक को सेट करने की आवश्यकता है, जैसे कि दशमलव बिंदु को 52 स्थानों पर स्थानांतरित किया जाएगा। यदि हम घातांक को एक से बढ़ाते हैं, तो हम दशमलव बिंदु के बाद अंक को बाईं ओर दाईं ओर नहीं जान सकते हैं।

111(omitted)111x.

कन्वेंशन द्वारा, यह 0. है। पूरे मंटिसा को शून्य पर सेट करना, हमें निम्नलिखित संख्या प्राप्त होती है:

100(omitted)00x. = 100(omitted)000.

यह एक 1 है जिसके बाद 53 शून्य, 52 संग्रहीत और 1 जोड़ा गया है।

यह 2 ^{53 का} प्रतिनिधित्व करता है , जो सीमा (दोनों नकारात्मक और सकारात्मक) को चिह्नित करता है, जिसके बीच हम सभी पूर्णांकों का सही प्रतिनिधित्व कर सकते हैं। यदि हम एक से 2 ⁵³ जोड़ना चाहते हैं , तो हमें निहित शून्य (एक से चिह्नित x) को एक पर सेट करना होगा , लेकिन यह असंभव है।

Answer 6

math.floorहमेशा एक पूर्णांक संख्या लौटाएगा और इस प्रकार int(math.floor(some_float))गोलाई त्रुटियों को कभी भी पेश नहीं करेगा।

राउंडिंग त्रुटि पहले से ही शुरू की जा सकती है math.floor(some_large_float), हालांकि, या पहली बार में एक बड़ी संख्या में एक फ़्लोट में संग्रहीत करते समय। (बड़ी संख्या में फ़्लोट में संग्रहीत होने पर सटीकता खो सकती है।)

Comments

प्रेषक: docs.python.org/2/library/math.html - math.floor (x) - x का फ़्लोट फ्लोट के रूप में लौटाता है, सबसे बड़ा पूर्णांक मान x से कम या उसके बराबर होता है।

— बिल रोसमस

जब आपको int पहले से ही काम करता है तो आपको math.floor कॉल करने की आवश्यकता क्यों है?

— एलेक्स

@ एलेक्स: intऔर floorनिश्चित रूप से नकारात्मक संख्याओं के लिए विभिन्न मान लौटाएं।

Answer 7

यदि आपको एक स्ट्रिंग फ्लोट को इंट में बदलने की आवश्यकता है तो आप इस विधि का उपयोग कर सकते हैं।

उदाहरण: '38.0'से38

इसे एक इंट में बदलने के लिए आप इसे एक फ्लोट के रूप में डाल सकते हैं। यह फ्लोट स्ट्रिंग्स या पूर्णांक स्ट्रिंग्स के लिए भी काम करेगा।

>>> int(float('38.0'))
38
>>> int(float('38'))
38

नोट : यह दशमलव के बाद किसी भी संख्या को छीन लेगा।

>>> int(float('38.2'))
38

Answer 8

चर का उपयोग करके एक वास्तविक / फ्लोट को पूर्णांक में बदलने के लिए एक और कोड नमूना। "वेल" एक वास्तविक / फ्लोट संख्या है और अगले उच्चतम INTEGER में परिवर्तित हो जाती है, "नया"।

import arcpy.math, os, sys, arcpy.da
.
.
with arcpy.da.SearchCursor(densifybkp,[floseg,vel,Length]) as cursor:
 for row in cursor:
    curvel = float(row[1])
    newvel = int(math.ceil(curvel))

Answer 9

चूंकि आप 'सबसे सुरक्षित' रास्ता पूछ रहे हैं, इसलिए मैं शीर्ष उत्तर के अलावा एक और उत्तर दूंगा।

यह सुनिश्चित करने का एक आसान तरीका है कि आप किसी भी सटीकता को न खोएं, यह जांचने के लिए है कि क्या मान आपके द्वारा परिवर्तित करने के बाद समान होंगे।

if int(some_value) == some_value:
     some_value = int(some_value)

यदि फ्लोट उदाहरण के लिए 1.0 है, तो 1.0 1 के बराबर है। इसलिए इंट में रूपांतरण निष्पादित होगा। और यदि फ्लोट 1.1 है, तो int (1.1) 1, और 1.1 के बराबर है! = 1. तो मान एक फ्लोट रहेगा और आप किसी भी सटीकता को नहीं खोएंगे।

Answer 10

df [ 'COLUMN_NAME'] = df [ 'COLUMN_NAME']। astype (पूर्णांक)

Comments

आपके उत्तर के लिए एक स्पष्टीकरण एक लंबा रास्ता तय करता है।

— बिब्लियोफिलसागर