# Listas em Python (list): métodos, fatias, ordenação, append, tuplas e conjuntos URL: https://skillaria.top/pt/guides/python/listas-python-list-metodos Lista em Python (list) é uma coleção ordenada e modificável de valores entre colchetes, por exemplo [250, 1200, 99]: é possível acrescentar elementos com append, inserir, remover, pegar fatias e ordenar. O método sort ordena a lista no próprio lugar e devolve None, enquanto a função sorted devolve uma nova lista ordenada. 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`. | Método | O que faz | | --- | --- | | `append(x)` | acrescenta x no fim | | `extend(iter)` | acrescenta todos os elementos de uma sequência | | `insert(i, x)` | insere x antes do índice i | | `remove(x)` | remove a primeira ocorrência de x (ValueError, se não houver) | | `pop(i=-1)` | remove e devolve o elemento do índice | | `index(x)` | índice da primeira ocorrência | | `count(x)` | quantas vezes x aparece | | `sort()` | ordena no próprio lugar | | `reverse()` | inverte no próprio lugar | | `copy()` | cópia rasa | | `clear()` | esvazia a lista | 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 | Tarefa | Coleção | | --- | --- | | Ordem e alterações | `list` | | Registro de campos fixos | `tuple` | | Busca por chave | `dict` | | Unicidade, verificação de presença | `set` | | Configurações imutáveis | `frozendict` (Python 3.15) | 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». ## FAQ **Qual a diferença entre lista e array em Python?** Um array no sentido de outras linguagens não existe como tipo embutido; seu papel é desempenhado pela lista, que pode guardar valores de tipos diferentes. Para arrays numéricos compactos existem o módulo array e a biblioteca NumPy. **Como encontrar o índice de um elemento na lista?** O método a.index(x) devolve o índice da primeira ocorrência e gera ValueError se o elemento não existir. Por isso, antes da chamada, convém verificar x in a. **Como remover duplicatas de uma lista mantendo a ordem?** Use list(dict.fromkeys(a)): o dicionário guarda as chaves sem repetição e na ordem de inserção. A variante list(set(a)) também remove repetições, mas não preserva a ordem. **Como juntar uma lista de strings em uma só?** Com o método join da string: ", ".join(["a", "b", "c"]) dá "a, b, c". Todos os elementos devem ser strings; números antes são convertidos com map(str, a). **Posso guardar tipos diferentes na mesma lista?** Sim, a lista pode conter números, strings, outras listas e objetos ao mesmo tempo. Mas ordenar essa lista sem o parâmetro key normalmente não é possível — comparar número com string gera TypeError. --- Source: Skillaria.Top (https://skillaria.top)