Números, Booleanos e Aritmética

Python fornece inteiros de tamanho ilimitado, floats binários e tipos numéricos exatos para domínios que não podem tolerar erros de arredondamento. Booleanos participam da aritmética porque são subclasses de int.

Receita

from decimal import Decimal
 
price = Decimal("19.99")
tax = Decimal("0.0825")
total = price * (1 + tax)
 
a, b = 7, 3
print(a / b, a // b, a % b, divmod(a, b))

Quando usar isso:

• Cálculos financeiros que exigem semântica decimal exata
• Computação científica com floats e tolerâncias
• Flags bitwise e protocolos de inteiros
• Testes de verdade em condições if e while

Exemplo de Trabalho

from decimal import Decimal, ROUND_HALF_UP
from fractions import Fraction
 
def invoice_line(unit_price: str, qty: int, tax_rate: str) -> Decimal:
    price = Decimal(unit_price)
    tax = Decimal(tax_rate)
    subtotal = price * qty
    tax_amount = (subtotal * tax).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
    return subtotal + tax_amount
 
def float_trap() -> None:
    print(0.1 + 0.2)  # 0.30000000000000004
    print(Fraction(1, 10) + Fraction(2, 10))  # 3/10 exato
 
def truthiness() -> None:
    for value in [0, 1, "", "x", [], [0], None]:
        print(repr(value), "->", bool(value))
 
if __name__ == "__main__":
    print(invoice_line("19.99", 3, "0.0825"))
    float_trap()
    truthiness()

O que isso demonstra:

• Decimal construído a partir de strings evita artefatos binários de float
• quantize controla o arredondamento para exibição de moeda
• Fraction mantém números racionais exatos
• Truthiness segue regras padrão: zero, vazio e None são falsy

Mergulho Profundo

Como Funciona

• int - Precisão arbitrária; limitado apenas pela memória.
• float - IEEE 754 duplo; rápido, mas inexato para muitos decimais.
• Decimal - Ponto flutuante base-10 com precisão configurável e modos de arredondamento.
• bool - Subclasse de int; True == 1, False == 0.
• Precedência de operadores - PEMDAS padrão; use parênteses para clareza.

Operadores em Resumo

Notas Python

import math
math.isclose(0.1 + 0.2, 0.3)  # prefira sobre == para floats
int("ff", 16)                  # conversão de base
float("nan") != float("nan")   # NaN não é igual a si mesmo

Armadilhas

• Igualdade de float - 0.1 + 0.2 == 0.3 é False. Correção: math.isclose ou Decimal.
• Divisão inteira em negativos - -7 // 3 é -3, não -2. Correção: Lembre-se de arredondar para -inf.
• Decimal a partir de float - Decimal(0.1) herda a imprecisão do float. Correção: Decimal("0.1").
• bool é int - True + True é igual a 2. Correção: Não use booleanos em somas, a menos que intencional.
• Int grande para float - Converter inteiros enormes para float perde precisão. Correção: Permaneça em int ou use Decimal.

Alternativas

FAQs

from decimal import Decimal, ROUND_HALF_UP
Decimal("2.675").quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)

Relacionado

• Variáveis, Tipos e Tipagem Dinâmica - tipos de objeto e identidade
• Fluxo de Controle - truthiness em condicionais
• Strings e f-strings - formatando números na saída
• Noções Básicas de Dicas de Tipo - anotando tipos numéricos

Versões do Stack: Esta página foi escrita para Python 3.14.0 (estável 3.14, manutenção 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+ e uv 0.6+.