Nesta aula, vamos explorar os tipos numéricos fundamentais em Python: int, float e complex. Entender como esses tipos funcionam é essencial para realizar cálculos, controlar a precisão e evitar erros comuns em programas numéricos. Além disso, veremos as operações disponíveis, incluindo a diferença entre divisão real (/) e divisão inteira (//), e como lidar com arredondamentos.

Python oferece suporte nativo a números de ponto flutuante de precisão dupla (conforme IEEE 754) e números complexos, o que facilita a implementação de algoritmos matemáticos e científicos. Ao final, você será capaz de manipular números de forma eficiente e consciente das limitações de precisão.

int, float, complex

O tipo int representa números inteiros, sem limite de tamanho (depende apenas da memória disponível). Exemplos: 42, -7, 0. Já o tipo float representa números de ponto flutuante (decimais), como 3.14, -0.001, 1.5e10. O tipo complex representa números complexos na forma a + bj, onde a e b são números reais e j é a unidade imaginária. Exemplo: 3+4j.

Em Python, você pode verificar o tipo de um valor usando a função type(). Além disso, é possível converter entre tipos usando funções como int(), float() e complex(). Cuidado: converter um float para int trunca a parte decimal (descarta a parte fracionária).

print(type(42))         # <class 'int'>
print(type(3.14))       # <class 'float'>
print(type(3+4j))       # <class 'complex'>

# Conversões
print(int(3.9))         # 3 (trunca)
print(float(5))         # 5.0
print(complex(2,3))     # (2+3j)

Operações

Python suporta as operações aritméticas básicas: adição (+), subtração (-), multiplicação (*), divisão (/), exponenciação (**), entre outras. As operações seguem as regras de precedência matemática (PEMDAS). Quando operandos são de tipos diferentes, Python promove o tipo mais abrangente (int para float, float para complex).

Além disso, existem operadores especiais: // para divisão inteira, % para resto de divisão (módulo), e ** para potência. Também é possível usar funções matemáticas do módulo math para operações mais avançadas.

# Operações básicas
print(10 + 3)    # 13
print(10 - 3)    # 7
print(10 * 3)    # 30
print(10 / 3)    # 3.3333333333333335 (float)
print(10 ** 3)   # 1000

# Resto e divisão inteira
print(10 % 3)    # 1
print(10 // 3)   # 3

# Mistura de tipos
print(10 + 3.0)  # 13.0 (float)
print(10 + 3j)   # (10+3j) (complex)

Divisão (/ vs //)

A divisão real (/) sempre retorna um valor float, mesmo que o resultado seja exato (por exemplo, 6/3 retorna 2.0). Já a divisão inteira (//) retorna o quociente inteiro (truncado em direção ao infinito negativo para números negativos).

Para números positivos, // simplesmente descarta a parte decimal. Para números negativos, o resultado é o menor inteiro (mais negativo) que é menor ou igual ao quociente real. Exemplo: -7 // 3 retorna -3 porque -7/3 ≈ -2.333, e o menor inteiro é -3.

# Divisão real
print(10 / 3)    # 3.3333333333333335
print(10 / 2)    # 5.0

# Divisão inteira
print(10 // 3)   # 3
print(10 // 2)   # 5
print(-7 // 3)   # -3 (trunca para baixo)
print(7 // -3)   # -3 (trunca para baixo)

Precisão e arredondamento

Números de ponto flutuante em Python são representados em binário (base 2), o que pode causar erros de arredondamento em operações que seriam exatas em base 10. Por exemplo, 0.1 + 0.2 não é exatamente 0.3 devido a essas limitações. Isso é importante em cálculos financeiros ou científicos.

Para arredondar números, Python oferece a função round(), que arredonda para o número par mais próximo (banker's rounding) quando o valor está exatamente no meio. Também é possível usar o módulo decimal para precisão decimal arbitrária, ou o módulo fractions para frações exatas.

# Erro de precisão
print(0.1 + 0.2)  # 0.30000000000000004

# round()
print(round(2.5))   # 2 (arredonda para o par mais próximo)
print(round(3.5))   # 4
print(round(2.675, 2))  # 2.67 (cuidado: devido a precisão)

# Usando decimal
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2'))  # 0.3 exato

Boas práticas

Ao trabalhar com números, prefira usar Decimal para cálculos financeiros, evite comparar floats com igualdade exata (use uma tolerância), e lembre-se de que a divisão inteira com números negativos pode surpreender. Sempre documente suposições sobre precisão.

Referências

Exercícios

  1. Qual é o resultado de type(10) e type(10.0)?

    ✓ Resposta: type(10) retorna <class 'int'> e type(10.0) retorna <class 'float'>.

  2. Calcule o valor de 17 // 5 e 17 % 5.

    ✓ Resposta: 17 // 5 é 3 e 17 % 5 é 2.

  3. Explique por que 0.1 + 0.2 == 0.3 retorna False em Python.

    ✓ Resposta: Devido à representação binária de ponto flutuante, 0.1 e 0.2 não são exatos, resultando em uma soma ligeiramente diferente de 0.3.

  4. Qual é o resultado de round(2.5) e round(3.5)? Por que são diferentes?

    ✓ Resposta: round(2.5) retorna 2 e round(3.5) retorna 4. Python usa "banker's rounding" (arredondamento para o par mais próximo).

  5. Escreva uma expressão usando o módulo decimal para obter o valor exato de 0.1 + 0.2.

    ✓ Resposta: 
    from decimal import Decimal
resultado = Decimal('0.1') + Decimal('0.2')  # Decimal('0.3')