Skip to content
Tutorial Reference

How to Round Numbers in Python

Learn Python's rounding techniques with round(), math.floor(), and math.ceil() for decimals, multiples (5, 10, 100), nearest 0.5, and even numbers with code examples.

Rounding numbers is a fundamental operation in many programming tasks.

Python offers various methods for rounding numbers, whether you need to round to a specific decimal place, the nearest integer, or a multiple of another number (like 5, 10, 100, or even).

This guide covers the different rounding techniques available in Python, including using round(), math.floor(), and math.ceil().

Rounding to N Decimal Places (Nearest Tenth, Hundredth, etc.)

Using round()

The built-in round() function is the standard way to round a float to a specific number of decimal places:

result = round(4.5678, 1)
print(result)  # Output: 4.6

result = round(4.5678, 2)
print(result)  # Output: 4.57

result = round(4.5678)
print(result)  # Output: 5
  • The second argument ndigits specifies the number of digits after the decimal point to round to.
  • If ndigits is omitted, the function rounds to the nearest integer.

Formatting Output with f-strings

To display a float rounded to N decimal places (as a string), use f-string formatting:

my_float = 4.5678
print(f'{my_float:.1f}')  # Output: '4.6' (Rounds to 1 decimal place)
print(f'{my_float:.2f}')  # Output: '4.57' (Rounds to 2 decimal places)
  • :.Nf formats the float to N decimal places using fixed-point notation.

Rounding to the Nearest 0.5

Rounding to Nearest 0.5

To round to the nearest 0.5, multiply by 2, round to the nearest integer, then divide by 2:

def round_to_nearest_half(num):
    return round(num * 2) / 2

print(round_to_nearest_half(3.1))  # Output: 3.0
print(round_to_nearest_half(3.7))  # Output: 3.5

Rounding Up to Nearest 0.5

Use math.ceil() to round up to the nearest 0.5:

import math

def round_up_to_nearest_half(num):
    return math.ceil(num * 2) / 2

print(round_up_to_nearest_half(3.1))  # Output: 3.5
print(round_up_to_nearest_half(3.7))  # Output: 4.0

Rounding Down to Nearest 0.5

Use math.floor() to round down to the nearest 0.5:

import math

def round_down_to_nearest_half(num):
    return math.floor(num * 2) / 2

print(round_down_to_nearest_half(3.9))  # Output: 3.5
print(round_down_to_nearest_half(3.4))  # Output: 3.0

Rounding to the Nearest Multiple (5, 10, 100, 500, 1000)

You can round a number to the nearest multiple of any value (e.g., 5, 10, 100) using a general pattern.

General Approach: round(num / multiple) * multiple

This rounds to the closest multiple:

def round_to_nearest(num, multiple):
    return round(num / multiple) * multiple

print(round_to_nearest(26, 5))          # Output: 25

Rounding Up: math.ceil(num / multiple) * multiple

This rounds up to the next multiple:

import math

def round_up_to_nearest(num, multiple):
    return math.ceil(num / multiple) * multiple

print(round_up_to_nearest(23, 5))       # Output: 25
print(round_up_to_nearest(142, 100))    # Output: 200

Rounding Down: math.floor(num / multiple) * multiple

This rounds down to the previous multiple:

import math

def round_down_to_nearest(num, multiple):
    return math.floor(num / multiple) * multiple

print(round_down_to_nearest(129, 5))    # Output: 125
print(round_down_to_nearest(599, 100))  # Output: 500

Specific Examples (Nearest 10, 100, 500, 1000)

The built-in round() function has a special behavior for rounding to multiples of 10, 100, 1000, etc., using negative ndigits:

print(round(157, -1))   # Rounds to nearest 10 -> Output: 160
print(round(157, -2))   # Rounds to nearest 100 -> Output: 200
print(round(4678, -3))  # Rounds to nearest 1000 -> Output: 5000

import math
def round_up_to_nearest_10(num):
    return math.ceil(num / 10) * 10
print(round_up_to_nearest_10(21))       # Output: 30

def round_down_to_nearest_100(num):
    return math.floor(num / 100) * 100
print(round_down_to_nearest_100(546))   # Output: 500

def round_up_to_nearest_1000(num):
    return math.ceil(num / 1000) * 1000
print(round_up_to_nearest_1000(3100))   # Output: 4000

def round_down_to_nearest_1000(num):
    return math.floor(num / 1000) * 1000
print(round_down_to_nearest_1000(5999)) # Output: 5000

def round_to_nearest_500(num):
    return round(num / 500) * 500
print(round_to_nearest_500(1400))       # Output: 1500

def round_down_to_nearest_500(num):
    return math.floor(num / 500) * 500
print(round_down_to_nearest_500(999))   # Output: 500

Rounding to the Nearest Even Number

Rounding to Nearest Even

Use the general approach, dividing/multiplying by 2:

def round_to_nearest_even(num):
    return round(num / 2) * 2

print(round_to_nearest_even(3.1))  # Output: 4 (3.1/2=1.55 -> round(1.55)=2 -> 2*2=4)
print(round_to_nearest_even(8.6))  # Output: 8 (8.6/2=4.3 -> round(4.3)=4 -> 4*2=8)

Rounding Up to Nearest Even

Use math.ceil():

import math

def round_up_to_nearest_even(num):
    return math.ceil(num / 2) * 2

print(round_up_to_nearest_even(3.1))  # Output: 4
print(round_up_to_nearest_even(8.6))  # Output: 10

Rounding Down to Nearest Even

Use math.floor():

import math

def round_down_to_nearest_even(num):
    return math.floor(num / 2) * 2

print(round_down_to_nearest_even(3.1))  # Output: 2
print(round_down_to_nearest_even(8.6))  # Output: 8
Navigation