Your total is: $48.40
Rounding numbers is a common operation in many programming tasks. Whether you‘re working with currency values, measurements, percentages, or any other real-world quantities, you‘ll often need to round your calculations to a fixed number of decimal places.
In this expert Python tutorial, we‘ll take an in-depth look at how to round numbers to 2 decimal places in Python. We‘ll start with the basics of what decimal places are and how rounding works, then show you multiple ways to perform this task in your Python code.
By the end of this guide, you‘ll be equipped with the knowledge and code samples to handle all your decimal rounding needs. Let‘s dive in!
Understanding Decimal Places and Rounding
Before we get into the Python specifics, let‘s make sure we‘re on the same page about what decimal places are and how rounding to a certain number of decimal places works.
In our standard base-10 number system, the digits to the right of the decimal point represent fractional parts of powers of 10. The first digit after the decimal point is the tenths place, the second digit is the hundredths place, the third is the thousandths place, and so on.
For example, consider the number 3.14159. Here‘s what each digit represents:
3 . 1 4 1 5 9 ↑ | | | | └─ Ten thousandths (10^-5) ↑ | | | └────── Thousandths (10^-4) ↑ | | └─────────── Hundredths (10^-3) ↑ | └────────────────── Tenths (10^-2) ↑ └───────────────────────── Ones (10^-1) └──────────────────────────────── Decimal point
When we round a number to a certain number of decimal places, we look at the digit just to the right of the desired decimal place. If that digit is 5 or greater, we round up by adding 1 to the digit in the desired decimal place. If the next digit is less than 5, we round down by leaving the desired decimal place as is and dropping all the digits that follow.
So to round 3.14159 to 2 decimal places, we look at the third digit after the decimal point since that‘s just beyond the hundredths place we want. The 1 in the thousandths place is less than 5, so we round down, giving us 3.14.
If we wanted to round 2.71828 to 2 decimal places, the 8 in the third decimal place is greater than 5, so we would round up the 1 in the hundredths place to a 2, resulting in 2.72.
Make sense so far? Great! Now let‘s look at how to actually do this in Python.
Rounding to 2 Decimal Places with Python‘s built-in round() Function
Python makes it very straightforward to round numbers using the built-in round() function. round() takes two arguments:
- The number you want to round
- An optional number of decimal places you want to round to (which defaults to 0 if omitted)
To round a number to 2 decimal places, simply pass the number and 2 to round(). For example:
>>> round(3.14159, 2) 3.14 >>> round(2.71828, 2) 2.72
Easy, right? round() follows the rounding rules we discussed in the previous section. 3.14159 gets rounded down to 3.14 because the 1 in the third decimal place is less than 5. And 2.71828 gets rounded up to 2.72 since the 8 in the third decimal place is 5 or greater.
round() works just as well for negative numbers and numbers that are already rounded to 2 or fewer decimal places:
>>> round(-2.84953, 2) -2.85 >>> round(4.5, 2) 4.5 >>> round(8.0, 2) 8.0
One quirk to watch out for is how round() handles numbers that end in exactly 5 in the decimal place you‘re rounding to. In Python 3, round() uses "banker‘s rounding" in this case.
What that means is that round(2.675, 2) will round to 2.68 instead of 2.67 like you might expect. This is because 2.675 is exactly halfway between 2.67 and 2.68. With banker‘s rounding, the number gets rounded to the nearest even digit (8 in this case) instead of always rounding up. This avoids consistently over-estimating when rounding many numbers.
>>> round(2.675, 2) # 5 in the third decimal place 2.68 >>> round(1.645, 2) 1.64
While this behavior can seem unintuitive at first, it‘s a well-established method for minimizing rounding bias. Just be aware that it may give results you don‘t expect if you‘re working with numbers that end in 5 at your desired decimal place.
Rounding String Representations of Numbers
So what if you have a number stored as a string instead of a numeric type? No problem! Just convert it to a float first with float(), then pass it to round() as usual:
>>> num_string = "6.824693" >>> round(float(num_string), 2) 6.82
You can also use Python f-strings to easily format your rounded result back into a string with 2-decimal places:
>>> num = 8.91743
>>> f"Rounded: {num:.2f}"
‘Rounded: 8.92‘
The :.2f specifies a floating-point format with 2 digits after the decimal point. The rounding here always rounds down though, so be careful – 8.91743 rounded to 2 decimal places should really be 8.92.
For full control over rounding in string formatting, use round() to round your number first, then plug it into an f-string or other string formatting method:
>>> rounded_num = round(num, 2)
>>> f"Rounded: {rounded_num:.2f}"
‘Rounded: 8.92‘
Advanced Rounding with the Decimal Module
For most cases, round() does everything you need for rounding numbers to a fixed number of decimal places. However, sometimes you may need more precise control over how rounding behaves, especially when dealing with money.
This is where Python‘s decimal module comes in handy. decimal allows you to set an exact precision level and rounding mode for your decimal operations.
Here‘s an example showing how the Decimal class can give more expected results than round() when dealing with numbers that end in 5:
>>> from decimal import Decimal
>>> Decimal("2.675").quantize(Decimal("0.01")) # round to nearest 0.01
Decimal(‘2.68‘)
>>> round(2.675, 2)
2.68
Here the quantize() method of the Decimal class lets you specify exactly how many decimal places you want and what value to round to (0.01 for 2 decimal places, 0.001 for 3, etc).
The decimal module also provides different rounding modes like ROUND_HALF_UP that always round numbers ending in 5 up instead of to the nearest even number:
>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.665").quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
Decimal(‘2.67‘)
>>> round(2.665, 2)
2.66
While overkill for simpler cases, decimal can be a powerful tool when you need absolute precision in your rounding and want full control over how numbers are rounded. Especially when money is involved, decimal can help you avoid subtle bugs caused by floating-point rounding errors.
Real-World Use Cases
Rounding to 2 decimal places is extremely common when dealing with currency amounts. Most financial systems use a 2 decimal place format to represent dollars and cents (or equivalent in other currencies).
For example, let‘s say you‘re writing code for an online store and need to calculate the total cost of a customer‘s order. You would want to round the result to 2 decimal places before displaying it to the user or charging their credit card:
def calculate_total(item_costs, tax_rate):
subtotal = sum(item_costs)
tax = subtotal * tax_rate
total = subtotal + tax
return round(total, 2) # round total to 2 decimal places
items = [4.99, 12.99, 27.5]
total_cost = calculate_total(items, 0.075)
print(f"Your total is: ${total_cost:.2f}")
Here we sum the item costs, calculate tax, add it to the subtotal, then round the final amount to 2 decimal places before returning. The f-string at the end formats the rounded total as a dollar amount string for display.
Rounding is also frequently used when working with scientific or engineering data to avoid false precision. Consider an application that tracks weather data:
def format_temperature(degrees_celsius):
fahrenheit = (degrees_celsius * 9/5) + 32
return f"{round(fahrenheit, 2)} °F"
today_temp = 28.87643 # degrees C
print(f"Today‘s temperature: {format_temperature(today_temp)}")
Even though our input temperature has 5 decimal places, that level of precision is meaningless in this context. The temperature sensor likely isn‘t nearly that accurate. So we round to 2 decimal places before formatting as a string to avoid implying false precision.
Floating-Point Limitations and Workarounds
One thing to keep in mind when rounding in Python (or any language) is that floating-point numbers like floats and doubles have inherent limitations in how precisely they can represent decimal fractions due to how they‘re encoded in binary.
In most cases this isn‘t an issue, but it can sometimes cause surprising results, like this:
>>> 1.1 + 2.2 3.3000000000000003
Wait, what? 1.1 + 2.2 isn‘t exactly 3.3?
Under the hood, 1.1 and 2.2 can‘t be represented exactly in binary, so they‘re each stored as the closest representable binary fraction. When added together, the tiny discrepancies add up to 3.3000000000000003 instead of 3.3.
In a money application, this kind of unexpected result could cause major issues. Imagine adding up a long column of transactions and having a fraction of a cent error at the end.
To avoid these floating-point precision errors, you have a few options:
-
Use round() to round your final result to an appropriate number of decimal places (like 2 for currency), which will hide small errors.
-
Use the Decimal class we discussed earlier for more precise math.
-
Work with integer numbers of cents instead of fractional dollar amounts (e.g. 550 cents instead of $5.50)
def calculate_total_cents(item_costs_cents, tax_rate):
subtotal_cents = sum(item_costs_cents)
tax_cents = round(subtotal_cents * tax_rate)
return subtotal_cents + tax_cents # total in cents
items_cents = [499, 1299, 2750]
total_cents = calculate_total_cents(items_cents, 0.075)
print(f"Your total is: ${total_cents/100:.2f}")
By working in whole cents and keeping track of the decimal point ourselves, we avoid floating-point errors. We still get the same $48.40 result in the end, but now it‘s reliably calculated.
Rounding Alternatives
Rounding to 2 decimal places is most commonly needed when working with currencies, but there are plenty of other situations where other types of rounding are useful.
Python‘s built-in round() function is really flexible. Without a second argument, it rounds a number to the nearest integer:
>>> round(2.4) 2 >>> round(3.8) 4
You can also pass negative numbers for the decimal places argument to round to the nearest 10, 100, 1000, etc:
>>> round(1234, -1) # round to nearest 10 1230 >>> round(5678, -2) # round to nearest 100 5700
Sometimes displaying a rounded number is good enough and you don‘t need to change the actual value. In those cases, you can use f-strings or Python‘s format() method to format a number as a string rounded to 2 (or any other number of) decimal places:
>>> f"{2.71828:.2f}"
‘2.72‘
>>> "{:.2f}".format(3.14159)
‘3.14‘
These string formatting approaches don‘t actually change the number though – they just affect how it looks when printed as a string. If you need the rounded value for further calculations, using round() is usually clearer and safer.
Conclusion
In this comprehensive guide, we‘ve covered everything you need to know about rounding to 2 decimal places (or any number of places) in Python.
We started with a review of what decimal places are and how rounding works in general. Then we looked at how to use Python‘s built-in round() function to round values to 2 decimal places in several realistic examples.
For more advanced use cases, we also explored the decimal module and saw how it can help you work around some of the limitations and surprises of floating-point math.
Finally, we walked through a few real-world scenarios where rounding to 2 decimal places is commonly needed for things like currency and scientific calculations. And we compared rounding to 2 decimal places with other related techniques like rounding to an integer or formatting a number as a string.
Armed with this in-depth knowledge, you‘re now prepared to precisely round numbers in any Python application. Whether you‘re summing currency amounts for an online store or presenting experimental results in a research paper, you can use the techniques from this guide to keep your decimal places in check.
As a next step, try applying what you‘ve learned to your own Python projects. Find places where you‘re currently displaying or calculating numbers and see if rounding them to 2 (or some other number of) decimal places improves readability or eliminates distracting and irrelevant digits.
With a solid grasp of number rounding, you‘ll be one step closer to cleaner, more professional, and more accurate Python code. Happy rounding!