¿Cómo redondeas un número en Python?

floating-point integer

Question

Este problema me está matando. ¿Cómo se redondea un número hacia arriba en Python?

Intenté redondear (número) pero redondea el número hacia abajo. Ejemplo:

round(2.3) = 2.0 and not 3, what I would like

¡Intenté int (número + .5) pero redondea el número nuevamente! Ejemplo:

int(2.3 + .5) = 2

Luego lo intenté (número + .5) pero no funcionará en casos de borde. Ejemplo:

WAIT! THIS WORKED!

Por favor avise.

Answer 1

Básicamente soy un principiante en Python, pero si estás tratando de redondear hacia arriba en lugar de hacia abajo, ¿por qué no hacerlo?

round(integer) + 1

Answer 2

Creo que estás confundiendo los mecanismos de trabajo entre int() y round() .

int() siempre trunca los números decimales si se da un número flotante; mientras que round() , en el caso de 2.5 donde 2 y 3 están ambos a la misma distancia de 2.5 , Python devuelve lo que esté más alejado del punto 0.

round(2.5) = 3
int(2.5) = 2

Answer 3

El valor redondeado debe ser flotante.

a = 8
b = 21
print math.ceil(a / b)
>>> 0

pero

print math.ceil(float(a) / b)
>>> 1.0

Answer 4

Interesante tema de Python 2.x para tener en cuenta:

>>> import math
>>> math.ceil(4500/1000)
4.0
>>> math.ceil(4500/1000.0)
5.0

El problema es que dividir dos ints en python produce otro int y eso se trunca antes de la llamada del techo. Para obtener un resultado correcto, debe hacer que un valor sea un valor flotante (o emitido).

En javascript, el mismo código exacto produce un resultado diferente:

console.log(Math.ceil(4500/1000));
5

Answer 5

La función ceil (techo):

import math
print(math.ceil(4.2))

Answer 6

La sintaxis puede no ser tan pirónica como a uno le gustaría, pero es una biblioteca poderosa.

https://docs.python.org/2/library/decimal.html

from decimal import *
print(int(Decimal(2.3).quantize(Decimal(''1.''), rounding=ROUND_UP)))

Answer 7

Las respuestas anteriores son correctas, sin embargo, importar el módulo math solo para esta función, por lo general es un poco excesivo para mí. Por suerte, hay otra forma de hacerlo:

g = 7/5
g = int(g) + (not g.is_integer())

True y False se interpretan como 1 y 0 en una declaración que involucra números en python. g.is_interger() básicamente se traduce en g.has_no_decimal() o g == int(g) . Así que la última declaración en inglés lee la round g down and add one if g has decimal .

Answer 8

Me sorprende que nadie sugiera.

(numerator + denominator - 1) // denominator

Para división entera con redondeo hacia arriba. Solía ​​ser la forma común de C / C ++ / CUDA (cf. divup )

Answer 9

Me sorprende que no haya visto esta respuesta todavía round(x + 0.4999) , así que voy a round(x + 0.4999) . Tenga en cuenta que esto funciona con cualquier versión de Python. Los cambios realizados en el esquema de redondeo de Python han dificultado las cosas. Ver este post

Sin importar, yo uso:

def int_ceil(a, b):
return (a - 1) // b + 1
>>> int_ceil(19, 5)
4
>>> int_ceil(20, 5)
4
>>> int_ceil(21, 5)
5

Porque esto funciona

De los docs

Para los tipos incorporados que admiten round (), 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 hacia la elección par

Por lo tanto, 2.5 se redondea a 2 y 3.5 se redondea a 4. Si este no es el caso, entonces se puede redondear agregando 0.5, pero queremos evitar llegar al punto medio. Entonces, si agrega 0.4999 se acercará, pero con el margen suficiente para redondearlo a lo que normalmente esperaría. Por supuesto, esto fallará si x + 0.4999 es igual a [n].5000 , pero eso es poco probable.

Answer 10

Para aquellos que quieren redondear a a / b y obtener un entero:

Otra variante que usa división entera es

