Y a-t-il un moyen d'obtenir le plafond d'une grande décimale de précision en python? MATH arrose la valeur et retourne la valeur non précise
6 Réponses :
Vous pouvez le faire en utilisant l'option de mode de précision et d'arrondi du constructeur de contexte.
ctx = decimal.Context(prec=1, rounding=decimal.ROUND_CEILING) ctx.divide(decimal.Decimal(800000000000000000001), decimal.Decimal(100000000000000000000))
Parfait :) --- Terminer la limite de caractères ---
@Alex Désolé devait partir avant 6 minutes. Merci pour le rappel
-1. Cela ne généralise pas bien; Il ne se passe que dans ce cas car le résultat est compris entre [1, 10]. Essayez le même calcul avec décimal (123) / décimal (10), par exemple, et vous obtiendrez un résultat de décimal ('2e + 1') .
>>> decimal.Context(rounding=decimal.ROUND_CEILING).quantize(
... decimal.Decimal(800000000000000000001)/100000000000000000000, 0)
Decimal('9')
Notez que cette solution a des problèmes pour décimal avec une valeur importante: par exemple, si vous essayez c.quantize (décimal.decimal ('1e100'), 1) avec votre contexte C , vous obtiendrez une exception invalidorsération .
def decimal_ceil(x):
int_x = int(x)
if x - int_x == 0:
return int_x
return int_x + 1
x = decimal.Decimal('8.00000000000000000000001')
with decimal.localcontext() as ctx:
ctx.prec=100000000000000000
ctx.rounding=decimal.ROUND_CEILING
y = x.to_integral_exact()
C'est bon, mais il n'est pas nécessaire de changer la précision du contexte ici. TO_INTEGRAL_EXACT prend également un argument d'arrondi , afin que vous puissiez éviter de jouer avec le contexte.
La voie la plus directe de prendre le plafond d'une instance décimale Contrairement à la plupart des méthodes décimales, le d'ailleurs, dans python 3.x, x est d'utiliser x.to_integral_exact (arrondi = rond_ceiling) . Il n'y a pas besoin de gâcher avec le contexte ici. Notez que cela définit le inexacte et arrondi drapeaux le cas échéant; Si vous ne voulez pas que les indicateurs touchent, utilisez x.to_integal_value (arrondi = rond_ceiling) à la place. Exemple: to_integral_exact et to_integal_value n'est pas affecté par la précision du contexte actuel , donc vous n'avez pas à vous soucier de changer de précision: math.ceil fonctionne exactement Comme vous le souhaitez, sauf qu'il renvoie un int plutôt que par une instance décimale . Cela fonctionne parce que math.ceil est surchargeable pour les types personnalisés dans Python 3. Dans Python 2, math.ceil convertit simplement l'instance décimal à un float d'abord, perdez potentiellement des informations dans le processus, vous pouvez donc vous retrouver avec des résultats incorrects.
Juste pour la complétude: dans Python 2.x Math.Ceuil ne fonctionne pas comme prévu: il convertit la décimale en float en premier. À cause de ce int (pla (d ('1.0000000000000001'))) évalue à 1 en Python 2.x et à 2 dans Python 3.x
@Antayhatchkins: merci, bon point. J'ai édité cette information dans la réponse.
Utilisez simplement une puissance pour faire cela.
Importer math
Je suis nouveau à Python, je viens de commencer hier en fait. Stupédié sur ce problème dans mon deuxième programme de pratique (le premier était bien sûr l'obligatoire «Print» Bonjour, World! '; »). Donc, je trouve difficile de juger la meilleure réponse à cela. La solution décimale.context de Matthew Flaschen a travaillé dans mon cas particulier. Mais j'aimerais que les autres optimisent la meilleure solution (aussi être utiles pour les débutants comme moi si vous pouvez expliquer pourquoi une approche donnée fonctionne mieux) et je reviendrai et accepterai.