python - quitar - ¿Cómo redondear un número de coma flotante hasta cierto lugar decimal?

redondear un numero en python 3

Question

Supongamos que estoy teniendo 8.8333333333333339 y quiero convertirlo a 8.84 , ¿cómo puedo lograr esto en python? round(8.8333333333333339, 2) da 8.83 y no 8.84 . Soy nuevo en Python o en la programación en general.

No quiero imprimirlo como una cadena, el resultado se usará más. Para obtener más información sobre el problema, consulte los consejos de programación de Python de Tim Wilson: Préstamo y calculadora de pagos .

Answer 1

Aquí hay una función simple para hacer esto:

def precision(num,x):
return "{0:.xf}".format(round(num))

Aquí, num es el número decimal x es el decimal hasta donde quieres redondear un número flotante

La ventaja sobre otra implementación es que puede llenar ceros en el extremo derecho del decimal para hacer un número de desinfección hasta x decimales.

Ejemplo 1:

precision(10.2,9)

regresará 10.200000000 (hasta 9 dp)

Ejemplo 2:

precision(10.2231,2)

devolverá 10.22 (hasta 2 dp)

Answer 2

Desea usar el módulo decimal pero también necesita especificar el modo de redondeo. Aquí hay un ejemplo:

>>> import decimal
>>> decimal.Decimal(''8.333333'').quantize(decimal.Decimal(''.01''), rounding=decimal.ROUND_UP)
Decimal(''8.34'')
>>> decimal.Decimal(''8.333333'').quantize(decimal.Decimal(''.01''), rounding=decimal.ROUND_DOWN)
Decimal(''8.33'')
>>>

Answer 3

Hier es mi solución para el problema de redondeo arriba / abajo

<.5 redondear hacia abajo

> = .5 rodear

import math
def _should_round_down(val: float):
if val < 0:
return ((val * -1) % 1) < 0.5
return (val % 1) < 0.5
def _round(val: float, ndigits=0):
if ndigits > 0:
val *= 10 ** (ndigits - 1)
is_positive = val > 0
tmp_val = val
if not is_positive:
tmp_val *= -1
rounded_value = math.floor(tmp_val) if _should_round_down(val) else math.ceil(tmp_val)
if not is_positive:
rounded_value *= -1
if ndigits > 0:
rounded_value /= 10 ** (ndigits - 1)
return rounded_value
# test
# nr = 12.2548
# for digit in range(0, 4):
# print("{} decimals : {} -> {}".format(digit, nr, _round(nr, digit)))
# output
# 0 decimals : 12.2548 -> 12
# 1 decimals : 12.2548 -> 12.0
# 2 decimals : 12.2548 -> 12.3
# 3 decimals : 12.2548 -> 12.25

Answer 4

La forma más fácil de hacerlo es mediante el uso de la función siguiente, que está incorporada

format()

por ejemplo:

format(1.242563,".2f")

la salida sería:

1.24

similar:

format(9.165654,".1f")

daría:

9.2

Answer 5

Para que conste. Podrías hacerlo de esta manera:

def roundno(no):
return int(no//1 + ((no%1)/0.5)//1)

Allí, no es necesario incluir / importar

Answer 6

Si quiere redondear, 8.84 es la respuesta incorrecta. 8.833333333333 redondeado es 8.83 no 8.84. Si siempre quiere redondear, puede usar math.ceil. Haga ambas cosas en una combinación con el formato de cadenas, ya que redondear un número flotante en sí mismo no tiene sentido.

"%.2f" % (math.ceil(x * 100) / 100)

Answer 7

Si redondeas 8.8333333333339 a 2 decimales, la respuesta correcta es 8.83, no 8.84. La razón por la que obtuviste 8.83000000001 es porque 8.83 es ​​un número que no se puede reporrar correctamente en binario, y te da el más cercano. Si desea imprimirlo sin todos los ceros, haga lo que VGE dice:

print "%.2f" % 8.833333333339 #(Replace number with the variable?)

Answer 8

Una forma mucho más simple es simplemente usar la función round (). Aquí hay un ejemplo.

total_price = float()
price_1 = 2.99
price_2 = 0.99
total_price = price_1 + price_2

Si imprimiera total_price en este momento, obtendría

3.9800000000000004

Pero si lo encierra en una función redonda () como tal

print(round(total_price,2))

El resultado es igual

3.98

La función round () funciona aceptando dos parámetros. El primero es el número que quieres redondear. El segundo es el número de lugares decimales a redondear a.

Answer 9

use el módulo decimal : decimal

Answer 10

Esto es normal (y no tiene nada que ver con Python) porque 8.83 no se puede representar exactamente como un flotante binario, así como 1/3 no se puede representar exactamente en decimal (0,333333 ... ad infinitum).

Si quiere garantizar una precisión absoluta, necesita el módulo decimal :

>>> import decimal
>>> a = decimal.Decimal("8.833333333339")
>>> print(round(a,2))
8.83

Answer 11

8.833333333339 (o 8.833333333333334 , el resultado de 106.00/12 ) debidamente redondeado a dos decimales es 8.83 . Matemáticamente parece que lo que quieres es una función de techo . El que está en el módulo math de Python se llama ceil :

import math
v = 8.8333333333333339
print(math.ceil(v*100)/100) # -> 8.84

Respectivamente, las funciones de piso y techo generalmente asignan un número real al mayor entero siguiente o más pequeño que tiene cero decimales, así que para usarlos para 2 decimales, el número primero se multiplica por 10 ² (o 100) para cambiar el decimal punto y luego se divide por él para compensar.

Si no quiere usar el módulo math por alguna razón, puede usar esta implementación (mínimamente probada) que acabo de escribir:

def ceiling(x):
n = int(x)
return n if n-1 < x <= n else n+1

Cómo esto se aplica al problema vinculado con la calculadora de préstamos y pagos

Del resultado de la muestra, parece que redondearon el pago mensual, que es lo que muchos llaman el efecto de la función de techo. Esto significa que cada mes se está pagando un poco más de _1/12 de la cantidad total. Eso hizo que el pago final fuera un poco más pequeño de lo normal, dejando un saldo pendiente de 8.76 .

Hubiera sido igualmente válido utilizar el redondeo normal produciendo un pago mensual de 8.83 y un pago final ligeramente superior de 8.87 . Sin embargo, en el mundo real a la gente en general no le gusta que sus pagos aumenten, por lo que redondear cada pago es una práctica común: también devuelve el dinero al prestamista más rápidamente.