Listas em Python (list): métodos, fatias, ordenação, append, tuplas e conjuntos

A lista em Python (list) é um conjunto ordenado de valores qualquer entre colchetes, que pode ser alterado: é possível acrescentar elementos no fim, inserir no meio, remover e ordenar. É a coleção mais usada da linguagem: linhas de um arquivo, gastos do mês, respostas de APIs — quase tudo começa com uma lista. Vamos ver a python list por completo: criação, métodos, fatias, ordenação, list comprehension, cópia e, no final, tuplas e conjuntos.

O que é uma lista em Python

A lista guarda os elementos na ordem em que foram definidos e acessa cada um pelo índice a partir de zero. Em uma mesma lista podem estar valores de tipos diferentes, embora na prática costumem ser guardados dados do mesmo tipo.

amounts = [250, 1200, 99]
print(amounts[0])     # 250 — primeiro elemento
print(amounts[-1])    # 99 — último
amounts[1] = 1300     # a lista é modificável
print(len(amounts))   # 3 — tamanho da lista

O tamanho da lista é retornado pela função len(). Acessar um índice inexistente gera IndexError: list index out of range.

Criação de uma lista

empty = []                       # lista vazia
also_empty = list()              # o mesmo, pela função list
nums = [1, 2, 3]
chars = list("abc")              # ['a', 'b', 'c']
digits = list(range(5))          # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]

A função list() transforma em lista qualquer objeto iterável: uma string, um range, um conjunto, as chaves de um dicionário.

append e outros métodos de lista

O método append acrescenta um elemento no fim da lista — é o método mais usado em Python. Ele altera a lista no próprio lugar e devolve None.

amounts = [250, 1200]
amounts.append(450)          # [250, 1200, 450]
amounts.extend([10, 20])     # [250, 1200, 450, 10, 20]
amounts.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
amounts.remove(1200)         # remove o primeiro valor 1200
last = amounts.pop()         # 20 — remove e devolve o último

Erro frequente: a.append([10, 20]) acrescenta um único elemento — uma lista aninhada, e não dois números. Para vários elementos é preciso usar extend.

Remover um elemento pelo índice ou um intervalo inteiro também pode ser feito com o operador del: del a[0], del a[1:3]. Funções embutidas úteis com listas: len, sum, min, max, sorted, reversed, enumerate, zip.

Fatias em Python

A fatia pega parte da lista pela forma a[start:stop:step]: do start incluído até o stop não incluído, com o passo step. Qualquer parte pode ser omitida. A fatia sempre devolve uma nova lista.

a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — os dois primeiros
print(a[-2:])     # [4, 5] — os dois últimos
print(a[::2])     # [0, 2, 4] — cada segundo elemento
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — invertida
print(a[:])       # cópia da lista inteira

Diferente do índice, a fatia fora dos limites não gera erro: a[10:20] simplesmente devolve []. Também é possível atribuir valores a uma fatia e substituir um pedaço da lista: a[1:3] = ["x", "y", "z"].

Fatia de string

As fatias funcionam da mesma forma para qualquer sequência, inclusive strings e tuplas:

s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP

Uma string não pode ser alterada por fatia — as strings são imutáveis, e a fatia cria uma nova string.

Ordenação de listas: sort e sorted

É aqui que os iniciantes mais se confundem. O método sort reorganiza os elementos dentro da própria lista e devolve None. A função sorted não mexe na lista original e devolve uma nova, já ordenada.

amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — nova cópia
print(amounts)             # [250, 1200, 99, 450] — a original permanece

result = amounts.sort()    # ordena no próprio lugar
print(result, amounts)     # None [99, 250, 450, 1200]

Daí o erro clássico «por que deu None»: a = a.sort() apaga a lista, atribuindo a ela o valor None. Escreva ou a.sort(), ou a = sorted(a).

Chave e ordem decrescente

Ambas as formas aceitam os parâmetros key e reverse. O key é uma função cujo resultado é usado na comparação dos elementos.

words = ["café", "Táxi", "assinatura"]
print(sorted(words, key=len))               # ['café', 'Táxi', 'assinatura']
print(sorted(words, key=str.lower))         # sem diferenciar maiúsculas
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("Alimentação", 650), ("Cinema", 120), ("Táxi", 300)]
expenses.sort(key=lambda e: e[1])           # pelo valor

A ordenação em Python é estável: elementos com a mesma chave mantêm a ordem original. Há ainda uma diferença de aplicação: sorted aceita qualquer sequência (string, dicionário, conjunto), enquanto sort existe apenas em listas.

