Table of Contents
- How does rounding numbers work in Python?
- Overview of the Ceiling function
- math.floor(...) vs math.ceil(...)
- Ceiling constants in Python
- Ceiling negative numbers
- Next Steps
Rounding decimals is a basic mathematical operation that can prove very useful when programming. With Python, there are various ways to round decimal numbers. You can use the built-in function
round(...), or you can access other functions from the standard library
math. Two of such functions are the
math.floor(...) and the
In this article, we will explore the
math.ceil(...) function. We'll learn how it interacts with mathematical constants and negative numbers and compare it to the Python floor function
How does rounding numbers work in Python?
Rounding decimal numbers in basic mathematics has three simple rules:
- The number stays the same if the decimal is already a whole number.
- If the value after the decimal point is above 0.0 and below 0.5, the number rounds down.
- If the value after the decimal point is 0.5 or above, the number rounds up to the next whole number.
This form of rounding can be done with Python’s built-in
round(...) function, as shown below:
>>> round(1) 1 >>> round(1.5) 2 >>> round(1.49) 1 >>> round(1.8) 2
But then what is the point of the functions
math.ceil(...), which we can access from the
math library? Well, they both round floating point numbers in different ways.
Overview of the Ceiling function
The ceiling function in Python is part of the
math standard library. Essentially, the ceiling function always rounds decimal numbers up to the next whole number and returns an integer. For example:
>>> import math >>> >>> math.ceil(5.0) 5 >>> math.ceil(5.1) 6 >>> math.ceil(5.0000001) 6 >>> math.ceil(5.5) 6 >>> math.ceil(5.8) 6
Here, we first import the
math library. Then call the
math.ceil(...) function, with integer 5 as the argument, which returns the same number as an integer. But, using float 5.1 returns 6. In the next lines of code, we see that even if the value after the decimal point is as small as 0.0000001, or as large as 0.8, the ceiling function always rounds to the next whole number.
math.floor(...) vs math.ceil(...)
math.ceil(...) differ in the direction that the rounding occurs. The ceiling function rounds up to the next whole number, while the floor function rounds down to the previous whole number. Their names represent this exactly. One is called floor (below), and the other is ceil, referring to the ceiling (above). So, when rounding the number 1.5, 1 would be the floor, and 2 would be the ceiling.
Let’s look at how each function rounds floats side by side:
>>> from math import ceil, floor >>> >>> print(ceil(8.0), floor(8.0)) 8 8 >>> print(ceil(8.49), floor(8.49)) 9 8 >>> print(ceil(8.7), floor(8.7)) 9 8
In this example, we print the outputs of the
floor(...) with the same float. Using the float 8.0, we get the same value back as an integer. But we can see no matter what the decimal value of the float is, the
ceil(...) function will always round to the next whole number, while the
floor(...) function will always round down. Both always return an integer.
Ceiling constants in Python
The Python standard library
math contains several mathematical constants:
>>> math.pi # pi: ratio of a circle's circumference to its diameter 3.141592653589793 >>> math.e # e: base of the natural logarithm 2.718281828459045 >>> math.tau # tau: ratio of a circle's circumference to its radius, equal to 2? 6.283185307179586 >>> math.inf # floating-point positive infinity inf >>> -math.inf # floating-point negative infinity -inf >>> math.nan # not a number nan
Below, we can understand how the
ceil(...) function interacts with these constants:
>>> from math import ceil >>> import math >>> >>> ceil(math.pi) 4 >>> ceil(math.e) 3 >>> ceil(math.tau) 7 >>> ceil(math.inf) Traceback (most recent call last): File "<stdin>", line 1, in <module> OverflowError: cannot convert float infinity to integer >>> ceil(-math.inf) Traceback (most recent call last): File "<stdin>", line 1, in <module> OverflowError: cannot convert float infinity to integer >>> ceil(math.nan) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: cannot convert float NaN to integer
The pi, e, and tau constants work like any other float; they round to the next whole number. But, positive infinity, negative infinity, and
NaN produce throw a Python exception.
Both infinites produce the
OverflowError because the
ceil(...) function tries to output the next whole number, but infinity is too large, and the function cannot calculate it.
NaN produces an error because it is not a number and cannot be converted to a numeric type to be ceilinged.
Ceiling negative numbers
math.ceil(...) function works the same way with negative numbers, but it can be a bit confusing to the the reversed directions of positive and negative magnitudes. When the input is a negative number, the ceiling is still the closest whole integer that is greater than the input. This means that the ceiling of a negative decimal number is the next greatest integer toward zero. The opposite it true for floor.
>>> import math >>> >>> print(math.floor(1.4), math.ceil(1.4)) 1 2 >>> print(math.floor(-1.4), math.ceil(-1.4)) -2 -1 >>> print(math.floor(5.7), math.ceil(5.7)) 5 6 >>> print(math.floor(-5.7), math.ceil(-5.7)) -6 -5
In this example, two numbers 1.4 and 5.7, are inputted as positive and negative to the
math.floor(...) and the
Looking at the output from negative numbers allows us to better grasp how the ceiling function works. For positive numbers, the output of the ceiling function is the next whole number. But specifically, the next whole number on the right side of the number line. While flooring outputs the next whole number on the left side of the number line.
In this article, we learned how the
math.ceil(...) function works in Python. First, we looked at how rounding decimal numbers in Python works with the built-in
round(...) function. Then we compared the
math.ceil(...) functions. We saw examples of using the ceiling function with different mathematical constants. Finally, we saw how ceiling works with negative numbers and its relation to flooring.
In this article, we learned about ceiling in Python. To learn more about its counterpart, we wrote a more detailed look at the Python floor function.
If you're interested in learning more about the basics of Python, coding, and software development, check out our Coding Essentials Guidebook for Developers, where we cover the essential languages, concepts, and tools that you'll need to become a professional developer.
Thanks and happy coding! We hope you enjoyed this article. If you have any questions or comments, feel free to reach out to firstname.lastname@example.org.
Recommended product: Coding Essentials Guidebook for Developers