Maneira mais segura de converter float para inteiro em python?

O módulo de matemática do Python contém funções úteis como floor& ceil. Essas funções usam um número de ponto flutuante e retornam o número inteiro mais próximo abaixo ou acima dele. No entanto, essas funções retornam a resposta como um número de ponto flutuante. Por exemplo:

import math
f=math.floor(2.3)

Agora fretorna:

2.0

Qual é a maneira mais segura de obter um número inteiro desse float, sem correr o risco de erros de arredondamento (por exemplo, se o float é o equivalente a 1.99999) ou talvez eu deva usar outra função completamente?

Todos os números inteiros que podem ser representados por números de ponto flutuante têm uma representação exata. Então você pode usar com segurança intno resultado. Representações inexatas ocorrem apenas se você estiver tentando representar um número racional com um denominador que não é um poder de dois.

Que isso funcione não é nada trivial! É uma propriedade da representação de ponto flutuante IEEE que int∘floor = ⌊⋅⌋ se a magnitude dos números em questão for pequena o suficiente, mas diferentes representações são possíveis onde int (floor (2.3)) pode ser 1.

Para citar a Wikipedia ,

Qualquer número inteiro com valor absoluto menor ou igual a 2 ²⁴ pode ser representado exatamente no formato de precisão única, e qualquer número inteiro com valor absoluto menor ou igual a 2 ⁵³ pode ser representado exatamente no formato de precisão dupla.

O uso int(your non integer number)vai pregar.

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

Você poderia usar a função round. Se você não usar um segundo parâmetro (número de dígitos significativos), acho que obterá o comportamento desejado.

Saída IDLE.

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

Combinando dois dos resultados anteriores, temos:

int(round(some_float))

Isso converte um número flutuante em um número inteiro de maneira bastante confiável.

Que isso funcione não é nada trivial! É uma propriedade da representação de ponto flutuante IEEE que int∘floor = ⌊⋅⌋ se a magnitude dos números em questão for pequena o suficiente, mas diferentes representações são possíveis onde int (floor (2.3)) pode ser 1.

Este post explica por que funciona nesse intervalo .

Em um dobro, você pode representar números inteiros de 32 bits sem problemas. Não pode haver problemas de arredondamento. Mais precisamente, as dobras podem representar todos os números inteiros entre 2 ⁵³ e -2 ⁵³ inclusive .

Breve explicação : Um duplo pode armazenar até 53 dígitos binários. Quando você precisar de mais, o número é preenchido com zeros à direita.

Daqui resulta que 53 ones é o maior número que pode ser armazenado sem preenchimento. Naturalmente, todos os números (inteiros) que exigem menos dígitos podem ser armazenados com precisão.

Adicionar um a 111 (omitido) 111 (53 unidades) produz 100 ... 000 (53 zeros). Como sabemos, podemos armazenar 53 dígitos, o que resulta no preenchimento zero mais à direita.

É ^{daí que} vem o 2 ⁵³ .

Mais detalhes: Precisamos considerar como o ponto flutuante IEEE-754 funciona.

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

O número é calculado da seguinte maneira (excluindo casos especiais que são irrelevantes aqui):

-1 ^sinal × 1.mantissa × 2 ^{expoente - viés}

onde viés = 2 ^{expoente - 1} - 1 , ou seja, 1023 e 127 para precisão dupla / única, respectivamente.

Sabendo que multiplicar por 2 ^X simplesmente muda todos os bits X para a esquerda, é fácil ver que qualquer número inteiro deve ter todos os bits na mantissa que terminam à direita do ponto decimal em zero.

Qualquer número inteiro, exceto zero, tem o seguinte formato em binário:

1x ... x onde os x -es representam os bits à direita do MSB (bit mais significativo).

Como excluímos zero, sempre haverá um MSB, e é por isso que não é armazenado. Para armazenar o número inteiro, devemos trazê-lo para a forma acima mencionada: -1 ^sinal × 1.mantissa × 2 ^{expoente - viés} .

É o mesmo que mudar os bits sobre o ponto decimal até que haja apenas o MSB à esquerda do MSB. Todos os bits à direita do ponto decimal são armazenados na mantissa.

A partir disso, podemos ver que podemos armazenar no máximo 52 dígitos binários além do MSB.

Segue-se que o número mais alto em que todos os bits são armazenados explicitamente é

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

Para isso, precisamos definir o expoente, de modo que o ponto decimal seja deslocado em 52 casas. Se aumentarmos o expoente em um, não saberemos o dígito da direita para a esquerda após o ponto decimal.

111(omitted)111x.

Por convenção, é 0. Definindo a mantissa inteira como zero, recebemos o seguinte número:

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

Isso é 1 seguido de 53 zeros, 52 armazenados e 1 adicionado devido ao expoente.

Representa 2 ⁵³ , que marca o limite (negativo e positivo) entre o qual podemos representar com precisão todos os números inteiros. Se quiséssemos adicionar um a 2 ⁵³ , teríamos que definir o zero implícito (indicado por x) para um, mas isso é impossível.

math.floorsempre retornará um número inteiro e, portanto int(math.floor(some_float)), nunca introduzirá erros de arredondamento.

O erro de arredondamento já pode ter sido introduzido math.floor(some_large_float), ou mesmo ao armazenar um grande número em um float em primeiro lugar. (Números grandes podem perder precisão quando armazenados em carros alegóricos.)

Se você precisar converter uma seqüência de caracteres flutuante em um int, poderá usar esse método.

Exemplo: '38.0'para38

Para converter isso em um int, você pode convertê-lo como um float e depois em um int. Isso também funcionará para cadeias flutuantes ou cadeias inteiras.

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

Nota : Isso retira qualquer número após o decimal.

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

Outro exemplo de código para converter um real / flutuante em um número inteiro usando variáveis. "vel" é um número real / flutuante e convertido para o próximo mais alto INTEGER, "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))

Como você está pedindo a maneira 'mais segura', fornecerei outra resposta que não seja a principal.

Uma maneira fácil de garantir que você não perca nenhuma precisão é verificar se os valores serão iguais após a conversão.

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

Se o float for 1,0, por exemplo, 1,0 é igual a 1. Portanto, a conversão para int será executada. E se o float for 1.1, int (1.1) equivale a 1 e 1.1! = 1. Portanto, o valor permanecerá um float e você não perderá nenhuma precisão.

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