Inverter uma lista

Três formas com comportamentos diferentes:

• a.reverse() — inverte no próprio lugar e devolve None;
• a[::-1] — nova lista invertida;
• reversed(a) — iterador preguiçoso, cômodo em laços: for x in reversed(a):.

Percorrer uma lista

items = ["café", "metrô", "cinema"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 café, 2 metrô, 3 cinema

print("cinema" in items)    # True — verificação de presença

Não remova elementos da lista que está sendo percorrida no laço — alguns elementos serão pulados. Monte uma nova lista com uma comprehension ou percorra uma cópia a[:].

List comprehension

A list comprehension cria uma nova lista em uma única linha: expressão, laço e, opcionalmente, uma condição.

squares = [n * n for n in range(6)]          # [0, 1, 4, 9, 16, 25]
big = [a for a in [250, 1200, 99] if a > 200]  # [250, 1200]
names = [s.strip().title() for s in [" ana ", "oscar"]]

As comprehensions costumam ser mais rápidas e legíveis que um laço com append. Mas se a lógica não cabe numa linha compreensível, um laço comum é melhor.

Unir, somar e subtrair listas

a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — nova lista
a += b             # o mesmo que a.extend(b)
print([*a, *b])    # desempacotamento em uma nova lista

Subtração de listas com o operador - não existe. Para tirar de uma lista os elementos de outra, use uma comprehension: [x for x in a if x not in set(b)]. A interseção de listas é mais fácil de achar com conjuntos: set(a) & set(b) (a ordem e as duplicatas se perdem nesse caso).

Listas aninhadas e bidimensionais

Uma lista de listas é uma forma simples de guardar uma tabela ou uma matriz:

matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # correto
bad = [[0] * 3] * 2                  # armadilha: duas referências para a mesma lista
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]

Desempacotamento de listas

first, second, third = [10, 20, 30]
head, *rest = [1, 2, 3, 4]      # head=1, rest=[2, 3, 4]
print(*["a", "b"], sep=", ")    # a, b — print de uma lista sem colchetes

Se o número de variáveis não bater com o tamanho da lista, surge ValueError — o asterisco resolve isso.

Cópia de lista

b = a não copia a lista: ela apenas cria um segundo rótulo para o mesmo objeto, e alterações feitas por b aparecem em a. Uma cópia independente é feita explicitamente: a.copy(), list(a) ou a[:]. Para dados aninhados isso não basta — as listas internas continuam compartilhadas, e é preciso copy.deepcopy(a).

import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — a lista interna é compartilhada
c = copy.deepcopy(a)     # cópia totalmente independente

Tuplas: lista imutável

A tupla (tuple) é parecida com a lista, mas não pode ser alterada depois de criada. Isso é um sinal claro para quem lê o código: diante dele está um registro de campos fixos, e não um conjunto que cresce. Tuplas se desempacotam facilmente, e é com elas que as funções devolvem vários valores.

expense = (250, "Café")
amount, item = expense
expense[0] = 300
# TypeError: 'tuple' object does not support item assignment

Uma tupla de valores imutáveis é hashable, por isso pode servir como chave de dicionário. Uma tupla com um único elemento escreve-se com vírgula: (5,).

Conjuntos: apenas valores únicos

O conjunto (set) guarda apenas valores únicos e não mantém a ordem. É a forma mais rápida de eliminar duplicatas e verificar «existe ou não» um elemento; além disso, sabe fazer interseção, união e diferença.

jan = {"Alimentação", "Táxi", "Cinema"}
feb = {"Alimentação", "Assinaturas"}
print(jan & feb)    # {'Alimentação'}
print(feb - jan)    # {'Assinaturas'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — sem repetições, ordem mantida
empty = set()       # {} — isto seria um dict vazio!

Qual coleção escolher

A verificação x in list percorre os elementos um a um, enquanto x in set funciona quase instantaneamente. Se dentro de um laço você verifica muitas vezes a presença em uma lista grande, transforme-a em conjunto.

Resumo

A python list é uma coleção ordenada e modificável: append e extend acrescentam, pop e remove removem, as fatias a[start:stop:step] pegam partes, sort ordena no próprio lugar e devolve None, e sorted devolve uma nova lista. Faça cópias explicitamente, use tupla para registros fixos e conjunto para valores únicos. Listas, tuplas, dicionários e conjuntos são praticados no curso «Python 3.15: do iniciante ao profissional».