Redondea al segundo lugar decimal en Python

¿Cómo puedo redondear un número al segundo decimal de python? Por ejemplo:

0.022499999999999999 

Debe redondear hasta 0.03

 0.1111111111111000 

Debe redondear hasta 0.12

Si hay algún valor en la tercera posición decimal, quiero que siempre se redondee dejándome 2 valores detrás del punto decimal.

Python incluye la función round() que le permite especificar el número de dígitos que desea. De la documentación:

round(x[, n])

Devuelva el valor de punto flotante x redondeado a n dígitos después del punto decimal. Si se omite n, el valor predeterminado es cero. El resultado es un número de punto flotante. Los valores se redondean al múltiplo más cercano de 10 a la potencia menos n; si dos múltiplos están igualmente cerca, el redondeo se realiza fuera de 0 (así, por ejemplo, la ronda (0.5) es 1.0 y la ronda (-0.5) es -1.0).

Por lo tanto, querría usar round(x, 2) para hacer el redondeo normal. Para asegurarse de que el número siempre esté redondeado, deberá utilizar la función ceil(x) . Del mismo modo, para redondear hacia abajo se usa floor(x) .

 from math import ceil num = 0.1111111111000 num = ceil(num * 100) / 100.0 

Ver:
documentación de math.ceil
documentación round – probablemente querrá revisar esto de todos modos para futuras referencias

Extrapolando de la respuesta de Edwin:

 from math import ceil, floor def float_round(num, places = 0, direction = floor): return direction(num * (10**places)) / float(10**places) 

Usar:

 >>> float_round(0.21111, 3, ceil) #round up >>> 0.212 >>> float_round(0.21111, 3) #round down >>> 0.211 >>> float_round(0.21111, 3, round) #round naturally >>> 0.211 
 x = math.ceil(x * 100.0) / 100.0 

Esto depende del comportamiento que desee al considerar los números positivos y negativos, pero si desea algo que siempre se redondea a un valor mayor (por ejemplo, 2.0449 -> 2.05, -2.0449 -> -2.04), entonces puede hacer:

 round(x + 0.005, 2) 

o un poco más lujoso

 def round_up(x, place): return round(x + 5 * 10**(-1 * (place + 1)), place) 

Esto también parece funcionar de la siguiente manera:

 round(144, -1) # 140 round_up(144, -1) # 150 round_up(1e308, -307) # 1.1e308 

Tenga en cuenta que el truco ceil(num * 100) / 100 se bloqueará en algunas entradas degeneradas, como 1e308. Es posible que esto no ocurra a menudo, pero puedo decir que solo me costó un par de días. Para evitar esto, “sería bueno si” ceil() y floor() tomaron un lugar decimal, como round() hace … Mientras tanto, ¿alguien sabe una alternativa limpia que no se bloquee en entradas como esta? Tuve algunas esperanzas para el paquete decimal , pero parece morir también:

 >>> from math import ceil >>> from decimal import Decimal, ROUND_DOWN, ROUND_UP >>> num = 0.1111111111000 >>> ceil(num * 100) / 100 0.12 >>> float(Decimal(num).quantize(Decimal('.01'), rounding=ROUND_UP)) 0.12 >>> num = 1e308 >>> ceil(num * 100) / 100 Traceback (most recent call last): File "", line 301, in runcode File "", line 1, in  OverflowError: cannot convert float infinity to integer >>> float(Decimal(num).quantize(Decimal('.01'), rounding=ROUND_UP)) Traceback (most recent call last): File "", line 301, in runcode File "", line 1, in  decimal.InvalidOperation: [] 

Por supuesto, uno podría decir que el choque es el único comportamiento sano en tales entradas, pero diría que no es el redondeo sino la multiplicación lo que está causando el problema (por eso, por ejemplo, 1e306 no falla), y una implementación más limpia de La redondeo del n-lugar evitaría el truco de multiplicación.

 def round_up(number, ndigits=None): # start by just rounding the number, as sometimes this rounds it up result = round(number, ndigits if ndigits else 0) if result < number: # whoops, the number was rounded down instead, so correct for that if ndigits: # use the type of number provided, eg float, decimal, fraction Numerical = type(number) # add the digit 1 in the correct decimal place result += Numerical(10) ** -ndigits # may need to be tweaked slightly if the addition was inexact result = round(result, ndigits) else: result += 1 # same as 10 ** -0 for precision of zero digits return result assert round_up(0.022499999999999999, 2) == 0.03 assert round_up(0.1111111111111000, 2) == 0.12 assert round_up(1.11, 2) == 1.11 assert round_up(1e308, 2) == 1e308 

La función de ronda indicada no funciona para enteros definidos como:

a = 8
redondo (a, 3)
8.0
a = 8.00
redondo (a, 3)
8.0
a = 8.000000000000000000000000
redondo (a, 3)
8.0

pero, trabaja para:

r = 400 / 3.0
r
133.33333333333334
redondo (r, 3)
133.333

Además, los decimales como 2.675 se redondean como 2.67, no 2.68.
Mejor uso el otro método proporcionado anteriormente.

La función de redondeo de python podría redondearse de la manera que no esperaba.

Puede ser más específico sobre el método de redondeo usando Decimal.quantize

p.ej.

 from decimal import Decimal, ROUND_HALF_UP res = Decimal('0.25').quantize(Decimal('0.0'), rounding=ROUND_HALF_UP) print(res) # prints 0.3 

Más referencia:

https://gist.github.com/jackiekazil/6201722