Entendendo Números em Python

Python possui três tipos numéricos embutidos: inteiros (int), números de ponto flutuante (float) e números complexos (complex). Esta página cobre como cada tipo funciona, como realizar operações aritméticas com eles, armadilhas comuns, conversão de tipos e quais funções matemáticas a biblioteca padrão oferece.

Números Inteiros

Um inteiro é um número inteiro — positivo, negativo ou zero — sem ponto decimal. Em Python, os inteiros têm precisão ilimitada: não há um tamanho máximo fixo como existe em C ou Java. Python trabalha facilmente com números que têm centenas de dígitos.

x = 10
y = -5
z = 0

# Python integers have no fixed size limit
big = 2 ** 100
print(big)  # 1267650600228229401496703205376

Aritmética com Inteiros

Note que / sempre retorna um float, mesmo quando o resultado é um número inteiro (6 / 2 resulta em 3.0). Use // quando precisar de um resultado inteiro.

Literais Inteiros: Binário, Octal e Hexadecimal

Python aceita literais inteiros em quatro bases. Todos os quatro criam o mesmo objeto int — o prefixo apenas indica ao Python como interpretar os dígitos.

decimal     = 255        # base 10 — no prefix
binary      = 0b11111111 # base 2  — prefix 0b
octal       = 0o377      # base 8  — prefix 0o
hexadecimal = 0xFF       # base 16 — prefix 0x

print(decimal, binary, octal, hexadecimal)
# 255 255 255 255

# Convert an int back to a string in a given base
print(hex(255))   # '0xff'
print(bin(255))   # '0b11111111'
print(oct(255))   # '0o377'

Verificando o Tipo

Use type() para confirmar o tipo de um valor, ou isinstance() para verificar a pertença:

print(type(42))            # <class 'int'>
print(isinstance(42, int)) # True

Números de Ponto Flutuante

Um float é um número com ponto decimal (ou expoente). Os floats de Python são valores de dupla precisão IEEE 754 de 64 bits, o que fornece aproximadamente 15–17 dígitos decimais significativos de precisão.

x = 10.5
y = -5.2
z = 0.0
e = 1.5e3   # scientific notation — same as 1500.0

Aritmética com Floats

Precisão de Ponto Flutuante

Como os floats são armazenados em binário, algumas frações decimais não podem ser representadas exatamente. Esta é uma propriedade da aritmética IEEE 754, não um bug do Python:

print(0.1 + 0.2)          # 0.30000000000000004
print(0.1 + 0.2 == 0.3)   # False

Quando a aritmética decimal exata é importante (por exemplo, em cálculos financeiros), use o módulo decimal da biblioteca padrão em vez de float.

Arredondamento e Operações Úteis com Floats

import math

print(round(3.14159, 2))  # 3.14  — round to 2 decimal places
print(math.floor(3.7))    # 3     — largest integer <= value
print(math.ceil(3.2))     # 4     — smallest integer >= value
print(math.sqrt(16))      # 4.0   — square root
print(abs(-7.5))          # 7.5   — absolute value

Números Complexos

Um número complexo tem uma parte real e uma parte imaginária. Em Python (seguindo a convenção de engenharia), a unidade imaginária é escrita como j ou J, não i.

x = 10 + 5j
y = -5 + 3j
z = 0 + 0j        # equivalent to complex(0, 0)
w = complex(2, -3) # constructor: real=2, imag=-3

Acessando as Partes Real e Imaginária

z = 3 + 4j
print(z.real)   # 3.0
print(z.imag)   # 4.0
print(abs(z))   # 5.0  — magnitude: sqrt(3^2 + 4^2)

Aritmética com Números Complexos

Números complexos não podem ser comparados com < ou > porque não há ordenação natural no plano complexo. Apenas == e != são suportados.

Conversão de Tipos

Python não promove tipos silenciosamente em atribuições, mas a aritmética entre diferentes tipos numéricos segue regras bem definidas:

Você pode converter entre tipos explicitamente com os construtores embutidos:

# int → float
print(float(42))       # 42.0

# float → int (truncates toward zero, no rounding)
print(int(3.9))        # 3
print(int(-3.9))       # -3

# str → int or float
print(int("100"))      # 100
print(float("3.14"))   # 3.14

# int → complex
print(complex(5))      # (5+0j)

Note que converter um float para int trunca — não arredonda. Use round() primeiro se precisar de arredondamento.

O Módulo math

O módulo math fornece funções matemáticas adicionais para números reais.

import math

print(math.pi)          # 3.141592653589793
print(math.e)           # 2.718281828459045

print(math.log(math.e)) # 1.0   — natural log
print(math.log10(1000)) # 3.0
print(math.pow(2, 10))  # 1024.0 — float result (use ** for int result)
print(math.factorial(5)) # 120
print(math.gcd(12, 8))  # 4

Para operações com números complexos, use cmath em vez de math:

import cmath

z = 1 + 1j
print(cmath.phase(z))   # 0.7853981633974483  — angle in radians (π/4)
print(cmath.polar(z))   # (1.4142135623730951, 0.7853981633974483) — (r, θ)

Quando Usar Cada Tipo

Para tópicos relacionados, consulte o capítulo Python Variables para saber como os números são armazenados em variáveis, o capítulo Python Operators para o conjunto completo de operadores numéricos, e Python Casting para detalhes sobre conversão de tipos.

Prática