Comment vérifier si une valeur flottante est un nombre entier
J'essaie de trouver la plus grande racine cubique qui est un nombre entier, c'est-à-dire moins de 12 000.
processing = True
n = 12000
while processing:
n -= 1
if n ** (1/3) == #checks to see if this has decimals or not
Je ne sais pas comment vérifier si c'est un nombre entier ou non! Je pourrais le convertir en une chaîne puis utiliser l'indexation pour vérifier les valeurs de fin et voir si elles sont nulles ou non, cela semble plutôt lourd cependant. Est-il un moyen plus simple?
11 réponses
Pour vérifier si une valeur float est un nombre entier, utilisez la float.is_integer() méthode:
>>> (1.0).is_integer()
True
>>> (1.555).is_integer()
False
La méthode a été ajoutée au type float dans Python 2.6.
Prenez en compte que dans Python 2, 1/3 est 0 (division de plancher pour les opérandes entiers!), et cette arithmétique à virgule flottante peut être imprécise (a float est une approximation utilisant des fractions binaires, Pas un nombre réel précis). Mais en ajustant un peu votre boucle, cela donne:
>>> for n in range(12000, -1, -1):
... if (n ** (1.0/3)).is_integer():
... print n
...
27
8
1
0
Ce qui signifie que tout ce qui dépasse 3 cubes, (y compris 10648) a été manqué en raison de l'imprécision susmentionnée:
>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996
Vous devrez vérifier les nombres fermer au nombre entier à la place, ou ne pas utiliser float() pour trouver votre numéro. Comme arrondir la racine cubique de 12000:
>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648
Si vous utilisez Python 3.5 ou plus récent, vous pouvez utiliser math.isclose() fonction pour voir si une valeur à virgule flottante est dans une marge configurable:
>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True
Pour les anciennes versions, le naïf implémentation de cette fonction (Ignorer la vérification des erreurs et ignorer infinity et NaN) Comme mentionné dans PEP485 :
def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
Nous pouvons utiliser l'opérateur modulo ( % ). Cela nous indique combien de restes nous avons quand nous divisons x Par y-exprime comme x % y. Chaque nombre entier doit diviser par 1, donc si il y a un reste, il ne doit pas être un nombre entier.
Cette fonction retourne un booléen, True ou False, selon que n est un nombre entier.
def is_whole(n):
if n % 1 == 0:
return True
else:
return False
Vous pouvez utiliser ceci:
if k == int(k):
print(str(k) + "is a whole number!"
Vous pouvez utiliser une opération modulo pour cela.
if (n ** (1.0/3)) % 1 != 0:
print("We have a decimal number here!")
Vous n'avez pas besoin de faire une boucle ou de vérifier quoi que ce soit. Il suffit de prendre une racine cubique de 12 000 et de l'arrondir:
r = int(12000**(1/3.0))
print r*r*r # 10648
Ne serait-il pas plus facile de tester les racines du cube? Commencez avec 20 (20**3 = 8000) et aller jusqu'à 30 (30**3 = 27000). Ensuite, vous devez tester moins de 10 entiers.
for i in range(20, 30):
print("Trying {0}".format(i))
if i ** 3 > 12000:
print("Maximum integral cube root less than 12000: {0}".format(i - 1))
break
Les réponses ci-dessus fonctionnent dans de nombreux cas, mais elles en manquent. Considérez ce qui suit:
fl = sum([0.1]*10) # this is 0.9999999999999999, but we want to say it IS an int
En utilisant ceci comme référence, certaines des autres suggestions n'obtiennent pas le comportement que nous pourrions vouloir:
fl.is_integer() # False
fl % 1 == 0 # False
Essayez plutôt:
def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
def is_integer(fl):
return isclose(fl, round(fl))
Maintenant, nous obtenons:
is_integer(fl) # True
isclose livré avec Python 3.5 + , et pour D'autres Python, vous pouvez utiliser cette définition principalement équivalente (comme mentionné dans le Pep correspondant)
Vous pouvez utiliser le round fonction pour calculer la valeur.
Oui en python comme beaucoup l'ont fait quand on calculer la valeur d'une racine cubique, il vous donnera une sortie avec un peu d'erreur. Pour vérifier si la valeur est un nombre entier, vous pouvez utiliser la fonction suivante:
def cube_integer(n):
if round(n**(1.0/3.0))**3 == n:
return True
return False
, Mais rappelez-vous que int(n) est équivalent à math.floor et de ce fait, si vous trouvez le int(41063625**(1.0/3.0)), vous obtiendrez 344 au lieu de 345.
Alors soyez prudent lors de l'utilisation int dont les racines cubiques.
J'espère avoir répondu à votre question. Si vous avez d'autres questions, alors vous pouvez me contacter.
Juste une info latérale, is_integer fait en interne:
import math
isInteger = (math.floor(x) == x)
Pas exactement en python, mais l'implémentation de cpython est implémentée comme mentionné ci-dessus.
Essayez d'utiliser:
int(val) == val
Cela donnera beaucoup plus de précision que toutes les autres méthodes.