Listas, Tuplas e Fatiamento
Domine as operações com listas do Python, a sintaxe de fatiamento e a imutabilidade das tuplas com exemplos práticos baseados em desafios clássicos de programação.
Listas, Tuplas e Fatiamento é uma aula grátis de DSA Interview Prep no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de DSA Interview Prep, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de DSA Interview Prep inclui 4 aulas no total.
Listas do Python: vetores dinâmicos
Uma lista do Python é um vetor dinâmico que armazena qualquer coisa e cresce automaticamente. Ela é ordenada, mutável e oferece acesso instantâneo O(1) por índice. O código mostra o básico.
nums = [3, 1, 4, 1, 5]
print(nums[0]) # 3
print(nums[-1]) # 5 (last element)
nums.append(9)
print(len(nums)) # 6Operações comuns com listas
Memorize estas operações: append e pop no final são O(1), mas insert no início é O(n). Evite usar remove em laços críticos — ele faz uma nova varredura a cada vez.
stack = []
stack.append(1)
stack.append(2)
stack.append(3)
print(stack.pop()) # 3 O(1)
print(stack) # [1, 2]
# insert at index 0 is O(n)
stack.insert(0, 0)
print(stack) # [0, 1, 2]Sintaxe de fatiamento explicada
O fatiamento usa a forma lst[start:stop:step] e para imediatamente antes de stop. O truque clássico: um passo igual a -1 inverte uma lista sem alterá-la. O código percorre cada forma.
a = [0, 1, 2, 3, 4, 5]
print(a[1:4]) # [1, 2, 3]
print(a[:3]) # [0, 1, 2]
print(a[3:]) # [3, 4, 5]
print(a[::2]) # [0, 2, 4] every other
print(a[::-1]) # [5, 4, 3, 2, 1, 0] reversedO fatiamento cria cópias rasas
Uma particularidade importante: o fatiamento sempre cria uma nova lista, portanto editar o fatiamento não altera a lista original. Mas a cópia é rasa, então as listas aninhadas continuam compartilhadas. Tenha cuidado.
original = [1, 2, 3]
copy = original[:] # shallow copy
copy[0] = 99
print(original) # [1, 2, 3] unchanged
# Nested list pitfall
nested = [[1, 2], [3, 4]]
shallow = nested[:]
shallow[0][0] = 99
print(nested) # [[99, 2], [3, 4]] changed!Tuplas: sequências imutáveis
Uma tupla usa parênteses e não pode ser alterada depois de criada. Como é hasheável, pode ser uma chave de um dicionário ou um membro de um conjunto — perfeita para pares (linha, coluna) em problemas de grade.
point = (3, 7)
print(point[0]) # 3
# Use as dict key
grid = {}
grid[(0, 0)] = 'start'
grid[(2, 3)] = 'end'
print(grid[(0, 0)]) # start
# Unpacking
x, y = point
print(x, y) # 3 7Quando usar tupla em vez de lista
Escolha uma tupla quando os dados não devem mudar e uma lista quando devem mudar. As tuplas também usam um pouco menos de memória, o que faz diferença dentro de grandes heaps no algoritmo de Dijkstra.
import sys
a_list = [1, 2, 3, 4, 5]
a_tuple = (1, 2, 3, 4, 5)
print(sys.getsizeof(a_list)) # e.g. 104 bytes
print(sys.getsizeof(a_tuple)) # e.g. 80 bytes
# Tuple returned from function
def min_max(nums):
return min(nums), max(nums)
lo, hi = min_max([3, 1, 4, 1, 5])
print(lo, hi) # 1 5Erros de um a mais ou um a menos no fatiamento
Erros de um a mais ou um a menos são a principal armadilha em problemas com vetores. Lembre-se de que lst[i:j] fornece exatamente j-i itens. Para dividir no meio, a esquerda é lst[:mid] e a direita é lst[mid:].
lst = [1, 2, 3, 4, 5, 6]
mid = len(lst) // 2 # 3
left = lst[:mid] # [1, 2, 3]
right = lst[mid:] # [4, 5, 6]
print(left, right)
# How many elements?
print(len(lst[2:5])) # 3 (indices 2,3,4)Índices negativos em entrevistas
O Python tem índices negativos: lst[-1] é o último item, e lst[-2] é o anterior. Prefira lst[-1] a lst[len(lst)-1] — os entrevistadores percebem a versão mais limpa.
s = 'abcde'
print(s[-1]) # 'e'
print(s[-3:]) # 'cde'
print(s[:-2]) # 'abc' (all except last 2)
nums = [10, 20, 30, 40]
print(nums[-2]) # 30
nums[-1] = 99
print(nums) # [10, 20, 30, 99]Ordenação e comparação de listas
A ordenação do Python usa Timsort (O(n log n) e estável). lst.sort() altera a lista no próprio lugar; sorted(lst) retorna uma nova lista. Use a opção key para uma ordem personalizada. Consulte o código.
words = ['banana', 'fig', 'apple', 'kiwi']
words.sort(key=len)
print(words) # ['fig', 'kiwi', 'apple', 'banana']
nums = [3, 1, 4, 1, 5]
print(sorted(nums, reverse=True)) # [5, 4, 3, 1, 1]
print(nums) # unchanged: [3, 1, 4, 1, 5]Alteração de listas durante a iteração
Uma armadilha clássica: nunca adicione nem remova itens enquanto percorre uma lista — você pulará elementos ou causará uma falha. Em vez disso, crie uma nova lista com uma compreensão.
# WRONG — skips elements
nums = [1, 2, 3, 4, 5]
for n in nums:
if n % 2 == 0:
nums.remove(n) # skips 4!
print(nums) # [1, 3, 5]... but 4 got skipped? Actually removes 2,4
# CORRECT — build new list
nums = [1, 2, 3, 4, 5]
nums = [n for n in nums if n % 2 != 0]
print(nums) # [1, 3, 5]Desempacotamento de tuplas em laços
O desempacotamento de tuplas mantém os laços organizados: enumerate fornece (índice, valor), e zip percorre duas listas juntas. A sintaxe *rest captura o restante em sua própria variável. Consulte o código.
nums = [10, 20, 30]
for i, v in enumerate(nums):
print(i, v)
# 0 10 / 1 20 / 2 30
a = [1, 2, 3]
b = ['x', 'y', 'z']
for x, y in zip(a, b):
print(x, y)
first, *rest = [1, 2, 3, 4]
print(first, rest) # 1 [2, 3, 4]Verificação rápida
Verificação rápida — mostre o que você aprendeu sobre listas, tuplas e fatiamento no Python. Você consegue. 💪
Recapitulação da lição
Recapitulação: listas são vetores dinâmicos com append O(1), o fatiamento sempre retorna uma cópia nova, e as tuplas são imutáveis e hasheáveis. A seguir: dicionários e conjuntos.
Perguntas Frequentes
A aula “Listas, Tuplas e Fatiamento” é grátis?
Sim — o texto completo de “Listas, Tuplas e Fatiamento” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de DSA Interview Prep, atualize para CoddyKit PRO. O curso de DSA Interview Prep inclui 4 aulas no total.
O que vou aprender em “Listas, Tuplas e Fatiamento”?
Domine as operações com listas do Python, a sintaxe de fatiamento e a imutabilidade das tuplas com exemplos práticos baseados em desafios clássicos de programação. Você pratica DSA Interview Prep com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar DSA Interview Prep?
Nenhuma experiência prévia é necessária. DSA Interview Prep no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Listas, Tuplas e Fatiamento”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de DSA Interview Prep?
Sim. Cada aula de DSA Interview Prep inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Listas, Tuplas e Fatiamento
- Dicionários e Conjuntos em Python
- Compreensões e Funções Integradas
- Funções, Fechamentos e Lambda