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

Este problema me está matando. ¿Cómo se acumula un número UP en Python?

Intenté redondear (número) pero redondeó 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 intenté round (número + .5) pero no funcionará en casos extremos. Ejemplo:

WAIT! THIS WORKED!

Por favor avise.

El ceil función (techo):

import math
print(math.ceil(4.2))

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, que además es Verdadero = 1; False = 0. Entonces, si no hay resto, entonces permanece el mismo número entero, pero si hay un resto agrega 1.

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

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

El problema es que dividir dos entradas en python produce otro int y se trunca antes de la llamada al techo. Tienes que hacer que un valor sea flotante (o lanzado) para obtener un resultado correcto.

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

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

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

rounded_up = -(-numerator // denominator)

Por ejemplo:

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

También te puede interesar numpy:

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

No digo que sea mejor que las matemáticas, pero si ya estabas usando numpy para otros fines, puedes mantener tu código consistente.

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

Usemath.ceil para redondear:

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

NOTA : La entrada debe ser flotante.

Si necesita un número entero, llame intpara convertirlo:

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

Por cierto, use math.floorpara redondear hacia abajo y roundpara 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)

La sintaxis puede no ser tan pitónica como uno quisiera, 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)))

Me sorprende que nadie sugirió

(numerator + denominator - 1) // denominator

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

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

Prueba esto:

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

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

Esta función no requiere módulos.

Las respuestas anteriores son correctas, sin embargo, importar el mathmódulo solo para esta función generalmente me parece un poco exagerado. Afortunadamente, hay otra forma de hacerlo:

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

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

Sin importar matemáticas // usando el entorno básico:

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)

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

Otra variante que usa la división de enteros es

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

En caso de que alguien esté buscando redondear a un lugar decimal específico:

import math
def round_up(n, decimals=0):
    multiplier = 10 ** decimals
    return math.ceil(n * multiplier) / multiplier

Me sorprende no haber visto esta respuesta todavía round(x + 0.4999), así que la voy a dejar. 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 esta publicación .

Sin importar, uso:

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)))

Por que esto funciona

De los documentos

Para los tipos integrados 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 opción pareja

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

Para hacerlo sin importar nada:

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

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

-round(-x-0.5)

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

Salud

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

usando 4500 / 1000.0, el resultado será 4.5 y un techo de 4.5 -> 5

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

¡¡Buena suerte!!

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

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

Puede usar el diseño del piso y agregarle 1. 2,3 // 2 + 1

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.5dónde 2y 3ambos están a la misma distancia 2.5, Python devuelve el que esté más alejado del punto 0.

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

Mi parte

He probado print(-(-101 // 5)) = 21 ejemplo anterior.

Ahora para redondear:

101 * 19% = 19.19

No puedo usar, **así que extendí la multiplicación a la división:

(-(-101 //(1/0.19))) = 20

Básicamente soy un principiante en Python, pero si solo estás intentando redondear en lugar de bajar, ¿por qué no hacerlo?

round(integer) + 1