Listas, Tuplas e Sets em Python

Laboratório de Programação — Ciência da Computação • UFPI

Sintaxe básica, características, exemplos práticos e usos comuns — com syntax highlighting

Listas em Python — Introdução

Coleções ordenadas de itens
Mutáveis e heterogêneas
Estrutura versátil e muito utilizada

Listas — Criando

# Lista vazia
minha_lista = []

# Lista com elementos
numeros = [1, 2, 3, 4, 5]
misturada = [1, "texto", True, 3.14]

Listas — Acessando elementos

frutas = ["maçã", "banana", "laranja"]

# Acesso por índice (começa em 0)
primeira = frutas[0]    # "maçã"
ultima = frutas[-1]     # "laranja" (índice negativo)

Listas — Características

Ordenadas (mantêm ordem de inserção)
Mutáveis (alteráveis após criar)
Indexáveis (acesso rápido por índice)
Dinâmicas (crescem/diminuem)
Aninháveis (podem conter outras listas)

Listas — Modificar & Inserir

cores = ["vermelho", "verde", "azul"]
cores[1] = "amarelo"      # substitui "verde"

cores.append("roxo")      # adiciona ao final
cores.insert(1, "laranja")# insere na posição 1

Listas — Remover

cores.remove("azul")      # remove por valor
cor_removida = cores.pop(2)  # remove por índice e retorna
del cores[0]              # remove por índice (sem retorno)

Listas — Fatiamento (slicing)

numeros = [0,1,2,3,4,5,6,7,8,9]

# lista[início:fim:passo]
primeiros = numeros[0:3]   # [0, 1, 2]
pares     = numeros[0:10:2]# [0, 2, 4, 6, 8]
reverso   = numeros[::-1]  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Listas — Iteração

# Loop direto
for fruta in ["maçã", "banana", "laranja"]:
    print(fruta)

# Loop com índice
frutas = ["maçã", "banana", "laranja"]
for indice, fruta in enumerate(frutas):
    print(f"Índice {indice}: {fruta}")

Listas — Métodos úteis

lista = [3, 1, 4, 1, 5, 9, 2]

tamanho  = len(lista)      # 7
contagem = lista.count(1)  # 2

lista.sort()               # [1, 1, 2, 3, 4, 5, 9]
lista.sort(reverse=True)   # [9, 5, 4, 3, 2, 1, 1]

lista.reverse()            # inverte in-place

Listas — Operações

a = [1, 2, 3]
b = [4, 5, 6]

c = a + b       # concatenação
d = a * 2       # repetição
existe = 3 in a # verificação

Usos — Pilhas, Filas, Compreensão

# Pilha (LIFO)
pilha = []
pilha.append("item")
item = pilha.pop()

# Fila (FIFO)
from collections import deque
fila = deque(["a", "b", "c"])
fila.append("d")
primeiro = fila.popleft()

# Compreensão de listas
quadrados = [x**2 for x in range(10) if x % 2 == 0]

Listas — Exemplo prático

# Gerenciador de tarefas simples
tarefas = []

def adicionar_tarefa(descricao, prioridade=3):
    tarefas.append({"descricao": descricao, "prioridade": prioridade})

def listar_tarefas():
    tarefas_ordenadas = sorted(tarefas, key=lambda x: x["prioridade"])
    print("Lista de Tarefas:")
    for i, t in enumerate(tarefas_ordenadas, 1):
        print(f"{i}. {t['descricao']} (Prioridade: {t['prioridade']})")

adicionar_tarefa("Estudar Python", 1)
adicionar_tarefa("Fazer compras", 3)
adicionar_tarefa("Ler livro", 2)
listar_tarefas()

Tuplas em Python — Introdução

Parecidas com listas, porém imutáveis
Ideais para dados constantes
Frequentemente mais eficientes em memória

Tuplas — Criando

minha_tupla = ()           # vazia
coordenadas = (10, 20)
cores = ("vermelho", "verde", "azul")
tupla_unica = ("único",)   # vírgula obrigatória
ponto = 30, 40             # packing sem parênteses

Tuplas — Acessando

dados = ("João", 25, "Engenheiro")
nome  = dados[0]   # "João"
idade = dados[-2]  # 25

Tuplas — Imutabilidade

lista = [1, 2, 3]
lista[1] = 99      # ok

tupla = (1, 2, 3)
tupla[1] = 99      # TypeError: não é possível alterar

Vantagens: segurança contra alterações, chaves de dicionário, desempenho.

Tuplas — Operações

tupla1 = (1, 2, 3)
tupla2 = (4, 5, 6)

tupla3 = tupla1 + tupla2     # concatenação
tupla_rep = tupla1 * 2       # repetição

