Números e booleanos em Python: int, float, bool e aritmética

Dois tipos de números, um tipo de verdade

Os tipos numéricos que você vai usar no dia a dia são int e float, mais bool para valores verdadeiro/falso. Eles dão conta de quase toda a aritmética e lógica que um programa Python normal precisa.

count = 42
ratio = 0.25
is_ready = True

print(type(count), type(ratio), type(is_ready))

O Python às vezes chama booleanos de subtipo de inteiros — True é literalmente 1 e False é literalmente 0 — o que abre alguns truques úteis mais à frente.

Aritmética com inteiros

Inteiros em Python nunca estouram. Parece pouco importante até você escrever sua primeira função fatorial e perceber que a maioria das outras linguagens já teria virado silenciosamente para um número negativo.

print(2 ** 100)
print(1000 * 1000 * 1000 * 1000)

Os dois produzem respostas exatas, não importa quão grandes. A memória é o único teto.

Os operadores aritméticos são os que você esperaria, mais alguns:

print(10 + 3)   # 13   addition
print(10 - 3)   # 7    subtraction
print(10 * 3)   # 30   multiplication
print(10 / 3)   # 3.3333... true division (returns a float)
print(10 // 3)  # 3    floor division (drops the remainder)
print(10 % 3)   # 1    modulo (the remainder)
print(10 ** 3)  # 1000 exponent

Três coisas dessa lista que vale guardar:

• / sempre retorna um float no Python 3, mesmo quando os dois lados são inteiros. 10 / 2 te dá 5.0, não 5. Se quer um inteiro, use //.
• // arredonda na direção do infinito negativo, então -7 // 2 é -4, não -3. Incomum, mas consistente.
• % dá o resto, e é útil para "este número é par?" (n % 2 == 0) e para dar a volta num intervalo fixo.

Floats e sua armadilha famosa

Floats são imperfeitos por design. São guardados em binário, que não consegue representar a maioria das frações decimais exatamente. O exemplo clássico:

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

A primeira linha imprime 0.30000000000000004. A segunda imprime False. Toda linguagem que segue o padrão IEEE 754 — Python, JavaScript, Java, C — tem esse comportamento. Não é bug do Python.

Na prática, isso significa duas coisas:

1. Não compare floats com ==. Se você precisa de "perto o suficiente", use math.isclose(a, b) ou cheque se abs(a - b) < alguma_tolerancia.
2. Para dinheiro, use decimal.Decimal. O módulo decimal da biblioteca padrão dá aritmética decimal exata — sem surpresas tipo 0.1 + 0.2. É mais lento que float, e é por isso que não é o padrão, mas é a escolha certa para valores monetários.

from decimal import Decimal

total = Decimal("0.1") + Decimal("0.2")
print(total)

Convertendo entre tipos numéricos

O Python não converte silenciosamente um inteiro em string nem uma string em número. Você pede explicitamente:

age_text = "30"
age = int(age_text)
print(age + 5)

price = float("19.99")
print(price)

count = 7
label = "Count: " + str(count)
print(label)

Conversões inválidas geram ValueError:

>>> int("hello")
ValueError: invalid literal for int() with base 10: 'hello'

A mensagem de erro é direta e fácil de agir em cima. Limpe a entrada ou capture a exceção.

Booleanos, com um pouco mais de profundidade

True e False são os dois valores booleanos — escritos exatamente assim, com letra maiúscula. A maioria das comparações produz um deles:

print(5 > 3)
print("abc" == "abc")
print([1] != [1])

Os operadores booleanos são and, or e not, escritos como palavras em inglês em vez de símbolos:

can_drive = True
has_car = False

print(can_drive and has_car)   # False — needs both
print(can_drive or has_car)    # True — needs one
print(not can_drive)           # False

Uma sutileza que vale saber: and e or não necessariamente retornam True ou False — retornam o valor que decidiu a expressão. 0 or "fallback" retorna "fallback"; 5 and 10 retorna 10. Isso permite escrever defaults curtos como name = user_input or "anonymous", mas também vale entender se uma checagem booleana um dia te der um tipo inesperado.

Truthy e falsy

O Python trata muitos valores como "mais ou menos verdadeiros" ou "mais ou menos falsos" quando você usa num contexto booleano como if ou while. Os valores falsy são:

• False
• 0, 0.0
• None
• Containers vazios: "", [], {}, set(), ()

Todo o resto é truthy. Isso permite escrever checagens mais naturais:

name = ""

if name:
    print(f"Hello, {name}")
else:
    print("No name provided")

Leia if name: como "se name tem algo dentro". Muito mais limpo do que if name != "":. Só cuidado com números — if count: vai tratar 0 como "pule", o que geralmente mas nem sempre é o que você quer. Se zero for um valor legítimo, use if count is not None:.

Aritmética com booleanos

Como booleanos são inteiros, você pode fazer aritmética com eles:

checks = [True, False, True, True, False]
print(sum(checks))   # 3 — counts how many are True

Esse truque aparece com frequência suficiente para guardar. Se você quer contar quantos itens numa lista passam em algum teste, some um gerador que retorna booleanos:

scores = [52, 78, 91, 45, 88, 63]
above_60 = sum(score >= 60 for score in scores)
print(above_60)

As lições práticas

• Inteiros nunca estouram. Use livremente.
• / retorna float; use // quando quer divisão inteira.
• Não compare floats com ==; compare com uma tolerância, ou use Decimal para dinheiro.
• Truthiness deixa condições mais legíveis — desde que você lembre que 0 e string vazia são falsy.

Na sequência: input e print, as duas ferramentas que transformam seus scripts de programas silenciosos em conversas.