Arredondar para 2 casas decimais em Python: 7 métodos explicados

Entendendo arredondamento e casas decimais

Casas decimais são os números que aparecem logo após o ponto decimal em um número. Elas determinam a precisão do valor: quanto mais casas, maior a precisão, e vice-versa.

Arredondar números significa ajustar um valor reduzindo a quantidade de casas decimais. Essa técnica é usada para simplificar números e manter consistência entre cálculos. Ainda assim, arredondar para um número específico de casas pode afetar a exatidão dos resultados por introduzir pequenos erros no processo.

Python oferece diferentes métodos para arredondar números para duas casas decimais. Os exemplos a seguir explicam cada técnica em detalhes.

Usando round() para arredondar um número em Python

A função round() é a nativa do Python para arredondar números de ponto flutuante para a quantidade de casas decimais especificada. Você define o número de casas passando um valor como segundo argumento. O exemplo abaixo imprime 34,15.

# Example number to be rounded
number = 34.14559

# Rounding the number to 2 decimal places
rounded_number = round(number, 2)

print(rounded_number)

# 34.15

A função round() do Python usa "round half to even" como modo padrão quando você omite o segundo argumento. No arredondamento para o par (bankers’ rounding), quando um número está exatamente no meio entre dois inteiros, ele é arredondado para o inteiro par mais próximo. Essa técnica ajuda a minimizar erros cumulativos de arredondamento.

Pegadinha de precisão de float com round()

Há um detalhe importante antes de confiar em round() em código financeiro. Experimente:

print(round(2.675, 2))  # You might expect 2.68
# Output: 2.67

O resultado é 2.67, não 2.68. O valor 2.675 não pode ser representado exatamente em ponto flutuante binário (IEEE 754); o valor armazenado é ligeiramente menor que 2.675, então o Python arredonda para baixo.

Se você precisa de arredondamento exato para cálculos financeiros, use o módulo decimal com um modo de arredondamento explícito:

from decimal import Decimal, ROUND_HALF_UP

result = Decimal("2.675").quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
print(result)  # 2.68

Usando formatação de strings para arredondar um número em Python

Técnicas de formatação de string são úteis para arredondar números para duas casas decimais, especialmente quando a intenção é exibir o número na saída.

Lembre que, ao usar formatação de string em Python para arredondar, a saída arredondada é uma string, mas o número original permanece inalterado. Se você fizer contas com o número original, os cálculos usam o valor não arredondado — o que pode gerar resultados inesperados.

Arredondando com o operador %

O operador % oferece um método tradicional para formatar números com duas casas decimais. Ele permite criar strings formatadas inserindo valores em placeholders.

No exemplo abaixo, f indica um número de ponto flutuante, enquanto .2 define que o arredondamento terá duas casas decimais.

# Example number to be rounded
number = 3.14159

# Using the % operator to round to 2 decimal places
formatted_number = "%.2f" % number

print(formatted_number)

# 3.14

Arredondando com str.format()

O método str.format() oferece uma forma mais flexível de lidar com formatações e arredondamentos mais complexos. Por usar placeholders nomeados, muitos desenvolvedores preferem esse método ao operador %. No exemplo abaixo, :.2f é usado dentro das chaves para indicar que o número deve ser exibido com duas casas decimais. O código imprime 3.14.

# Example number to be rounded
number = 3.14159

# Using str.format() to round to 2 decimal places
formatted_number = "{:.2f}".format(number)

print(formatted_number)

# 3.14

Arredondando com f-strings (Python 3.6+)

As f-strings chegaram no Python 3.6 e hoje são a forma preferida de embutir valores em strings. A sintaxe de f-string é especialmente limpa para arredondar: você faz a formatação de exibição em uma linha, sem chamada separada. O código abaixo imprime 14.68.

# Example number to be rounded
number = 14.67856

# Using f-strings to round to 2 decimal places
formatted_number = f"{number:.2f}"

print(formatted_number)

# 14.68

Usando format() para arredondar um número em Python

A função nativa format() recebe um valor e uma especificação de formato e retorna uma string formatada. Diferente de str.format(), você passa o número diretamente, em vez de embuti-lo em um template. O código abaixo imprime 345.69.

# Example number to be rounded
number = 345.68776

# Using the built-in format() to round to 2 decimal places
formatted_number = format(number, ".2f")

print(formatted_number)

# 345.69

Usando outros módulos para arredondar um número em Python

Além do Python básico, há outros módulos que você pode usar para arredondar números. Vou mostrar três exemplos mais comuns: math, decimal e NumPy.

Arredondando com o módulo math

