Estruturas de Dados em Python: Listas, Dicionários, Tuplas e Sets

Listas (list)

A lista é uma coleção ordenada e mutável que permite armazenar elementos de diferentes tipos. É uma das estruturas mais versáteis do Python.

Sintaxe

frutas = ['maçã', 'banana', 'laranja']
numeros = [1, 2, 3, 4, 5]
mista = [1, 'texto', True, 3.14]

Principais Métodos

• append(item) – adiciona ao final
• insert(pos, item) – insere em posição específica
• remove(item) – remove a primeira ocorrência
• pop(pos) – remove e retorna o elemento
• sort() – ordena a lista
• reverse() – inverte a ordem

Complexidade de Operações

Exemplos Práticos

Exemplo 1: Gerenciamento de tarefas

tarefas = []
tarefas.append('Estudar Python')
tarefas.append('Fazer exercícios')
tarefas.append('Revisar anotações')
print(tarefas)  # ['Estudar Python', 'Fazer exercícios', 'Revisar anotações']
concluida = tarefas.pop(0)
print(f'Concluída: {concluida}')
print(tarefas)  # ['Fazer exercícios', 'Revisar anotações']

Exemplo 2: Compreensão de listas (list comprehension)

numeros = list(range(1, 11))
pares = [n for n in numeros if n % 2 == 0]
print(pares)  # [2, 4, 6, 8, 10]

Dicionários (dict)

O dicionário é uma coleção não ordenada de pares chave-valor. É ideal para armazenar dados que precisam de uma chave de busca rápida.

Sintaxe

aluno = {
    'nome': 'Ana',
    'idade': 22,
    'curso': 'Ciência da Computação'
}

Principais Métodos

• get(chave, default) – acessa valor com segurança
• keys() – retorna as chaves
• values() – retorna os valores
• items() – retorna pares (chave, valor)
• update(dict) – atualiza com outro dicionário
• pop(chave) – remove e retorna o valor

Complexidade

Exemplos Práticos

Exemplo 1: Contagem de palavras

texto = "python é incrível python é poderoso"
contagem = {}
for palavra in texto.split():
    contagem[palavra] = contagem.get(palavra, 0) + 1
print(contagem)
# {'python': 2, 'é': 2, 'incrível': 1, 'poderoso': 1}

Exemplo 2: Agenda telefônica

agenda = {
    'Maria': '(21) 99999-0001',
    'João': '(21) 99999-0002'
}
agenda['Ana'] = '(21) 99999-0003'
print(agenda.get('Maria', 'Contato não encontrado'))
# (21) 99999-0001

Tuplas (tuple)

Tupla é uma coleção ordenada e imutável. Uma vez criada, seus elementos não podem ser alterados. É útil para garantir que dados não sejam modificados.

Sintaxe

coordenadas = (10.5, 20.8)
cores_rgb = (255, 0, 128)
unitaria = (1,)  # necessário a vírgula

Principais Métodos

• count(item) – quantas vezes aparece
• index(item) – posição da primeira ocorrência

Complexidade

Assim como listas: acesso O(1), busca O(n). Por ser imutável, não há operações de inserção/remoção.

Exemplos Práticos

Exemplo 1: Coordenadas geográficas

ponto = (-23.5505, -46.6333)  # São Paulo
lat, lng = ponto
print(f'Latitude: {lat}, Longitude: {lng}')

Exemplo 2: Retorno múltiplo de função

