Tipos primitivos: int, float, str e bool

1. Introdução aos tipos primitivos no Python

Tipos primitivos são os blocos fundamentais de construção de qualquer programa em Python. Eles representam dados simples e indivisíveis — um número, um caractere ou um valor lógico — e são a base sobre a qual todos os tipos compostos (listas, dicionários, tuplas) são construídos.

Python adota tipagem dinâmica forte: o interpretador infere automaticamente o tipo de uma variável no momento da atribuição, mas não realiza conversões implícitas entre tipos incompatíveis. Por exemplo, "10" + 5 levanta um TypeError, enquanto em linguagens de tipagem fraca como JavaScript isso resultaria em "105". Essa característica torna o código mais previsível e seguro.

2. int – Números inteiros

Inteiros em Python são objetos imutáveis que representam números sem parte fracionária. Diferentemente de linguagens como C ou Java, Python oferece precisão arbitrária: um inteiro pode crescer até o limite da memória disponível, sem risco de overflow.

# Criação básica
a = 42
b = -7
c = 0

# Inteiros grandes (sem overflow)
gigante = 10**100
print(gigante)  # 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

# Conversão explícita
print(int(3.9))      # 3 (trunca a parte decimal)
print(int("101", 2)) # 5 (binário para decimal)
print(int("FF", 16)) # 255 (hexadecimal para decimal)

# Funções úteis
print(bin(42))  # '0b101010'
print(hex(42))  # '0x2a'
print(abs(-10)) # 10

Inteiros suportam todas as operações aritméticas básicas (+, -, *, //, %, **) e operadores bit a bit (&, |, ^, <<, >>).

3. float – Números de ponto flutuante

Floats representam números reais com precisão limitada (geralmente 64 bits, seguindo o padrão IEEE 754). Você pode criá-los diretamente com ponto decimal ou notação científica.

# Criação
pi = 3.14159
notacao = 1e-5       # 0.00001
infinito = float('inf')
nao_numero = float('nan')

# Armadilha clássica: precisão finita
print(0.1 + 0.2)           # 0.30000000000000004
print(0.1 + 0.2 == 0.3)    # False!

# Solução: usar math.isclose()
import math
print(math.isclose(0.1 + 0.2, 0.3))  # True

# Conversão e arredondamento
print(float("3.14"))       # 3.14
print(round(3.14159, 2))   # 3.14
print(round(2.5))          # 2 (arredondamento bancário, para o par mais próximo)

Cuidado com comparações diretas entre floats. Sempre use math.isclose() ou converta para Decimal quando precisão absoluta for necessária (ex.: cálculos financeiros).

4. str – Strings

Strings são sequências imutáveis de caracteres Unicode. Podem ser criadas com aspas simples, duplas ou triplas (para strings multilinha).

# Criação
simples = 'Olá'
duplas = "Mundo"
multilinha = """Linha 1
Linha 2"""

# Imutabilidade: a string original nunca é alterada
nome = "Python"
# nome[0] = "J"  # TypeError: 'str' object does not support item assignment
novo_nome = "J" + nome[1:]  # "Jython" — cria nova string

# Operações essenciais
print("Hello" + " " + "World")   # Concatenação
print("Ha" * 3)                   # Repetição: "HaHaHa"
print("Python"[0:3])              # Fatiamento: "Pyt"
print(len("Python"))              # Comprimento: 6

# Métodos úteis
texto = "  python é incrível  "
print(texto.strip().capitalize()) # "Python é incrível"
print("42".zfill(5))              # "00042"
print(", ".join(["a", "b", "c"])) # "a, b, c"

Por serem imutáveis, toda operação que "modifica" uma string na verdade cria uma nova. Python otimiza isso internamente com string interning para literais pequenos.

5. bool – Booleanos

Booleanos representam valores lógicos: True e False. Uma peculiaridade do Python é que bool é uma subclasse de int: True == 1 e False == 0.

# Valores booleanos
ativo = True
inativo = False

# Subclasse de int
print(True + True)    # 2
print(False * 10)     # 0
print(isinstance(True, int))  # True

# Conversão implícita para booleano (truthy/falsy)
# Valores considerados False: 0, 0.0, "", [], {}, None, False
print(bool(0))        # False
print(bool(42))       # True
print(bool(""))       # False
print(bool("Python")) # True

# Operadores lógicos com curto-circuito
def obter_nome():
    print("Função executada")
    return "João"

nome = None
resultado = nome or obter_nome()  # "João" — 'nome' é falsy, então executa obter_nome()
print(resultado)

O curto-circuito em operadores and e or é um recurso poderoso: Python avalia apenas o necessário para determinar o resultado, evitando chamadas desnecessárias.

6. Verificação e conversão entre tipos

Python oferece funções para verificar e converter tipos de forma explícita.

# Verificação de tipo
valor = 42
print(type(valor))           # <class 'int'>
print(isinstance(valor, int)) # True
print(isinstance(valor, (int, float))) # True (aceita tupla de tipos)

# Conversão explícita (casting)
print(int(3.14))      # 3
print(float("2.5"))   # 2.5
print(str(100))       # "100"
print(bool(1))        # True

# Casos especiais
print(int("101", 2))       # 5 (binário)
print(float("inf"))        # inf
print(float("nan"))        # nan

# Tratamento de erros
try:
    numero = int("abc")
except ValueError:
    print("Conversão inválida")

isinstance() é preferível a type() porque aceita herança e permite verificar múltiplos tipos de uma vez.

7. Boas práticas e armadilhas comuns

Comparações entre tipos diferentes podem produzir resultados inesperados:

print(42 == 42.0)   # True (Python compara o valor numérico)
print(42 == "42")   # False (tipos diferentes)

None não é um tipo primitivo, mas um singleton que representa ausência de valor. É essencial para indicar inicializações vazias:

def buscar_usuario(id):
    if id == 0:
        return None
    return {"nome": "Ana"}

usuario = buscar_usuario(0)
if usuario is None:
    print("Usuário não encontrado")

Performance e memória: Python otimiza pequenos inteiros (geralmente de -5 a 256) com caching, reutilizando o mesmo objeto. Strings literais curtas também são internadas para economizar memória:

a = 256
b = 256
print(a is b)  # True (mesmo objeto em cache)

c = 257
d = 257
print(c is d)  # False (objetos diferentes, mesmo valor)

Por fim, evite comparar com == quando quiser verificar identidade de objetos. Use is para None, True e False, e == para igualdade de valor.

Referências