O módulo math não fornece funções que arredondam diretamente para casas decimais específicas. Porém, você pode combiná-lo com operações aritméticas para arredondar um número para duas casas decimais.

A função math.floor() arredonda um número para baixo até o inteiro mais próximo. Para arredondar para baixo com duas casas, multiplique por 100, aplique math.floor() e depois divida por 100. O código abaixo imprime 3.14.

# Import math module
import math

# Example number to be rounded
number = 3.14159

# Using math.floor() to round down to 2 decimal places
rounded_down = math.floor(number * 100) / 100

print(rounded_down)

# 3.14

Da mesma forma, a função math.ceil() arredonda para cima até o inteiro mais próximo. Para arredondar para cima com duas casas, multiplique por 100, aplique math.ceil() e depois divida por 100. O código abaixo imprime 3.15.

# Import the math module
import math

# Example number to be rounded
number = 3.14159

# Using math.ceil() to round up to 2 decimal places
rounded_up = math.ceil(number * 100) / 100

print(rounded_up)

# 3.15

Arredondando com o módulo decimal

O módulo decimal em Python é útil para arredondar números com precisão de casas decimais usando o método .quantize(). No exemplo abaixo, definimos a precisão como 0.01 para indicar que queremos duas casas decimais.

# Import the decimal module
from decimal import Decimal

# Example number to be rounded
number = Decimal("18.73869")

# Define the rounding precision to 2 decimal places
precision = Decimal('0.01')

# Using the quantize method with ROUND_UP 
# to round the number up to 2 decimal places
rounded_number = number.quantize(precision)

print(rounded_number)

# 18.74

Se você busca um comportamento específico de arredondar sempre para cima, confira nosso tutorial mais recente How to Round Up a Number in Python para aprender mais sobre o uso dos módulos math e decimal e outras técnicas para garantir que o número sempre arredonde para cima, e não para baixo. Para entender melhor transformações de dados em geral, explore nossa trilha de carreira Data Analyst with Python para desenvolver suas habilidades analíticas.

Arredondando com NumPy

Ao trabalhar com arrays no NumPy, use np.round() para arredondar todos os elementos de uma vez. Isso é mais rápido e legível do que iterar manualmente.

import numpy as np

prices = np.array([1.2345, 9.8765, 3.14159])
rounded_prices = np.round(prices, 2)

print(rounded_prices)
# [1.23 9.88 3.14]

np.round() aplica a mesma regra de banker's rounding da função nativa round() do Python. O método .round() funciona do mesmo jeito em DataFrames e Series do pandas:

import pandas as pd

df = pd.DataFrame({"price": [1.2345, 9.8765, 3.14159]})
df["price_rounded"] = df["price"].round(2)

print(df)
#      price  price_rounded
# 0   1.2345           1.23
# 1   9.8765           9.88
# 2  3.14159           3.14

Para uma visão mais ampla de transformação de dados com pandas, veja nosso tutorial de pandas.

Quando usar cada método de arredondamento em Python

Aqui vai um guia rápido para escolher a abordagem certa:

Algumas regras práticas para orientar a escolha:

• Só vai exibir o número? Use uma f-string (f"{x:.2f}"). Uma linha, sem imports e sem alterar o valor original.

• Vai fazer contas com o resultado? Use round(x, 2). Ele retorna um float que você pode continuar usando nos cálculos.

• Código financeiro ou contábil? Use Decimal.quantize(). Surpresas de precisão com float (round(2.675, 2) == 2.67) não acontecem com o módulo decimal.

• Precisa sempre subir ou sempre descer? Use math.ceil() ou math.floor(). Elas ignoram completamente as regras de arredondamento convencional.

• Trabalhando com um array NumPy ou coluna do pandas? Use np.round(arr, 2) ou series.round(2). Ambos tratam a coleção inteira de uma vez.

• Mantendo código legado? O operador % ainda funciona, mas as f-strings o substituíram no Python 3.6 — prefira f-strings em código novo.

Considerações finais

Arredondar números para duas casas decimais é essencial para melhorar a precisão em cálculos financeiros e científicos. Neste artigo, vimos diferentes métodos para arredondar para duas casas, incluindo funções nativas, formatação de strings e o módulo math. É importante entender e escolher o método adequado conforme a necessidade — seja precisão, seja estilo de formatação. Recomendo praticar os diferentes métodos com exemplos variados para descobrir o que melhor se adapta ao seu caso.

Se você quer avançar em Python, confira nossa trilha de habilidades Python Programming, que cobre funções, decoradores e padrões avançados em Python. Nossa trilha de carreira Python Developer também foi pensada para ajudar você a se capacitar como desenvolvedor enquanto aprende estruturas de dados e algoritmos mais avançados.