def dividir(a, b):
    return (a // b, a % b)

quociente, resto = dividir(17, 5)
print(f'{quociente}, resto {resto}')  # 3, resto 2

Sets (set)

Um set é uma coleção não ordenada de elementos únicos e mutáveis. Perfeito para operações de conjunto como união, interseção e diferença.

Sintaxe

conjunto_a = {1, 2, 3, 4}
conjunto_b = set([3, 4, 5, 6])

Principais Métodos

• add(elemento) – adiciona
• remove(elemento) – remove (gera erro se não existir)
• union(outro) – união
• intersection(outro) – interseção
• difference(outro) – diferença

Complexidade

Exemplos Práticos

Exemplo 1: Remover duplicatas de uma lista

numeros = [1, 2, 2, 3, 4, 4, 5]
unicos = list(set(numeros))
print(unicos)  # [1, 2, 3, 4, 5]

Exemplo 2: Operações entre conjuntos

frontend = {'HTML', 'CSS', 'JavaScript'}
backend = {'Python', 'PHP', 'JavaScript'}
fullstack = frontend.union(backend)
print(fullstack)
# {'HTML', 'CSS', 'JavaScript', 'Python', 'PHP'}

Filas (queue)

Uma fila segue o princípio FIFO (First In, First Out). Em Python, podemos implementar de forma eficiente usando collections.deque.

Implementação

from collections import deque

fila = deque()
fila.append('tarefa1')   # enqueue
fila.append('tarefa2')
fila.append('tarefa3')
primeira = fila.popleft()  # dequeue
print(primeira)  # tarefa1
print(fila)      # deque(['tarefa2', 'tarefa3'])

Complexidade

• Enqueue (append): O(1)
• Dequeue (popleft): O(1)

Exemplos Práticos

Exemplo 1: Fila de impressão

from collections import deque

fila_impressao = deque()
fila_impressao.append('Documento1.pdf')
fila_impressao.append('Foto.jpg')
fila_impressao.append('Relatorio.docx')

while fila_impressao:
    doc = fila_impressao.popleft()
    print(f'Imprimindo: {doc}')

Exemplo 2: Processamento de pedidos

pedidos = deque()
for i in range(1, 6):
    pedidos.append(f'Pedido #{i}')
while pedidos:
    atual = pedidos.popleft()
    print(f'Processando {atual}')

Pilhas (stack)

Pilha segue o princípio LIFO (Last In, First Out). Python listas já funcionam como pilha com append (push) e pop.

Sintaxe

pilha = []
pilha.append('item1')   # push
pilha.append('item2')
pilha.append('item3')
topo = pilha.pop()      # pop
print(topo)   # item3
print(pilha)  # ['item1', 'item2']

Complexidade

• Push (append): O(1)
• Pop: O(1)

Exemplos Práticos

Exemplo 1: Verificar parênteses balanceados

def balanceado(expressao):
    pilha = []
    for char in expressao:
        if char == '(':
            pilha.append(char)
        elif char == ')':
            if not pilha:
                return False
            pilha.pop()
    return len(pilha) == 0

print(balanceado('( ( ) )'))   # True
print(balanceado('( ) )'))    # False

Exemplo 2: Histórico de navegação (voltar)

historico = []
historico.append('pagina1')
historico.append('pagina2')
historico.append('pagina3')
# Usuário clica "voltar"
ultima = historico.pop()
print(f'Voltando de {ultima}')
print(f'Página atual: {historico[-1] if historico else "nenhuma"}')

Resumo e Dicas de Escolha

• Lista: Use quando precisar de uma coleção ordenada e mutável, com possibilidade de acesso por índice.
• Dicionário: Ideal para relacionar chaves a valores, como um banco de dados em memória.
• Tupla: Use para dados que não devem ser alterados (imutáveis), como constantes e retornos de função.
• Set: Perfeito para eliminar duplicatas e realizar operações de conjunto.
• Fila: Quando a ordem de chegada precisa ser respeitada (FIFO).
• Pilha: Para algoritmos que exigem ordem inversa (LIFO), como undo/redo.

Escolher a estrutura certa pode melhorar drasticamente a performance do seu código. Em Python, a biblioteca padrão oferece implementações otimizadas para cada caso.

Para aprofundar seus conhecimentos em Python, confira nosso guia completo de Python para back-end e veja como essas estruturas são usadas em aplicações reais.

Perguntas Frequentes

Qual a diferença entre lista e tupla em Python?

A principal diferença é que listas são mutáveis (podem ser alteradas depois de criadas) enquanto tuplas são imutáveis. Tuplas consomem menos memória e podem ser usadas como chaves de dicionário, o que não é possível com listas.

Quando usar set em vez de lista?

Use set quando você precisa garantir que os elementos sejam únicos e não se importa com a ordem. Sets oferecem operações de pertinência O(1) e métodos matemáticos de conjunto, sendo muito mais rápidos que listas para buscas.

Como implementar uma fila eficiente em Python?

A melhor forma é usar collections.deque, que oferece operações de inserção e remoção O(1) em ambas as extremidades. Evite usar listas com pop(0) pois isso é O(n).

Continue seus estudos

Dominar estruturas de dados é essencial para se tornar um programador completo. Explore outros conteúdos do nosso hub de estudos e tutoriais de programação para avançar ainda mais. Bônus de boas-vindas até R$1.500

• Exercícios de lógica de programação para praticar os fundamentos.
• Algoritmos comparativos para ver implementações em diferentes linguagens.
• Desafios resolvidos para testar suas habilidades.