To round a number up in Python, import the `math`

library with `import math`

, and call `math.ceil(number)`

. The function returns the ceiling of the specified `number`

that is defined as the smallest integer greater than or equal to `number`

The following code shows how to round the number 42.42 up to 43.

>>> import math >>> math.ceil(42.42) 43

If you don’t want to import the `math`

module, you can use the following one-liner beauty:

x = int(input('your number: ')) rounded_up = int(x) + (int(x)!=x)

- The
`int()`

built-in function cuts of the decimal part, i.e., rounds down. - The expression
`int(x)!=x`

evaluates to 1 if the decimal part of`x`

is greater than 0. Otherwise, it becomes 0. - This helps us because only if the decimal part is greater than 0, we need to add +1 to the rounded-down number to round it up.

## Rounding Up After Division

If the float to be rounded up comes from a division operation `a/b`

, you can also use integer division `a//b`

to round down to the next integer, and increment this by one. Thus, the expression `a//b+1`

rounds the resulting number up if `a`

is not divisible by `b`

, otherwise, the result of `a//b`

would already provide the “rounded-up” semantics.

You can create a simple ternary operator `x if y else z`

to differentiate between those two conditions:

a = int(input('a=')) b = int(input('b=')) rounded_up = a//b + 1 if a%b else a//b print(rounded_up)

The code goes through the following steps:

- Get the input strings from the user using the built-in
`input()`

function. - Convert the inputs to integer values using the built-in
`int()`

function. - Use the modulo operation
`a%b`

to differentiate between`b`

being a divisor of`a`

or not. - If not, the result will have a remainder and you can use integer division
`a//b`

to round down and increment this by one. - If yes, the result won’t have a remainder and you can simply use integer division because it, mathematically, would already be considered to be rounded up.
- You use the ternary operator to pack this logic into a single line of code.

Here’s an example execution that was rounded up:

a=8 b=3 3

And here’s an example execution that wasn’t:

a=8 b=4 2

An alternative one-liner to round up two integers would be the following beauty:

a = int(input('a=')) b = int(input('b=')) rounded_up = a // b + (a % b > 0) print(rounded_up)

The expression `(a % b > 0)`

evaluates to `True`

if `b`

is not a divisor of `a`

, otherwise it evaluates to `False`

. As the Boolean `True`

is represented by the integer value 1 in Python and Boolean `False`

by the integer value 0 in Python, the expression increments only if `b`

is not a divisor of `a`

.

## Python One-Liners Book: Master the Single Line First!

**Python programmers will improve their computer science skills with these useful one-liners.**

*Python One-Liners* will teach you how to read and write “one-liners”: ** concise statements of useful functionality packed into a single line of code. **You’ll learn how to systematically unpack and understand any line of Python code, and write eloquent, powerfully compressed Python like an expert.

The book’s five chapters cover (1) tips and tricks, (2) regular expressions, (3) machine learning, (4) core data science topics, and (5) useful algorithms.

Detailed explanations of one-liners introduce ** key computer science concepts **and

**. You’ll learn about advanced Python features such as**

*boost your coding and analytical skills**,*

**list comprehension****,**

*slicing***,**

*lambda functions***,**

*regular expressions***and**

*map***functions, and**

*reduce***.**

*slice assignments*You’ll also learn how to:

- Leverage data structures to
**solve real-world problems**, like using Boolean indexing to find cities with above-average pollution - Use
**NumPy basics**such as*array*,*shape*,*axis*,*type*,*broadcasting*,*advanced indexing*,*slicing*,*sorting*,*searching*,*aggregating*, and*statistics* - Calculate basic
**statistics**of multidimensional data arrays and the K-Means algorithms for unsupervised learning - Create more
**advanced regular expressions**using*grouping*and*named groups*,*negative lookaheads*,*escaped characters*,*whitespaces, character sets*(and*negative characters sets*), and*greedy/nongreedy operators* - Understand a wide range of
**computer science topics**, including*anagrams*,*palindromes*,*supersets*,*permutations*,*factorials*,*prime numbers*,*Fibonacci*numbers,*obfuscation*,*searching*, and*algorithmic sorting*

By the end of the book, you’ll know how to ** write Python at its most refined**, and create concise, beautiful pieces of “Python art” in merely a single line.

*Get your Python One-Liners on Amazon!!*

While working as a researcher in distributed systems, Dr. Christian Mayer found his love for teaching computer science students.

To help students reach higher levels of Python success, he founded the programming education website Finxter.com. He’s author of the popular programming book Python One-Liners (NoStarch 2020), coauthor of the Coffee Break Python series of self-published books, computer science enthusiast, freelancer, and owner of one of the top 10 largest Python blogs worldwide.

His passions are writing, reading, and coding. But his greatest passion is to serve aspiring coders through Finxter and help them to boost their skills. You can join his free email academy here.