#### [SOLVED] How do you round UP a number in Python?

By bodacydo

This problem is killing me. How does one roundup a number UP in Python?

I tried round(number) but it round the number down. Example:

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

The I tried int(number + .5) but it round the number down again! Example:

``````int(2.3 + .5) = 2
``````

Then I tried round(number + .5) but it won't work in edge cases. Example:

``````WAIT! THIS WORKED!
``````

Please advise.

#### @Timo-m 2019-04-05 09:43:36

int() will always take the integer of the value and therefore always "round down", so to round up on integers one may use:

``````int(x) + 1
``````

As suggested before the math.ceil function would word, moreover numpy.ceil also exists, when you prefer to work with numpy.

#### @James Coyle 2019-04-05 10:33:14

That breaks for values that are already integers.

#### @andres 2018-11-21 15:02:57

My share

I have tested `print(-(-101 // 5)) = 21` given example above.

Now for rounding up:

``````101 * 19% = 19.19
``````

I can not use `**` so I spread the multiply to division:

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

#### @PonasM 2018-06-21 14:16:13

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

This function requires no modules.

#### @Bolboa 2018-10-20 23:01:35

What if your number is `3`, then it would round up to `4` which may or may not be what someone wants

#### @Nearoo 2019-01-06 18:47:14

This only works in 99% of all cases. You didn't think this through properly. Such solutions should be avoided at all costs.

#### @Pavel 2018-03-16 23:52:26

For those who want to round up `a / b` and get integer:

Another variant using integer division is

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

#### @SooBin Kim 2018-03-14 19:12:17

I think you are confusing the working mechanisms between `int()` and `round()`.

`int()` always truncates the decimal numbers if a floating number is given; whereas `round()`, in case of `2.5` where `2` and `3` are both within equal distance from `2.5`, Python returns whichever that is more away from the 0 point.

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

#### @Nearoo 2018-06-19 12:43:49

"rounding up" means that e.g. `2.3` gets turned into `3`, which happens in neither of your examples.

#### @Steve Tjoa 2010-03-01 14:40:58

The ceil (ceiling) function:

``````import math
print(math.ceil(4.2))
``````

#### @R. W. Sinnet 2015-08-26 23:37:05

Elaboration: math.ceil returns the smallest integer which is greater than or equal to the input value. This function treats the input as a float (Python does not have strongly-typed variables) and the function returns a float. If you want an int, you can construct an int from the return value, i.e., `int(math.ceil(363))`

#### @TheEspinosa 2016-01-08 12:54:10

@Sinnet: Actually one could say that python is strongly typed stackoverflow.com/a/11328980/5069869

#### @quamrana 2017-12-17 12:27:22

@TheEspinosa: Yes, python is definitely strongly typed, its just that many functions ask questions about the type of some parameters and execute different code depending on the answer.

#### @Arthur Tacca 2018-05-02 15:50:12

@R.W.Sinnet In Python 3, `math.ceil` returns an actual integer object, not just floating object with integer value.

#### @TrophyGeek 2011-10-31 06:39:44

Interesting Python 2.x issue to keep in mind:

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

The problem is that dividing two ints in python produces another int and that's truncated before the ceiling call. You have to make one value a float (or cast) to get a correct result.

In javascript, the exact same code produces a different result:

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

#### @gecco 2011-10-31 06:46:58

In Python 2.x : int/int --> int and int/float --> float In Python 3.x : int/int can result in a float

#### @Rob Dennis 2013-10-22 17:54:56

you can get the Python 3.x on behavior on certain versions of Python 2.x by enabling "true division" as shown here

#### @user3712978 2017-12-04 22:22:47

Try this:

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

#### @Tom Aranda 2017-12-04 23:01:25

Clever. The `((int(a) - a) != 0)` expression returns `1` whenever `a` needs to be rounded up. You may want to expand your answer and explain how this work.

#### @Bowen Liu 2018-12-18 20:51:06

@TomAranda Can anyone explain how a boolean expression evaluates to a value please?

#### @Tom Aranda 2018-12-18 23:46:55

That is a better question for the OP. I just edited for code formatting.

#### @Kuřátko Zvyk 2017-11-19 12:09:29

Without importing math // using basic envionment:

a) method / class method

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

#### @Sebin 2017-03-19 13:49:15

If you don't want to import anything, you can always write your own simple function as:

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

