¿Cómo redondeo un número de punto flotante hasta un cierto lugar decimal?

Supongamos que tengo 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 progtwigción en general.

No quiero imprimirlo como una cadena, y el resultado se seguirá utilizando. Para obtener más información sobre el problema, consulte los consejos de progtwigción de Python de Tim Wilson: calculadora de préstamos y pagos .

8.833333333339 (o 8.833333333333334 , el resultado de 106.00/12 ) redondeado correctamente a dos lugares decimales es 8.83 . Matemáticamente suena como 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 anterior o más pequeño que sigue con cero lugares decimales; para usarlos con 2 lugares decimales, el número se multiplica primero por 10 2 (o 100) para desplazar 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 se aplica esto al problema de la calculadora de pagos y préstamos vinculados

captura de pantalla de la salida de la calculadora de préstamos

A partir de la salida de 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 paga un poco más de 112 del monto total. Eso hizo que el pago final fuera un poco más pequeño de lo habitual, dejando un saldo pendiente de pago de solo 8.76 .

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

Esto es normal (y no tiene nada que ver con Python) porque 8.83 no se puede representar exactamente como un flotador binario, al igual que 1/3 no se puede representar exactamente en decimal (0.333333 … ad infinitum).

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

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

Desea utilizar 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') >>> 

Una forma mucho más sencilla 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 tuviera que imprimir total_price ahora mismo obtendría

 3.9800000000000004 

Pero si lo encierras en una función round () como tal

 print(round(total_price,2)) 

La salida es igual a

 3.98 

La función round () funciona al aceptar dos parámetros. El primero es el número que deseas redondear. El segundo es el número de decimales para redondear a.

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

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

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

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

Solo para que conste. Podrías hacerlo de esta manera:

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

Allí, no hay necesidad de incluir / importaciones

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

 format() 

Por ejemplo:

 format(1.242563,".2f") 

La salida sería:

 1.24 

Similar:

 format(9.165654,".1f") 

daría:

 9.2 

Use el módulo decimal : http://docs.python.org/library/decimal.html

ََََََ

Aquí está mi solución para el problema de redondeo arriba / abajo

<.5 redondear hacia abajo

= .5 redondear


 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 

Tengo este codigo

 tax = (tax / 100) * price 

y luego este código:

 tax = round((tax / 100) * price, 2) 

la ronda funcionó para mí

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

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

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

La ventaja sobre otras implementaciones es que puede llenar ceros en el extremo derecho del decimal para hacer un número deciaml hasta x lugares decimales.

Ejemplo 1:

 precision(10.2, 9) 

volverá

10.200000000 (hasta 9 puntos decimales)

Ejemplo 2:

 precision(10.2231, 2) 

volverá

10.22 (hasta dos puntos decimales)