O Que São Variáveis em Python
Uma variável é um espaço na memória do computador destinado a armazenar um valor. Em Python, diferentemente de linguagens como Java ou C, você não precisa declarar explicitamente o tipo da variável — a linguagem identifica automaticamente qual tipo de dado você está armazenando. Pense em uma variável como uma caixa etiquetada: você coloca algo dentro e, posteriormente, pode recuperar ou modificar o conteúdo.
A sintaxe para criar uma variável é simples: basta atribuir um valor usando o sinal de igualdade (=). O identificador (nome da variável) fica à esquerda, e o valor à direita. Python segue algumas convenções de nomenclatura: nomes devem começar com letra ou underscore, podem conter números, e preferencialmente usamos snake_case (letras minúsculas com underscore separando palavras).
# Exemplos de atribuição simples
nome = "Alice"
idade = 28
altura = 1.65
ativo = True
# Atribuição múltipla
x, y, z = 10, 20, 30
# Reatribuição (variável muda de valor)
contador = 0
contador = 5
print(contador) # Output: 5
Note que quando você reatribui uma variável, o valor anterior é descartado. Python gerencia automaticamente a memória, liberando espaço quando o dado não é mais necessário — esse processo é chamado de garbage collection.
Identidade vs. Valor
Toda variável em Python possui três características: o nome (identificador), o tipo (qual classe de dado representa) e o valor (conteúdo). Além disso, existe a identidade, que é um identificador único em memória — você pode verificá-la com a função id().
a = 100
b = 100
print(a == b) # True (mesmo valor)
print(a is b) # True (mesma identidade, porque inteiros pequenos são cacheados)
print(id(a), id(b)) # Pode mostrar o mesmo ID para inteiros entre -5 e 256
# Exemplo com valores maiores
x = 1000
y = 1000
print(x is y) # False (identidades diferentes, embora valores iguais)
Tipos Primitivos em Python
Python possui vários tipos de dados primitivos (ou built-in types). Entender cada um é fundamental para escrever código robusto e eficiente. Os principais são: inteiros, ponto flutuante, booleanos e strings.
Inteiros (int)
O tipo int representa números inteiros, sem casas decimais. Python 3 não possui limite teórico de tamanho para inteiros — você pode trabalhar com números absurdamente grandes sem perder precisão.
numero_pequeno = 42
numero_grande = 99999999999999999999999999999
# Operações com inteiros
resultado = 10 + 5
divisao_inteira = 10 // 3 # Output: 3 (arredonda para baixo)
resto = 10 % 3 # Output: 1 (resto da divisão)
# Conversão para inteiro
texto = "123"
numero = int(texto)
print(numero + 1) # Output: 124
# Inteiros em diferentes bases
binario = 0b1010 # 10 em decimal
octal = 0o12 # 10 em decimal
hexadecimal = 0xa # 10 em decimal
Ponto Flutuante (float)
O tipo float representa números decimais. Internamente, Python usa o padrão IEEE 754 de ponto flutuante, o que significa que existem limitações de precisão.
preco = 19.99
temperatura = -3.5
pi_aproximado = 3.14159
# Operações com floats
resultado = 10.5 / 2.0 # Output: 5.25
potencia = 2.0 ** 3 # Output: 8.0
# Cuidado com precisão
print(0.1 + 0.2) # Output: 0.30000000000000004
print(0.1 + 0.2 == 0.3) # Output: False
# Use o módulo decimal para precisão exata
from decimal import Decimal
valor = Decimal('0.1') + Decimal('0.2')
print(valor == Decimal('0.3')) # Output: True
# Notação científica
numero_muito_grande = 1.5e6 # 1.500.000
numero_muito_pequeno = 2.3e-4 # 0.00023
Booleanos (bool)
O tipo bool possui apenas dois valores possíveis: True e False. Booleanos são úteis em condicionais e lógica de controle de fluxo.
usuario_ativo = True
produto_em_estoque = False
# Operações lógicas
resultado1 = True and False # False
resultado2 = True or False # True
resultado3 = not True # False
# Booleanos e valores "truthy" / "falsy"
# Qualquer valor não-booleano pode ser avaliado como True ou False
if 5: # 5 é "truthy"
print("Número diferente de zero é True")
if 0: # 0 é "falsy"
print("Isto não será executado")
if "": # String vazia é "falsy"
print("Isto não será executado")
if "texto": # String não-vazia é "truthy"
print("Isto será executado")
Strings (str)
O tipo str representa texto. Strings em Python são imutáveis — uma vez criadas, não podem ser modificadas.
mensagem = "Olá, Mundo!"
frase = 'Python é incrível' # Aspas simples ou duplas são equivalentes
# Strings multi-linha
poema = """
Linha 1
Linha 2
Linha 3
"""
# Concatenação
saudacao = "Olá" + ", " + "Python"
# Formatação com f-strings (Python 3.6+)
nome = "Bob"
idade = 25
apresentacao = f"Meu nome é {nome} e tenho {idade} anos"
# Métodos úteis de string
texto = "python"
print(texto.upper()) # PYTHON
print(texto.capitalize()) # Python
print(texto.replace('o', '0')) # pyth0n
print(len(texto)) # 6
# Índice e slicing
primeiro_caractere = texto[0] # p
ultimos_dois = texto[-2:] # on
intervalo = texto[1:4] # yth
Tipagem Dinâmica em Python
Tipagem dinâmica significa que o tipo de uma variável é determinado em tempo de execução, não em tempo de compilação. Você pode atribuir um valor de um tipo, e depois reatribuir com um valor de outro tipo completamente diferente. Isso oferece flexibilidade, mas também requer cuidado.
variavel = 10 # tipo int
variavel = "texto" # agora é str
variavel = 3.14 # agora é float
variavel = True # agora é bool
print(type(variavel)) # <class 'bool'>
A vantagem da tipagem dinâmica é permitir código mais conciso e flexível. A desvantagem é que erros de tipo podem aparecer apenas durante a execução, não durante o desenvolvimento. Um erro comum é tentar operações incompatíveis com o tipo:
resultado = "5" + 2 # TypeError: can only concatenate str (not "int") to str
# Para evitar isso, converta explicitamente
resultado = int("5") + 2 # 7
resultado = "5" + str(2) # "52"
Type Hints (Anotações de Tipo)
Python oferece type hints (anotações de tipo) para documentar qual tipo uma variável ou função deveria ter. Essas anotações não são obrigatórias e não alteram o comportamento em tempo de execução, mas melhoram a legibilidade e permitem que ferramentas como mypy detectem erros potenciais.
# Variáveis com type hints
numero: int = 42
texto: str = "olá"
ativo: bool = True
preco: float = 19.99
# Type hints em funções
def saudacao(nome: str) -> str:
return f"Olá, {nome}!"
def somar(a: int, b: int) -> int:
return a + b
resultado = somar(3, 5)
print(resultado) # 8
# Tipo genérico para coleções
from typing import List, Dict
numeros: List[int] = [1, 2, 3, 4]
pessoas: Dict[str, int] = {"Alice": 25, "Bob": 30}
Função type() e isinstance()
Para verificar o tipo de uma variável em tempo de execução, use type() ou isinstance().
# Usando type()
print(type(42)) # <class 'int'>
print(type(3.14)) # <class 'float'>
print(type("texto")) # <class 'str'>
print(type(True)) # <class 'bool'>
# Comparando tipos
if type(42) == int:
print("É um inteiro")
# Usando isinstance() (preferido)
if isinstance(42, int):
print("É um inteiro ou subclasse de int")
# isinstance() permite verificar múltiplos tipos
valor = 3.14
if isinstance(valor, (int, float)):
print("É um número")
Conversão de Tipos (Casting)
Frequentemente você precisa converter um tipo para outro. Python fornece funções built-in para isso.
# De string para outros tipos
numero_de_string = int("123")
decimal_de_string = float("3.14")
booleano_de_string = bool("True") # Cuidado: qualquer string não-vazia é True!
# De inteiro para outros tipos
stringificado = str(42) # "42"
decimal = float(42) # 42.0
# De float para outros tipos
inteiro = int(3.99) # 3 (trunca, não arredonda)
stringificado = str(3.14) # "3.14"
# Conversões mais complexas
lista_de_numeros = [1, 2, 3, 4, 5]
como_string = str(lista_de_numeros) # "[1, 2, 3, 4, 5]"
# Arredondamento correto de float para int
valor = 3.7
arredondado = round(valor) # 4
Boas Práticas e Armadilhas Comuns
Trabalhar com variáveis e tipos em Python exige atenção a alguns detalhes que podem causar bugs subtis. Uma das armadilhas mais comuns envolve objetos mutáveis como listas e dicionários.
# Armadilha: compartilhamento de referência
lista_original = [1, 2, 3]
lista_copia = lista_original # Não cria cópia, apenas referencia o mesmo objeto
lista_copia.append(4)
print(lista_original) # [1, 2, 3, 4] — também foi modificada!
# Solução: criar uma cópia real
lista_copia = lista_original.copy()
lista_copia.append(4)
print(lista_original) # [1, 2, 3] — intacta
# Para cópias profundas (nested structures)
import copy
lista_aninhada = [[1, 2], [3, 4]]
copia_profunda = copy.deepcopy(lista_aninhada)
Outra boa prática é usar nomes significativos para variáveis. Um nome bem escolhido documenta o código e reduz a necessidade de comentários.
# Ruim
x = 25
y = 3.5
z = "Alice"
# Bom
idade_usuario = 25
altura_em_metros = 3.5
nome_completo = "Alice"
# Ruim
dados = [1, 2, 3, 4, 5]
# Bom
idades_dos_clientes = [1, 2, 3, 4, 5]
Conclusão
Aprendemos que variáveis são contêineres para dados, identificadas por nomes e gerenciadas automaticamente por Python. Os tipos primitivos — int, float, bool e str — são os blocos fundamentais de qualquer programa Python, cada um com suas características e operações específicas. A tipagem dinâmica oferece flexibilidade mas exige cuidado: você pode mudar o tipo de uma variável a qualquer momento, porém deve estar atento aos erros que podem surgir em tempo de execução. Por fim, type hints são uma prática moderna que ajuda a documentar código e detectar erros sem sacrificar a natureza dinâmica da linguagem.