def roundUp(num):
return round(num + 0.49)
testCases = list(x*0.1 for x in range(0, 50))
print(testCases)
for test in testCases:
print("{:5.2f} -> {:5.2f}".format(test, roundUp(test)))

Answer 11

Para hacerlo sin ninguna importación:

>>> round_up = lambda num: int(num + 1) if int(num) != num else int(num)
>>> round_up(2.0)
2
>>> round_up(2.1)
3

Answer 12

Prueba esto:

a = 211.0
print(int(a) + ((int(a) - a) != 0))

Answer 13

Puedes usar el diseño del piso y agregarle 1. 2.3 // 2 + 1

Answer 14

Sé que esta respuesta es para una pregunta de hace un tiempo, pero si no quieres importar matemáticas y solo quieres redondear, esto funciona para mí.

>>> int(21 / 5)
4
>>> int(21 / 5) + (21 % 5 > 0)
5

La primera parte se convierte en 4 y la segunda parte se evalúa como "Verdadero" si hay un resto, lo que además es verdadero = 1; Falso = 0. Entonces, si no hay ningún resto, entonces permanece el mismo entero, pero si hay un resto, agrega 1.

Answer 15

Sé que esto es de hace bastante tiempo, pero encontré una respuesta bastante interesante, así que aquí va:

-round(-x-0.5)

Esto corrige los casos de bordes y funciona tanto para números positivos como negativos, y no requiere ninguna función de importación

Aclamaciones

Answer 16

Si no quiere importar nada, siempre puede escribir su propia función simple como:

def RoundUP(num): if num== int(num): return num return int(num + 1)

Answer 17

Si trabaja con números enteros, una forma de redondear es aprovechar el hecho de que // redondea hacia abajo: simplemente haga la división en el número negativo, luego niegue la respuesta. No se necesita importación, punto flotante o condicional.

rounded_up = -(-numerator // denominator)

Por ejemplo:

>>> print(-(-101 // 5))
21

Answer 18

Sin importar matematicas // usando envionment basico:

a) método / método de clase

def ceil(fl):
return int(fl) + (1 if fl-int(fl) else 0)
def ceil(self, fl):
return int(fl) + (1 if fl-int(fl) else 0)

b) lambda:

ceil = lambda fl:int(fl)+(1 if fl-int(fl) else 0)

Answer 19

También te podría gustar numpy:

>>> import numpy as np
>>> np.ceil(2.3)
3.0

No estoy diciendo que sea mejor que las matemáticas, pero si ya estaba usando el sistema numpy para otros propósitos, puede mantener su código consistente.

De todos modos, sólo un detalle que encontré. Uso mucho y me sorprendió que no se mencionara, pero, por supuesto, la respuesta aceptada funciona perfectamente bien.

Answer 20

cuando opera 4500/1000 en python, el resultado será 4, porque para python predeterminado asume como entero el resultado, lógicamente: 4500/1000 = 4.5 -> int (4.5) = 4 y ceil de 4 obviamente es 4

usando 4500 / 1000.0 el resultado será 4.5 y máximo de 4.5 -> 5

Al usar javascript, recibirá 4.5 como resultado de 4500/1000, porque javascript asume solo el resultado como "tipo numérico" y devuelve un resultado directamente como flotante

¡¡Buena suerte!!

Answer 21

ceil para redondear:

>>> import math
>>> math.ceil(5.4)
6.0

NOTA : La entrada debe ser flotante.

Si necesita un entero, llame a int para convertirlo:

>>> int(math.ceil(5.4))
6

Por cierto, use math.floor para redondear hacia abajo y round para redondear al entero más cercano.

>>> math.floor(4.4), math.floor(4.5), math.floor(5.4), math.floor(5.5)
(4.0, 4.0, 5.0, 5.0)
>>> round(4.4), round(4.5), round(5.4), round(5.5)
(4.0, 5.0, 5.0, 6.0)
>>> math.ceil(4.4), math.ceil(4.5), math.ceil(5.4), math.ceil(5.5)
(5.0, 5.0, 6.0, 6.0)

Answer 22

>>> def roundup(number):
... return round(number+.5)
>>> roundup(2.3)
3
>>> roundup(19.00000000001)
20

Esta función no requiere módulos.