Numbers are everywhere in programming, prices, measurements, scientific values, statistics, and financial calculations; all rely on accurate numeric representation. But computers store floating-point numbers with inherent imprecision, and real-world applications almost always need values expressed to a specific number of decimal places.<\/p>\n\n\n\n
Rounding is the answer. Whether you are displaying a price to two decimal places, computing an average to one decimal, binning sensor readings to the nearest integer, or ensuring consistent comparisons between floating-point values, Python provides a rich set of tools to handle every rounding scenario correctly.<\/p>\n\n\n\n
This complete guide covers everything you need to know about how to round off in Python: the built-in round() function and its banker’s rounding behaviour, the math module’s ceiling and floor functions, the decimal module for precision-critical applications, NumPy rounding for arrays, and the formatting functions that control how rounded numbers are displayed.<\/p>\n\n\n\n
\n Rounding off in Python is the process of adjusting a numeric value to a specified number of decimal places or significant digits, reducing precision in a controlled manner. Python provides several tools for this purpose, including the built-in Python’s built-in round() function is the most commonly used way to round off numbers in Python<\/a>. It requires no imports and works directly with integers, floats, and Decimal objects.<\/p>\n\n\n\n When ndigits is negative, round() rounds to the left of the decimal point tens, hundreds, thousands, and so on. This is useful for displaying approximate magnitudes or binning large numbers.<\/p>\n\n\n\n Python’s round() uses banker’s rounding, also called round half to even or IEEE 754 rounding. When a value is exactly halfway between two options (e.g., 0.5, 1.5, 2.5), it rounds to the nearest even number rather than always rounding up.<\/p>\n\n\n\n This behaviour often surprises developers expecting traditional half-up rounding. Banker’s rounding minimises cumulative bias when many values are rounded together important in financial and statistical calculations, where systematic rounding errors could compound over millions of operations.<\/p>\n\n\n\n Some decimal values cannot be represented exactly in binary floating-point. This can produce unexpected results with round():<\/p>\n\n\n\n For applications where exact decimal arithmetic is essential, such as financial software, billing systems, and tax calculations, use the decimal module instead of float arithmetic.<\/p>\n\n\n\n Python’s math module provides three directional rounding functions: floor, ceil, and trunc. Unlike round(), which rounds to the nearest value, these functions always round in a specific direction regardless of proximity.<\/p>\n\n\n\n math.floor(x) returns the largest integer less than or equal to x it always rounds toward negative infinity.<\/p>\n\n\n\n math.ceil(x) returns the smallest integer greater than or equal to x it always rounds toward positive infinity.<\/p>\n\n\n\n math.trunc(x) removes the fractional part without rounding it always rounds toward zero. For positive numbers, trunc behaves identically to floor. For negative numbers, trunc behaves identically to ceil.<\/p>\n\n\n\n The difference between these three functions is most visible with negative numbers:<\/p>\n\n\n\n Did You Know?<\/strong> For applications where floating-point imprecision is unacceptable financial calculations, billing systems, scientific measurements Python’s decimal module provides arbitrary-precision decimal arithmetic with full control over rounding behaviour.<\/p>\n\n\n\n The decimal module defines eight rounding modes, giving complete control over rounding behaviour:<\/p>\n\n\n\n When working with arrays of numbers, sensor readings, financial time series, and scientific measurements, applying Python’s round() in a loop is inefficient. NumPy provides vectorised rounding functions that operate on entire arrays in a single, highly optimised operation.<\/p>\n\n\n\n np.fix() is NumPy’s equivalent of math.trunc() it rounds each element toward zero, equivalent to floor for positives and ceil for negatives.<\/p>\n\n\n\n If your application requires traditional half-up rounding, where 0.5 always rounds up to 1, 1.5 rounds up to 2, and so on, Python offers several approaches.<\/p>\n\n\n\n The most reliable approach for precise half-up rounding is the decimal module:<\/p>\n\n\n\n For simple integer rounding without importing decimals, you can use the floor trick:<\/p>\n\n\n\n It is important to distinguish between rounding a number (changing its numeric value) and formatting a number for display (controlling how it looks as a string without altering its value).<\/p>\n\n\n\nround()<\/code> function, which uses banker’s rounding (round half to even), math.floor()<\/code> for rounding down, math.ceil()<\/code> for rounding up, and math.trunc()<\/code> for removing the decimal portion without rounding. For advanced precision and rounding control, Python also offers the decimal<\/code> module and NumPy’s array-based rounding functions.\n <\/p>\n\n <\/div>\n\n<\/div>\n\n\n\nThe Built-In round() Function in Python<\/strong><\/h2>\n\n\n\n
Syntax<\/strong><\/h3>\n\n\n\n
round(number, ndigits=None) # number \u2014 the value to round# ndigits \u2014 decimal places to round to (default: 0, returns int)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Basic Examples<\/strong><\/h3>\n\n\n\n
# Round to the nearest integerprint(round(3.7)) # 4print(round(3.2)) # 3print(round(-2.6)) # -3 # Round to specific decimal placesprint(round(3.14159, 2)) # 3.14print(round(3.14159, 4)) # 3.1416print(round(2.675, 2)) # 2.67 (floating-point quirk \u2014 see below) # Round to tens, hundreds (negative ndigits)print(round(1234, -2)) # 1200print(round(1567, -3)) # 2000<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Negative ndigits<\/strong><\/h3>\n\n\n\n
Banker’s Rounding: Round Half to Even<\/strong><\/h3>\n\n\n\n
# Banker’s rounding \u2014 rounds 0.5 to the nearest EVEN numberprint(round(0.5)) # 0 (rounds down \u2014 0 is even)print(round(1.5)) # 2 (rounds up \u2014 2 is even)print(round(2.5)) # 2 (rounds down \u2014 2 is even)print(round(3.5)) # 4 (rounds up \u2014 4 is even)print(round(4.5)) # 4 (rounds down \u2014 4 is even)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Floating-Point Representation Caveats<\/strong><\/h3>\n\n\n\n
print(round(2.675, 2)) # 2.67 instead of expected 2.68print(round(0.1 + 0.2, 1)) # 0.3 (works here due to rounding) # The cause: 2.675 in binary floating-point is slightly below 2.675import decimalprint(decimal.Decimal(2.675)) # 2.67499999999999982236431605997495353221893310546875<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Rounding with the Math Module<\/strong><\/h2>\n\n\n\n
math.floor() Always Round Down<\/strong><\/h3>\n\n\n\n
import math print(math.floor(3.9)) # 3print(math.floor(3.1)) # 3print(math.floor(3.0)) # 3print(math.floor(-3.1)) # -4 (rounds toward negative infinity)print(math.floor(-3.9)) # -4<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n math.ceil() Always Round Up<\/strong><\/h3>\n\n\n\n
import math print(math.ceil(3.1)) # 4print(math.ceil(3.9)) # 4print(math.ceil(3.0)) # 3print(math.ceil(-3.9)) # -3 (rounds toward positive infinity)print(math.ceil(-3.1)) # -3<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n math.trunc() Remove the Decimal Part<\/strong><\/h3>\n\n\n\n
import math print(math.trunc(3.9)) # 3 (same as floor for positives)print(math.trunc(-3.9)) # -3 (rounds toward zero, not -4)print(math.trunc(3.0)) # 3 # Equivalent with int() for simple truncationprint(int(3.9)) # 3print(int(-3.9)) # -3<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Comparing floor, ceil, and trunc for Negative Values<\/strong><\/h3>\n\n\n\n
import mathx = -2.7 print(math.floor(x)) # -3 (toward negative infinity)print(math.ceil(x)) # -2 (toward positive infinity)print(math.trunc(x)) # -2 (toward zero)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Python’s built-in round() function changed its rounding behaviour between Python 2 and Python 3, a breaking change that surprised many developers upgrading their codebases. In Python 2, round() used traditional half-up rounding (round(0.5) returned 1.0, round(1.5) returned 2.0). In Python 3, round() was changed to use banker’s rounding, rounding half to even, to comply with the IEEE 754 floating-point standard and to reduce systematic cumulative rounding bias. <\/p>\n\n\n\nPrecise Rounding with the Decimal Module<\/strong><\/h2>\n\n\n\n
Basic Usage<\/strong><\/h3>\n\n\n\n
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN # Always use strings to initialise Decimal \u2014 avoids float imprecisionx = Decimal(‘2.675’)print(x.quantize(Decimal(‘0.01’), rounding=ROUND_HALF_UP)) # 2.68print(x.quantize(Decimal(‘0.01’), rounding=ROUND_HALF_EVEN)) # 2.68 # Float initialisation captures the imprecision \u2014 avoid thisy = Decimal(2.675) # Decimal(‘2.67499999999999982236…’)print(y.quantize(Decimal(‘0.01’), rounding=ROUND_HALF_UP)) # 2.67 (wrong!)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Rounding Modes in the Decimal Module<\/strong><\/h3>\n\n\n\n
\n
Setting a Global Decimal Context<\/strong><\/h3>\n\n\n\n
from decimal import Decimal, getcontext, ROUND_HALF_UP # Set global precision and rounding modegetcontext().prec = 10getcontext().rounding = ROUND_HALF_UP a = Decimal(‘1.005’)print(round(a, 2)) # 1.01 (correct with ROUND_HALF_UP context)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Rounding Arrays with NumPy<\/strong><\/h2>\n\n\n\n
np.round() Round Array Elements<\/strong><\/h3>\n\n\n\n
import numpy as np arr = np.array([1.234, 2.567, 3.891, 4.125, -1.678]) print(np.round(arr, 2)) # [1.23 2.57 3.89 4.12 -1.68]print(np.round(arr, 1)) # [1.2 2.6 3.9 4.1 -1.7]print(np.round(arr, 0)) # [1. 3. 4. 4. -2.] # np.round_ and ndarray.round() are equivalentprint(arr.round(2)) # [1.23 2.57 3.89 4.12 -1.68]<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n np.floor(), np.ceil(), np.trunc()<\/strong><\/h3>\n\n\n\n
import numpy as np arr = np.array([1.7, 2.3, -1.7, -2.3]) print(np.floor(arr)) # [ 1. 2. -2. -3.]print(np.ceil(arr)) # [ 2. 3. -1. -2.]print(np.trunc(arr)) # [ 1. 2. -1. -2.]<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n np.fix() Truncate Toward Zero<\/strong><\/h3>\n\n\n\n
import numpy as np arr = np.array([2.9, -2.9, 3.1, -3.1])print(np.fix(arr)) # [ 2. -2. 3. -3.]<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n How to Get Traditional Half-Up Rounding<\/strong><\/h2>\n\n\n\n
Using the decimal Module with ROUND_HALF_UP<\/strong><\/h3>\n\n\n\n
from decimal import Decimal, ROUND_HALF_UP def round_half_up(value, decimals=0): factor = Decimal(‘1.’ + ‘0’ * decimals) if decimals > 0 else Decimal(‘1’) return float(Decimal(str(value)).quantize(factor, rounding=ROUND_HALF_UP)) print(round_half_up(0.5)) # 1.0print(round_half_up(1.5)) # 2.0print(round_half_up(2.5)) # 3.0print(round_half_up(2.675, 2)) # 2.68<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Using the Math Module Approach<\/strong><\/h3>\n\n\n\n
import math def round_half_up_int(x): return math.floor(x + 0.5) print(round_half_up_int(0.5)) # 1print(round_half_up_int(1.5)) # 2print(round_half_up_int(2.5)) # 3print(round_half_up_int(-0.5)) # 0 (note: -0.5 + 0.5 = 0.0)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Rounding vs. Formatting: Displaying Rounded Numbers<\/strong><\/h2>\n\n\n\n
Formatting with f-strings<\/strong><\/h3>\n\n\n\n