numeros = (0,1,2,3,4,5,6,7,8,9)
primeiros = numeros[0:3]
pares = numeros[0:10:2]
rev = numeros[::-1]

Tuplas — Métodos & Desempacotar

t = (1,2,3,2,4,2)
contagem = t.count(2)  # 3
posicao  = t.index(3)  # 2
tamanho  = len(t)      # 6

# Desempacotamento
x, y = (10, 20)
a, b = 5, 10
a, b = b, a

valores = (1, 2, 3, 4, 5)
primeiro, *meio, ultimo = valores

Tuplas — Como chaves de dicionário

coordenadas_pixels = {
    (0, 0): "preto",
    (1, 0): "branco",
    (0, 1): "cinza"
}
print(coordenadas_pixels[(1, 0)])  # "branco"

Tuplas — Retorno múltiplo

def calcular_estatisticas(numeros):
    media = sum(numeros) / len(numeros)
    return media, max(numeros), min(numeros)

media, maximo, minimo = calcular_estatisticas([10,20,30,40,50])
print(media, maximo, minimo)

Tuplas vs Listas

Característica	Tuplas	Listas
Mutabilidade	Imutável	Mutável
Sintaxe	`()` ou sem parênteses	`[]`
Desempenho	Geralmente mais rápido	Mais lento
Uso como chave	Pode	Não
Métodos	count, index	muitos
Casos de uso	Dados constantes	Dados mutáveis

Tuplas — Exemplo prático

# Sistema de coordenadas geográficas
def calcular_distancia(ponto1, ponto2):
    x1, y1 = ponto1
    x2, y2 = ponto2
    return ((x2 - x1)**2 + (y2 - y1)**2)**0.5

ponto_a = (3, 4)
ponto_b = (6, 8)
distancia = calcular_distancia(ponto_a, ponto_b)
print(f"Distância: {distancia:.2f}")

locais = {
    (40.7128, -74.0060): "Nova York",
    (51.5074,  -0.1278): "Londres",
    (35.6762, 139.6503): "Tóquio"
}
print(locais[(40.7128, -74.0060)])

Sets (Conjuntos) em Python — Introdução

Elementos únicos e não ordenados
Mutáveis (mas elementos devem ser imutáveis)
Excelentes para operações de conjunto e verificação de membro

Sets — Criando & Convertendo

meu_set = {1, 2, 3, "Python", "programação"}
set_vazio = set()   # {} seria dicionário

numeros = {1, 2, 2, 3, 3, 3}
print(numeros)  # {1, 2, 3}

lista = [1, 2, 2, 3, 3, 3]
set_unico = set(lista)      # {1, 2, 3}
palavra = set("abacaxi")    # {'a','b','c','x','i'}

Sets — Adicionar & Remover

linguagens = {"Python", "Java"}
linguagens.add("C++")
linguagens.update(["JavaScript", "Ruby"])

linguagens.remove("Java")   # erro se não existir
linguagens.discard("PHP")   # não erra se não existir
x = linguagens.pop()        # remove elemento arbitrário
linguagens.clear()

Sets — Verificação e tamanho

numeros = {1, 2, 3, 4, 5}
if 3 in numeros:
    print("3 está no conjunto")
tamanho = len(numeros)

Sets — Operações de conjunto

A = {1, 2, 3}
B = {3, 4, 5}

uniao        = A | B                 # {1,2,3,4,5}
intersecao   = A & B                 # {3}
diferenca    = A - B                 # {1,2}
dif_sim      = A ^ B                 # {1,2,4,5}

Sets — Relações

X = {1, 2, 3}
Y = {1, 2}
Z = {4, 5}

Y.issubset(X)    # True
X.issuperset(Y)  # True
X.isdisjoint(Z)  # True

Sets — Comuns & Filtragem

# Remover duplicatas
lista_dup = [1,1,2,2,3,3,3,4]
unicos = list(set(lista_dup))  # ordem pode variar

# Interseção entre listas
lista1 = [1,2,3,4,5]
lista2 = [4,5,6,7,8]
comuns = set(lista1) & set(lista2)  # {4, 5}

Sets — Exemplo prático

clientes_jan = {"Ana", "João", "Maria", "Carlos"}
clientes_fev = {"João", "Maria", "Pedro", "Ana"}

fieis = clientes_jan & clientes_fev   # em ambos
novos  = clientes_fev - clientes_jan  # apenas em fev
todos  = clientes_jan | clientes_fev  # união

Conclusões & Dicas

Listas: coleções mutáveis e ordenadas — ótimas para processamento geral.
Tuplas: sequências imutáveis — ideais para dados constantes e chaves.
Sets: conjuntos não ordenados e únicos — perfeitos para pertinência & operações de conjunto.

Escolha a estrutura conforme a necessidade de mutabilidade, ordem e unicidade.