¿La forma más segura de convertir flotante a entero en Python?

El módulo matemático de Python contiene funciones prácticas como floor& ceil. Estas funciones toman un número de coma flotante y devuelven el entero más cercano debajo o encima de él. Sin embargo, estas funciones devuelven la respuesta como un número de coma flotante. Por ejemplo:

import math
f=math.floor(2.3)

Ahora fvuelve:

2.0

¿Cuál es la forma más segura de obtener un número entero de este flotante, sin correr el riesgo de errores de redondeo (por ejemplo, si el flotante es el equivalente a 1.99999) o tal vez debería usar otra función por completo?

Todos los enteros que se pueden representar con números de coma flotante tienen una representación exacta. Por lo tanto, puede usarlo con seguridad inten el resultado. Las representaciones inexactas ocurren solo si está tratando de representar un número racional con un denominador que no es una potencia de dos.

¡Que esto funcione no es trivial en absoluto! Es una propiedad de la representación de coma flotante IEEE que int∘floor = ⌊⋅⌋ si la magnitud de los números en cuestión es lo suficientemente pequeña, pero son posibles diferentes representaciones donde int (floor (2.3)) podría ser 1.

Para citar de Wikipedia ,

Cualquier número entero con un valor absoluto menor o igual a 2 ²⁴ puede representarse exactamente en el formato de precisión simple, y cualquier número entero con un valor absoluto menor o igual a 2 ⁵³ puede representarse exactamente en el formato de doble precisión.

El uso int(your non integer number)lo clavará.

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

Podrías usar la función redonda. Si no utiliza ningún segundo parámetro (número de dígitos significativos), creo que obtendrá el comportamiento que desea.

Salida inactiva.

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

Combinando dos de los resultados anteriores, tenemos:

int(round(some_float))

Esto convierte un flotador en un entero de manera bastante confiable.

¡Que esto funcione no es trivial en absoluto! Es una propiedad de la representación de coma flotante IEEE que int∘floor = ⌊⋅⌋ si la magnitud de los números en cuestión es lo suficientemente pequeña, pero son posibles diferentes representaciones donde int (floor (2.3)) podría ser 1.

Esta publicación explica por qué funciona en ese rango .

En un doble, puede representar enteros de 32 bits sin ningún problema. No puede haber problemas de redondeo. Más precisamente, los dobles pueden representar todos los enteros entre 2 ⁵³ y -2 ⁵³ inclusive .

Breve explicación : un doble puede almacenar hasta 53 dígitos binarios. Cuando necesita más, el número se rellena con ceros a la derecha.

Se deduce que 53 unidades es el número más grande que se puede almacenar sin relleno. Naturalmente, todos los números (enteros) que requieren menos dígitos se pueden almacenar con precisión.

Agregar uno a 111 (omitido) 111 (53 unidades) produce 100 ... 000, (53 ceros). Como sabemos, podemos almacenar 53 dígitos, lo que hace que el margen cero más a la derecha.

De aquí viene el 2 ⁵³ .

Más detalles: debemos considerar cómo funciona el punto flotante IEEE-754.

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

El número se calcula de la siguiente manera (excluyendo casos especiales que son irrelevantes aquí):

-1 ^signo × 1.mantissa × 2 ^{exponente - sesgo}

donde sesgo = 2 ^{exponente - 1} - 1 , es decir, 1023 y 127 para precisión doble / simple respectivamente.

Sabiendo que multiplicar por 2 ^X simplemente cambia todos los bits X lugares a la izquierda, es fácil ver que cualquier número entero debe tener todos los bits en la mantisa que terminan a la derecha del punto decimal a cero.

Cualquier número entero excepto cero tiene la siguiente forma en binario:

1x ... x donde las x -es representan los bits a la derecha del MSB (bit más significativo).

Debido a que excluimos cero, siempre habrá un MSB que sea uno, razón por la cual no se almacena. Para almacenar el entero, debemos llevarlo a la forma mencionada anteriormente: -1 ^signo × 1.mantissa × 2 ^{exponente - sesgo} .

Eso dice lo mismo que desplazar los bits sobre el punto decimal hasta que solo esté el MSB hacia la izquierda del MSB. Todos los bits a la derecha del punto decimal se almacenan en la mantisa.

A partir de esto, podemos ver que podemos almacenar como máximo 52 dígitos binarios aparte del MSB.

Se deduce que el número más alto donde todos los bits se almacenan explícitamente es

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

Para esto, necesitamos establecer el exponente, de modo que el punto decimal se desplace 52 lugares. Si tuviéramos que aumentar el exponente en uno, no podríamos conocer el dígito de derecha a izquierda después del punto decimal.

111(omitted)111x.

Por convención, es 0. Al establecer toda la mantisa en cero, recibimos el siguiente número:

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

Es un 1 seguido de 53 ceros, 52 almacenados y 1 agregado debido al exponente.

Representa 2 ⁵³ , que marca el límite (tanto negativo como positivo) entre el que podemos representar con precisión todos los enteros. Si quisiéramos agregar uno a 2 ⁵³ , tendríamos que establecer el cero implícito (indicado por el x) en uno, pero eso es imposible.

math.floorsiempre devolverá un número entero y, por int(math.floor(some_float))lo tanto , nunca introducirá errores de redondeo.

Sin math.floor(some_large_float)embargo, el error de redondeo ya podría haberse introducido , o incluso cuando se almacena un gran número en un flotante en primer lugar. (Grandes números pueden perder precisión cuando se almacenan en flotadores).

Si necesita convertir una cadena flotante a un int, puede usar este método.

Ejemplo: '38.0'a38

Para convertir esto en un int, puedes lanzarlo como flotante y luego int. Esto también funcionará para cadenas flotantes o cadenas enteras.

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

Nota : Esto eliminará cualquier número después del decimal.

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

Otro ejemplo de código para convertir un real / flotante en un entero usando variables. "vel" es un número real / flotante y se convierte al siguiente INTEGER más alto, "newvel".

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))

Dado que está solicitando la forma "más segura", le proporcionaré otra respuesta que no sea la respuesta principal.

Una manera fácil de asegurarse de no perder precisión es verificar si los valores serían iguales después de convertirlos.

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

Si el flotante es 1.0 por ejemplo, 1.0 es igual a 1. Por lo tanto, la conversión a int se ejecutará. Y si el valor flotante es 1.1, int (1.1) equivale a 1, y 1.1! = 1. Por lo tanto, el valor seguirá siendo un valor flotante y no perderá ninguna precisión.

df ['Column_Name'] = df ['Column_Name']. astype (int)