Submódulo 3: Listas, tuplas e dicionários: estruturas de dados simples

Conceito e escolha entre listas, tuplas e dicionários

🎯 Por que conhecer as coleções básicas?

Antes de programar, vamos construir um modelo mental. Imagine seus dados como objetos em um armário:

• Lista é como uma prateleira onde você pode adicionar, remover ou reorganizar caixas (ordenada e mutável).
• Tupla é como uma caixa lacrada com itens fixos — você não muda o conteúdo depois de selar (ordenada e imutável).
• Dicionário é como uma etiqueta que aponta para um conteúdo — você consulta pelo rótulo (chave) e obtém o valor rapidamente (mapeamento chave→valor).

Por que isso importa? Porque a escolha afeta legibilidade, segurança (imutabilidade) e desempenho. Vamos ver por que e como usar cada uma na prática (referências oficiais e guias práticos abaixo) (1)(2).

Lembra que vimos...

Nos submódulos anteriores vimos tipos primitivos e operações básicas. Agora aplicamos esses tipos para organizar coleções: sequências (listas/tuplas) e mapeamentos (dicionários). Isso prepara você para funções e controle de fluxo adiante.

Exemplos rápidos — o que cria cada estrutura?

# Lista: mutável, ordenada
lista = [1, 2, 3]
# Tupla: imutável, ordenada
tupla = ("a", "b", "c")
# Dicionário: pares chave:valor
pessoa = {"nome": "Ana", "idade": 25}

# Acesso
primeiro = lista[0]        # 1
nome = pessoa["nome"]     # 'Ana'
# Note: acessar chave inexistente causa KeyError

Se você precisar de consulta por rótulo (como um catálogo), prefira dicionários. Se os elementos nunca devem mudar, use tupla. Para coleções mutáveis e frequentemente modificadas, use lista. A documentação oficial descreve detalhes sobre sequências e mapeamentos (1). Recursos didáticos mostram quando e como usar compreensões para criar coleções de forma concisa (2).

Listas: operações, métodos e mutabilidade (fatiamento e bons hábitos)

🔧 Por que dominar operações de lista?

Listas são a estrutura de coleção mais usada em Python. Saber manipulá-las com segurança evita bugs e melhora performance. Vamos ver os métodos importantes, como fatiamento funciona e quais erros esperar. A documentação detalha a API de sequências e exemplos (1). Para transformar loops em formas mais concisas, compreensões e geradores são úteis (2).

Operações essenciais

• append(x) — adiciona um item ao fim.
• extend(iterable) — adiciona cada item do iterável.
• insert(i, x) — insere na posição i.
• remove(x) — remove a primeira ocorrência de x.
• pop([i]) — remove e retorna o item (último por padrão).
• clear() — remove todos os itens.

Fatiamento (slicing)

Fatiamento produz uma nova lista com os elementos selecionados: sub = lista[1:4:2]. Lembre que fatiamento cria cópia superficial, logo alterações em objetos mutáveis dentro dessa sublista afetam os itens originais.

Exemplo prático com testes

# Vamos construir e testar pequenas operações
nums = [10, 20, 30]
nums.append(40)            # [10, 20, 30, 40]
nums.insert(1, 15)         # [10, 15, 20, 30, 40]
last = nums.pop()          # last == 40
nums.remove(15)            # [10, 20, 30]
# slicing cria cópia
sub = nums[0:2]
assert sub == [10, 20]
# erro comum: nums[10] -> IndexError

Erros comuns e boas práticas

Um erro frequente é modificar uma lista enquanto itera sobre ela — isso causa comportamento inesperado. Se precisar remover itens durante iteração, iterar sobre uma cópia (for x in lista[:]) ou construir uma nova lista com compreensão é mais seguro (2).

Dicionários, compreensões e critérios para escolher a estrutura certa

📦 Dicionários: armazenamento por chave

Dicionários são coleções não ordenadas de pares chave: valor (em CPython a ordem de inserção é preservada para operações iterativas, mas o acesso é por chave) (1). Usamos dicionários quando precisamos buscar por rótulos ao invés de índices numéricos.

Operações úteis

• val = d[k] — acessa (KeyError se inexistente).
• val = d.get(k, default) — acessa com valor padrão se chave ausente.
• d.keys(), d.values(), d.items() — iteradores úteis para percorrer o conteúdo.
• del d[k] ou d.pop(k) — remover pares.

Compreensões

Assim como listas, podemos criar dicionários de forma concisa com compreensões:

# Dicionário de quadrados
squares = {x: x*x for x in range(6)}
# Usando get para consulta segura
valor = squares.get(10, 'não encontrado')

Compreensões deixam o código mais curto e frequentemente mais claro — mas evite compreensões muito complexas: prefira legibilidade (2).

Documentação e guias práticos detalham os métodos, iteração e boas práticas para dicionários e compreensões (1)(3).

🎯 Exercícios