#### @Johannes Maria Frank 2017-03-28 00:01:12

This does not work if num is 2.05. You have to have at least as many digits with a 9 as your input, leaving you with a 0.999... which is 1. But then your corner case 2 is rounded up again. -- Well, I guess there is a reason why math.ceil is there.

#### @Nearoo 2017-05-05 03:23:21

The above answers are correct, however, importing the `math` module just for this one function usually feels like a bit of an overkill for me. Luckily, there is another way to do it:

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

`True` and `False` are interpreted as `1` and `0` in a statement involving numbers in python. `g.is_interger()` basically translates to `g.has_no_decimal()` or `g == int(g)`. So the last statement in English reads `round g down and add one if g has decimal`.

#### @Nearoo 2017-05-05 03:23:45

And if you feel fancy, you can use `int(g) + (g % 1 > 0)` instead ;-)

#### @SH7890 2019-01-25 21:50:57

`from math import ceil` seems to fix importing the entire math module :)

#### @Nearoo 2019-01-27 16:52:06

@SH7890 I'm afraid that line isn't much different to `import math` in terms of what happens behind the scenes. It just drops all symbols except `ceil`.

#### @erick vicente 2017-04-27 16:46:36

when you operate 4500/1000 in python, result will be 4, because for default python asume as integer the result, logically: 4500/1000 = 4.5 --> int(4.5) = 4 and ceil of 4 obviouslly is 4

using 4500/1000.0 the result will be 4.5 and ceil of 4.5 --> 5

Using javascript you will recieve 4.5 as result of 4500/1000, because javascript asume only the result as "numeric type" and return a result directly as float

Good Luck!!

#### @Nearoo 2018-06-19 12:41:30

That's only true in Python 2.x. In Python 3, division with a single `/` always results in a float, so `4500/1000` is always 4.5.

#### @Andreas Schuh 2017-04-08 09:52:00

I am surprised nobody suggested

``````(numerator + denominator - 1) // denominator
``````

for integer division with rounding up. Used to be the common way for C/C++/CUDA (cf. `divup`)

#### @Bharel 2017-07-06 12:31:19

Relevant only for statically typed languages. If the denominator is a float you're dead.

#### @kennytm 2010-03-01 14:41:23

Use `math.ceil` to round up:

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

NOTE: The input should be float.

If you need an integer, call `int` to convert it:

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

BTW, use `math.floor` to round down and `round` to round to nearest integer.

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

#### @guival 2017-02-24 10:33:26

The input does not necessarily need to be a float if using python 3: `ceil()` will take care of it internally

#### @Klik 2016-09-08 06:31:20

I'm surprised I haven't seen this answer yet `round(x + 0.4999)`, so I'm going to put it down. Note that this works with any Python version. Changes made to the Python rounding scheme has made things difficult. See this post.

Without importing, I use:

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

Why this works

From the docs

For the built-in types supporting round(), values are rounded to the closest multiple of 10 to the power minus n; if two multiples are equally close, rounding is done toward the even choice

Therefore 2.5 gets rounded to 2 and 3.5 gets rounded to 4. If this was not the case then rounding up could be done by adding 0.5, but we want to avoid getting to the halfway point. So, if you add 0.4999 you will get close, but with enough margin to be rounded to what you would normally expect. Of course, this will fail if the `x + 0.4999` is equal to `[n].5000`, but that is unlikely.

#### @blubberdiblub 2016-11-14 09:08:42

Using 0.4999, it will fail to give a correct result for any input in between ???.0000 and ???.0001 (open interval), not just exactly ???.0001. For instance, if you try it with 3.00005, you will get a result of 3 instead of the expected 4. Of course you can decrease the likelihood of this happening by adding more and more digits up to the maximum precision of floats, but what's the point to that if there are more robust and intuitive solutions at hand, like using `math.ceil()`?

#### @Klik 2016-11-14 22:23:45

@blubberdiblub In my answer I state `Without importing I use:`. I've also mentioned that it will fail if the `x + 0.4999` is equal to `[n].5000`.

#### @blubberdiblub 2016-11-17 05:59:30

Yes, you state in your answer that your solution is without importing, but I don't see the value of it. The `math` module and `math.ceil()` is in the standard library, so available everywhere for all practical purposes without installing extra stuff. And regarding your mention of when it fails, this is incomplete in your answer, as it fails for a whole interval, not just for a single point. Technically, you could argue you are correct, as you say if and not iff, but it will make the impression on the casual reader that it is less likely than it really is.

