# Round a number to the nearest 1000 in Python

Last updated: Jul 11, 2022

Photo from Unsplash

## Round a number to the nearest 1000 in Python#

Use the `round()` function to round a number to the nearest 1000, e.g. `result = round(num, -3)`. When the `round()` function is called with a second argument of `-3`, it rounds to the closest multiple of one thousand.

main.py
```Copied!```import math

# ✅ Round number to nearest 1000

num_1 = 4678
result_1 = round(num_1, -3)
print(result_1)  # 👉️ 5000

num_2 = 4432
result_2 = round(num_2, -3)
print(result_2)  # 👉️ 4000

# --------------------------------------

# ✅ Round number UP to nearest 1000

def round_up_to_nearest_1000(num):
return math.ceil(num / 1000) * 1000

print(round_up_to_nearest_1000(3100))  # 👉️ 4000
print(round_up_to_nearest_1000(1))  # 👉️ 1000

# --------------------------------------

# ✅ Round number DOWN to nearest 1000

def round_down_to_nearest_1000(num):
return math.floor(num / 1000) * 1000

print(round_down_to_nearest_1000(5999))  # 👉️ 5000
print(round_down_to_nearest_1000(5004))  # 👉️ 5000
``````

We used the `round()` function to round a number to the nearest 1000.

The round function takes the following 2 parameters:

NameDescription
`number`the number to round to `ndigits` precision after the decimal
`ndigits`the number of digits after the decimal, the number should have after the operation (optional)
When `ndigits` is a negative number, the `round()` function rounds to the left of the decimal.
• If `ndigits` is `-1`, the function rounds to the closest multiple of `10`.
• If `ndigits` is `-2`, it rounds to the nearest `100`.
• If `ndigits` is `-3`, it rounds to the nearest `1000`, etc.
main.py
```Copied!```print(round(3456, -1))  # 👉️ 3460
print(round(3456, -2))  # 👉️ 3500
print(round(3456, -3))  # 👉️ 3000
``````

## Round a number Up to the nearest 1000 in Python#

To round a number up to the nearest 1000:

1. Call the `math.ceil()` method passing it the number divided by `1000`.
2. Multiply the result by `1000`.
3. The result of the calculation is the number rounded up to the nearest thousand.
main.py
```Copied!```import math

def round_up_to_nearest_1000(num):
return math.ceil(num / 1000) * 1000

print(round_up_to_nearest_1000(3100))  # 👉️ 4000
print(round_up_to_nearest_1000(1))  # 👉️ 1000
print(round_up_to_nearest_1000(2350))  # 👉️ 3000
``````

The math.ceil method returns the smallest integer greater than or equal to the provided number.

main.py
```Copied!```import math

print(math.ceil(1234.001)) # 👉️ 1235
print(math.ceil(1234.999)) # 👉️ 1235
``````
If the passed in number has a fractional part, the `math.ceil` method rounds the number up.

Here is a step-by-step example of rounding a number up to the nearest thousand.

main.py
```Copied!```import math

print(4258 / 1000)  # 👉️ 4.258
print(5600 / 1000)  # 👉️ 5.6

print(math.ceil(4258 / 1000))  # 👉️ 5
print(math.ceil(5600 / 1000))  # 👉️ 6

print(math.ceil(4258 / 1000) * 1000)  # 👉️ 5000
print(math.ceil(5600 / 1000) * 1000)  # 👉️ 6000
``````
We first divide the number by `1000` and then multiply with `1000` to shift 3 decimal places to the right and left, so that `math.ceil()` works on the thousands.

This is a two step process:

1. Divide the number by `1000` and round the result up to the nearest integer.
2. Multiply the result by `1000` to get the number rounded up to the nearest `1000`.

## Round a Number Down to the nearest 1000 in Python#

To round a number down to the nearest 100:

1. Call the `math.floor()` method passing it the number divided by `1000`.
2. Multiply the result by `1000`.
3. The result of the calculation is the number rounded down to the nearest `1000`.
main.py
```Copied!```import math

def round_down_to_nearest_1000(num):
return math.floor(num / 1000) * 1000

print(round_down_to_nearest_1000(5999))  # 👉️ 5000
print(round_down_to_nearest_1000(5004))  # 👉️ 5000
print(round_down_to_nearest_1000(7900))  # 👉️ 7000
``````

The math.floor method returns the largest integer less than or equal to the provided number.

main.py
```Copied!```import math

print(math.floor(13.999)) # 👉️ 13
print(math.floor(13.001)) # 👉️ 13
``````
If the passed in number has a fractional part, the `math.floor` method rounds the number down.

Here is a step-by-step example of rounding a number down to the nearest 1000.

main.py
```Copied!```import math

print(5900 / 1000)  # 👉️ 5.9
print(4300 / 1000)  # 👉️ 4.3

print(math.floor(5900 / 1000))  # 👉️ 5
print(math.floor(4300 / 1000))  # 👉️ 4

print(math.floor(5900 / 1000) * 1000)  # 👉️ 5000
print(math.floor(4300 / 1000) * 1000)  # 👉️ 4000
``````
We first divide the number by `1000` and then multiply with `1000` to shift 3 decimal places to the right and left, so that `math.floor()` works on the thousands.

This is a two step process:

1. Divide the number by `1000` and round the result down to the nearest integer.
2. Multiply the result by `1000` to get the number rounded down to the nearest `1000`.
I wrote a book in which I share everything I know about how to become a better, more efficient programmer.
You can use the search field on my Home Page to filter through all of my articles.