Le moyen le plus sûr de convertir float en entier en python?

Le module mathématique de Python contient des fonctions pratiques comme floor& ceil. Ces fonctions prennent un nombre à virgule flottante et renvoient l'entier le plus proche en dessous ou au-dessus. Cependant, ces fonctions renvoient la réponse sous forme de nombre à virgule flottante. Par exemple:

import math
f=math.floor(2.3)

fRetourne maintenant :

2.0

Quelle est la façon la plus sûre d'extraire un entier de ce flottant, sans courir le risque d'erreurs d'arrondi (par exemple si le flottant est l'équivalent de 1,99999) ou peut-être devrais-je utiliser une autre fonction tout à fait?

Tous les entiers pouvant être représentés par des nombres à virgule flottante ont une représentation exacte. Vous pouvez donc utiliser intle résultat en toute sécurité . Les représentations inexactes ne se produisent que si vous essayez de représenter un nombre rationnel avec un dénominateur qui n'est pas une puissance de deux.

Que cela fonctionne n'est pas anodin! C'est une propriété de la représentation en virgule flottante IEEE que int∘floor = ⌊⋅⌋ si la magnitude des nombres en question est suffisamment petite, mais différentes représentations sont possibles où int (floor (2.3)) pourrait être 1.

Pour citer Wikipédia ,

Tout entier dont la valeur absolue est inférieure ou égale à 2 ²⁴ peut être représenté exactement au format simple précision et tout entier dont la valeur absolue est inférieure ou égale à 2 ⁵³ peut être représenté exactement au format double précision.

L'utilisation int(your non integer number)le clouera.

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

Vous pouvez utiliser la fonction ronde. Si vous n'utilisez pas de deuxième paramètre (nombre de chiffres significatifs), je pense que vous obtiendrez le comportement que vous souhaitez.

Sortie IDLE.

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

En combinant deux des résultats précédents, nous avons:

int(round(some_float))

Cela convertit un flottant en un entier de manière assez fiable.

Que cela fonctionne n'est pas anodin! C'est une propriété de la représentation en virgule flottante IEEE que int∘floor = ⌊⋅⌋ si la magnitude des nombres en question est suffisamment petite, mais différentes représentations sont possibles où int (floor (2.3)) pourrait être 1.

Ce post explique pourquoi cela fonctionne dans cette gamme .

Dans un double, vous pouvez représenter des entiers 32 bits sans aucun problème. Il ne peut y avoir de problème d'arrondi. Plus précisément, les doubles peuvent représenter tous les entiers compris entre 2 ⁵³ et -2 ⁵³ inclus .

Brève explication : un double peut stocker jusqu'à 53 chiffres binaires. Lorsque vous en avez besoin de plus, le nombre est complété par des zéros à droite.

Il s'ensuit que 53 unités est le plus grand nombre pouvant être stocké sans remplissage. Naturellement, tous les nombres (entiers) nécessitant moins de chiffres peuvent être stockés avec précision.

Ajouter un à 111 (omis) 111 (53 uns) donne 100 ... 000, (53 zéros). Comme nous le savons, nous pouvons stocker 53 chiffres, ce qui fait le remplissage zéro le plus à droite.

C'est de là que vient 2 ⁵³ .

Plus de détails: nous devons examiner comment fonctionne la virgule flottante IEEE-754.

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

Le nombre est ensuite calculé comme suit (hors cas particuliers qui ne sont pas pertinents ici):

-1 ^signe × 1.mantisse × 2 ^{exposant - biais}

où biais = 2 ^{exposants - 1} - 1 , c'est-à-dire 1023 et 127 pour la précision double / simple respectivement.

Sachant que multiplier par 2 ^X décale simplement tous les bits X à gauche, il est facile de voir que tout entier doit avoir tous les bits de la mantisse qui se terminent à droite de la virgule décimale par zéro.

Tout entier sauf zéro a la forme suivante en binaire:

1x ... x où les x -es représentent les bits à droite du MSB (bit le plus significatif).

Parce que nous avons exclu zéro, il y aura toujours un MSB qui est un, c'est pourquoi il n'est pas stocké. Pour stocker l'entier, nous devons le mettre sous la forme susmentionnée: -1 ^signe × 1.mantisse × 2 ^{exposant - biais} .

Cela signifie la même chose que de déplacer les bits sur la virgule décimale jusqu'à ce qu'il n'y ait que le MSB vers la gauche du MSB. Tous les bits à droite de la virgule décimale sont ensuite stockés dans la mantisse.

De cela, nous pouvons voir que nous pouvons stocker au plus 52 chiffres binaires en dehors du MSB.

Il s'ensuit que le nombre le plus élevé où tous les bits sont explicitement stockés est

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

Pour cela, nous devons définir l'exposant, de sorte que la virgule décimale soit décalée de 52 places. Si nous devions augmenter l'exposant de un, nous ne pouvons pas connaître le chiffre de droite à gauche après le point décimal.

111(omitted)111x.

Par convention, c'est 0. En mettant la mantisse entière à zéro, nous recevons le nombre suivant:

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

C'est un 1 suivi de 53 zéros, 52 stockés et 1 ajouté en raison de l'exposant.

Il représente 2 ⁵³ , qui marque la frontière (à la fois négative et positive) entre laquelle nous pouvons représenter avec précision tous les entiers. Si nous voulions ajouter un à 2 ⁵³ , nous devions définir le zéro implicite (indiqué par le x) à un, mais c'est impossible.

math.floorrenverra toujours un nombre entier et int(math.floor(some_float))n'introduira donc jamais d'erreurs d'arrondi.

L'erreur d'arrondi peut déjà être introduite dans math.floor(some_large_float), ou même lors du stockage d'un grand nombre dans un flottant en premier lieu. (Les grands nombres peuvent perdre en précision lorsqu'ils sont stockés dans des flotteurs.)

Si vous devez convertir un flottant de chaîne en entier, vous pouvez utiliser cette méthode.

Exemple: '38.0'à38

Pour le convertir en entier, vous pouvez le convertir en flottant puis en entier. Cela fonctionnera également pour les chaînes flottantes ou les chaînes entières.

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

Remarque : Cela supprimera tous les nombres après la décimale.

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

Un autre exemple de code pour convertir un réel / flottant en un entier à l'aide de variables. "vel" est un nombre réel / flottant et converti au prochain INTEGER le plus élevé, "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))

Puisque vous demandez le moyen le plus sûr, je fournirai une autre réponse que la première réponse.

Un moyen facile de vous assurer de ne perdre aucune précision est de vérifier si les valeurs seront égales après les avoir converties.

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

Si le flottant est 1.0 par exemple, 1.0 est égal à 1. La conversion en int s'exécutera donc. Et si le flottant est 1.1, int (1.1) équivaut à 1 et 1.1! = 1. La valeur restera donc un flottant et vous ne perdrez aucune précision.

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