#### @user6612280 2016-07-20 07:07:54

You can use floor devision and add 1 to it. 2.3 // 2 + 1

#### @guival 2017-02-24 10:34:58

or use `ceil()` instead of weirdly doing the opposite and then compensating

#### @Carl Thomé 2017-07-26 15:36:22

This won't work. For example: `from math import ceil; assert 4 // 2 + 1 == ceil(4 / 2)`

#### @Daniel 2016-06-01 02:46:14

I'm basically a beginner at Python, but if you're just trying to round up instead of down why not do:

``````round(integer) + 1
``````

#### @Pranav Shukla 2016-06-01 02:52:38

This will not work for any integer i where 2.5 < integer < 3. The desired value after rounding up is 3 but your expression will turn it into 4.

#### @Klik 2016-09-08 05:33:57

I think you mean `round(integer + 0.5)` This is what I often do

#### @David Bau 2016-02-01 08:23:29

If working with integers, one way of rounding up is to take advantage of the fact that `//` rounds down: Just do the division on the negative number, then negate the answer. No import, floating point, or conditional needed.

``````rounded_up = -(-numerator // denominator)
``````

For example:

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

#### @Klik 2016-09-08 06:33:49

What about when you don't need to perform any math operation? I.e. you just have one number.

#### @Marco smdm 2017-04-04 08:57:13

@Klik: then you can just divide by 1 ==> -( -num // 1) and you are getting your answer :-) Have a nice day! David Bau: very nice proposal!

#### @mini totent 2017-07-20 18:23:48

I timed all the answers in here and this was five times faster than the next best (math.ceil). @Andreas had the same time

#### @Salyangoz 2018-09-04 08:48:21

very nice solve without importing the math lib.

#### @Nearoo 2019-01-06 18:44:06

@minitotent That is not surprising since it's simple integer division and a couple of single-cycle operations. This is the sort of answer that gets you a job: Understanding not only the language, but all the layers of abstractions beneath it.

#### @NuclearPeon 2015-03-27 19:21:19

The syntax may not be as pythonic as one might like, but it is a powerful library.

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

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

#### @user3074620 2014-05-11 07:28:39

I know this answer is for a question from a while back, but if you don't want to import math and you just want to round up, this works for me.

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

The first part becomes 4 and the second part evaluates to "True" if there is a remainder, which in addition True = 1; False = 0. So if there is no remainder, then it stays the same integer, but if there is a remainder it adds 1.

#### @naught101 2015-08-19 13:04:36

Nice. You can also use `//` for integer division, so this becomes `21 // 5 + (21 % 5 > 0)`.

#### @Nico Schlömer 2017-07-16 21:39:00

This is the best solution if only integers are involved. No unnecessary `float`s. Nice.

#### @Fenmaz 2015-01-14 08:15:01

I know this is from quite a while back, but I found a quite interesting answer, so here goes:

``````-round(-x-0.5)
``````

This fixes the edges cases and works for both positive and negative numbers, and doesn't require any function import

Cheers

#### @Diblo Dk 2015-06-19 20:44:41

This will still rounds down `-round(-x-0.3) = x`

#### @Alexey 2014-07-30 19:27:18

Be shure rounded value should be float

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

but

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

#### @gorttar 2014-06-15 00:34:53

To do it without any import:

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

#### @Lisa 2013-04-26 16:27:43

You might also like numpy:

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

I'm not saying it's better than math, but if you were already using numpy for other purposes, you can keep your code consistent.

Anyway, just a detail I came across. I use numpy a lot and was surprised it didn't get mentioned, but of course the accepted answer works perfectly fine.

#### @Marco smdm 2017-04-04 08:52:02

Using numpy is nice too. The easiest would be with math since it is already part of python built in libraries. It makes more sense. Instead as you mentioned if you use a lot numpy for other issues, then it makes sense and consistent to use numpy.ceil :-) Good hint!

#### @AtilioA 2018-08-26 13:23:35

Great if you're already using numpy (my case).

### [SOLVED] How do I generate random integers within a specific range in Java?

• 2008-12-12 18:20:57
• user42155
• 3788834 View
• 3207 Score
• 64 Answer
• Tags:   java random integer