¿Cómo se redondea hacia arriba un número en Python?

Question

Este problema me está matando. ¿Cómo se rodeo de un número hasta en Python?

Me trató ronda (número) pero redondear el número. Ejemplo:

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

El tratado I int (número + 0.5) pero redondear el número de nuevo! Ejemplo:

int(2.3 + .5) = 2

Luego probé ronda (número + 0.5) pero no funcionará en casos extremos. Ejemplo:

WAIT! THIS WORKED!

Por favor avise.

Answer 1

La función ceil (techo):

import math
print(math.ceil(4.2))

Answer 2

tema interesante 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 la división de dos enteros en pitón produce otro int y que está truncada antes de la llamada de techo. Usted tiene que tomar un valor de un flotador (o molde) para obtener un resultado correcto.

en JavaScript, exactamente el mismo código produce un resultado diferente:

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

Answer 3

Sé que esta respuesta es una pregunta de un tiempo, pero si usted no quiere matemáticas importación y lo que desea redondear hacia arriba, 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 evalúa a "true" si hay un resto, que además True = 1; Falso = 0. Por lo tanto, si no hay residuo, a continuación, se mantiene el mismo número entero, pero si hay un resto que añade 1.

Answer 4

Si se trabaja con números enteros, una forma de redondeo es tomar ventaja del hecho de que las rondas // abajo: Apenas haga la división del número negativo, entonces anulan la respuesta. Sin importar, punto flotante, o condicional sea necesario.

rounded_up = -(-numerator // denominator)

Por ejemplo:

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

Answer 5

También te numpy:

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

No estoy diciendo que es mejor que las matemáticas, pero si ya estaba utilizando numpy para otros fines, puede mantener su código consistente.

De todos modos, sólo un detalle que me encontré. Yo uso numpy mucho y me sorprendió que no consiguió mencionado, pero por supuesto la respuesta aceptada funciona perfectamente bien.

Answer 6

Uso math.ceil para arriba redonda:

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

Nota: . La entrada debe ser flotante

Si necesita un entero, int llamada para convertirlo:

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

Por cierto, el uso de math.floor redonda por y round a ronda de número 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 7

La sintaxis puede no ser tan Pythonic como uno quiera, pero es una biblioteca de gran alcance.

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

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

Answer 8

Me sorprende que nadie sugirió

(numerator + denominator - 1) // denominator

para la división de número entero con redondeo. Se utiliza para ser la forma común para C / C ++ / CUDA (divup cf.)

Answer 9

Sé Shure valor redondeado debe ser flotante

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

y

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

Answer 10

Prueba esto:

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

Answer 11

Las respuestas anteriores son correctas, sin embargo, importando el módulo math sólo para esta función por lo general se siente como un poco de una exageración para mí. Afortunadamente, hay otra manera de hacerlo:

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

True y False se interpretan como 1 y 0 en un comunicado que se usan números en Python. g.is_interger() básicamente se traduce en g.has_no_decimal() o g == int(g). Así que la última instrucción en Inglés lee round g down and add one if g has decimal.

Answer 12

Sin importar matemáticas // usando envionment básica:

a) método de método / 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 13

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

Esta función no requiere módulos.

Answer 14

Para los que quieren reunir a a / b y obtener entero:

Otra variante usando división entera 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

Answer 15

Me sorprende que no he visto esta respuesta todavía round(x + 0.4999), así que voy a dejar de leerlo. Tenga en cuenta que esto funciona con cualquier versión de Python. Los cambios realizados en el esquema de redondeo Python ha puesto las cosas difíciles. Ver este posterior .

Sin importar, yo 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 qué funciona este

A partir de los documentos

  

Para la ronda tipos incorporados de soporte (), los valores se redondean al múltiplo más cercano de 10 a la potencia menos n; si dos múltiplos son igual de cerca, redondeo se realiza hacia la elección aún

Por lo tanto 2.5 se redondea a 2 y 3.5 se redondea a 4. Si este no era el caso, entonces redondeo que se podría hacer mediante la adición de 0,5, pero queremos evitar llegar a la mitad del camino. Por lo tanto, si se agrega 0,4999 obtendrá cerca, pero con margen suficiente para ser redondeado a lo que se esperaría normalmente. Por supuesto, esto fallará si el x + 0.4999 es igual a [n].5000, pero eso es poco probable.

Answer 16

Para hacerlo sin ningún tipo de 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 17

Sé que esto es de un bastante tiempo atrás, pero he encontrado una respuesta muy interesante, así que aquí va:

-round(-x-0.5)

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

Saludos

Answer 18

cuando se opera en 4500/1000 pitón, resultado será 4, porque para ASUME pitón por defecto como entero el resultado, lógicamente: 4500/1000 = 4,5 -> int (4,5) = 4 y ceil de 4 obviouslly es 4

usando 4500 / 1000.0 el resultado será 4,5 y ceil de 4,5 -> 5

El uso de Javascript que recibirá 4,5 como resultado de 4500/1000, debido Javascript ASUME sólo el resultado como "tipo numérico" y devolver un resultado directamente como flotador

Buena suerte !!

Answer 19

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

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

Answer 20

Se puede usar la división suelo y añadir 1 a la misma. 2.3 // 2 + 1

Answer 21

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

int() siempre trunca los números decimales si se le da un número flotante; mientras que round(), en caso de 2.5 donde 2 y 3 son tanto dentro de la misma distancia de 2.5, Python vuelve lo que es más lejos del punto 0.

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

Answer 22

Mi parte

I han probado print(-(-101 // 5)) = 21 dado ejemplo anterior.

Ahora para el redondeo:

101 * 19% = 19.19

No puedo usar ** extendí la multiplicación de división:

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

Answer 23

https://docs.python.org/2/library/math.html buscar Math.ceil

"Return el techo de x como un flotador, el valor más pequeño mayor número entero que o igual a x."

Answer 24

Básicamente soy un principiante en Python, pero si usted está tratando de redondear en vez de bajar por qué no hacer:

round(integer) + 1