Python round to nearest thousand

List comprehension is a one-line loop which allows you to apply a function to the list items. (for more read List Comprehensions)

[x for x in rev_list]

In this case, round(num, -3) is the function.

>>> round(1300,-3)
1000
>>>

The answer

You can apply a function on a list by this code

rev_list=[round(x,-3) for x in rev_list]

The example:

>>> rev_list=[97277, 96494, 104541, 132060, 98179, 87862, 84718, 95391, 94674, 89773, 92790, 86122]
>>> rev_list=[round(x,-3) for x in rev_list]
>>> rev_list
[97000, 96000, 105000, 132000, 98000, 88000, 85000, 95000, 95000, 90000, 93000, 86000]
>>>

Table of Contents #

1. Round a number to the nearest 1000 in Python
2. Round a number Up to the nearest 1000 in Python
3. Round a Number Down to the nearest 1000 in Python

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.

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:

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.

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.

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.

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.

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.

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.

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.

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.

How do you round to the nearest 1000 in Python?

How do you round to the nearest 1000?

How do you round to the nearest whole number in Python?

How do you round to the nearest 500 in Python?