Lista: O que É e Como Funciona | Python Brasil
Guia completo sobre listas em Python: criacao, metodos, fatiamento, list comprehension, ordenacao e boas praticas para manipular colecoes de dados.
O que e uma Lista?
Uma lista em Python e uma estrutura de dados mutavel e ordenada que armazena uma colecao de itens. Listas sao provavelmente a estrutura de dados mais utilizada na linguagem. Elas podem conter elementos de qualquer tipo — inteiros, strings, outras listas, objetos — e o tamanho pode crescer ou diminuir dinamicamente conforme necessario.
Listas sao representadas por colchetes [] e seus elementos sao separados por virgulas. Internamente, o CPython implementa listas como arrays dinamicos de ponteiros, o que torna o acesso por indice uma operacao de tempo constante O(1).
Como Criar Listas
# Formas de criar listas
frutas = ['maca', 'banana', 'laranja']
numeros = [1, 2, 3, 4, 5]
mista = [1, 'Python', 3.14, True, None]
aninhada = [[1, 2], [3, 4], [5, 6]]
# Lista vazia
vazia = []
vazia2 = list()
# A partir de outros iteraveis
from_string = list('Python') # ['P', 'y', 't', 'h', 'o', 'n']
from_range = list(range(5)) # [0, 1, 2, 3, 4]
from_tupla = list((10, 20, 30)) # [10, 20, 30]
# List comprehension
quadrados = [x ** 2 for x in range(10)]
pares = [x for x in range(20) if x % 2 == 0]
Indexacao e Fatiamento
letras = ['a', 'b', 'c', 'd', 'e', 'f']
# Indexacao
print(letras[0]) # 'a'
print(letras[-1]) # 'f'
print(letras[-2]) # 'e'
# Fatiamento
print(letras[1:4]) # ['b', 'c', 'd']
print(letras[:3]) # ['a', 'b', 'c']
print(letras[3:]) # ['d', 'e', 'f']
print(letras[::2]) # ['a', 'c', 'e']
print(letras[::-1]) # ['f', 'e', 'd', 'c', 'b', 'a']
# Fatiamento com atribuicao (listas sao mutaveis)
letras[1:3] = ['X', 'Y']
print(letras) # ['a', 'X', 'Y', 'd', 'e', 'f']
Metodos Principais
Diferente de tuplas, listas possuem metodos que modificam a colecao diretamente, ja que sao mutaveis.
numeros = [3, 1, 4, 1, 5, 9, 2, 6]
# Adicionar elementos
numeros.append(7) # adiciona ao final: [3, 1, 4, 1, 5, 9, 2, 6, 7]
numeros.insert(0, 0) # insere na posicao 0: [0, 3, 1, 4, ...]
numeros.extend([8, 10]) # adiciona varios ao final
# Remover elementos
numeros.remove(1) # remove a primeira ocorrencia de 1
ultimo = numeros.pop() # remove e retorna o ultimo elemento
primeiro = numeros.pop(0) # remove e retorna o elemento na posicao 0
numeros.clear() # remove todos os elementos
# Busca e contagem
frutas = ['maca', 'banana', 'maca', 'laranja']
print(frutas.count('maca')) # 2
print(frutas.index('banana')) # 1
print('uva' in frutas) # False
# Ordenacao
notas = [7.5, 9.0, 6.8, 8.3, 5.5]
notas.sort() # ordena no local (crescente)
notas.sort(reverse=True) # ordena no local (decrescente)
ordenada = sorted(notas) # retorna nova lista ordenada
# Ordenacao com chave personalizada
nomes = ['Ana', 'carlos', 'Beatriz']
nomes.sort(key=str.lower) # ordena ignorando maiusculas/minusculas
# Inverter
numeros = [1, 2, 3]
numeros.reverse() # inverte no local: [3, 2, 1]
Copias de Listas
Um erro muito comum e criar uma “copia” de lista por simples atribuicao. Isso cria apenas uma referencia ao mesmo objeto na memoria.
original = [1, 2, 3]
# Isso NAO cria uma copia
referencia = original
referencia.append(4)
print(original) # [1, 2, 3, 4] — a original tambem foi alterada!
# Copia rasa (shallow copy)
copia1 = original.copy()
copia2 = original[:]
copia3 = list(original)
# Copia profunda (deep copy) — para listas aninhadas
import copy
aninhada = [[1, 2], [3, 4]]
copia_profunda = copy.deepcopy(aninhada)
copia_profunda[0][0] = 99
print(aninhada) # [[1, 2], [3, 4]] — original preservada
Desempacotamento e Operacoes
# Desempacotamento
primeiro, segundo, terceiro = [10, 20, 30]
cabeca, *cauda = [1, 2, 3, 4, 5]
print(cabeca) # 1
print(cauda) # [2, 3, 4, 5]
# Concatenacao e repeticao
a = [1, 2, 3]
b = [4, 5, 6]
print(a + b) # [1, 2, 3, 4, 5, 6]
print(a * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
# Funcoes embutidas
numeros = [10, 5, 8, 3, 12]
print(len(numeros)) # 5
print(sum(numeros)) # 38
print(min(numeros)) # 3
print(max(numeros)) # 12
Iteracao sobre Listas
frutas = ['maca', 'banana', 'laranja']
# Loop simples
for fruta in frutas:
print(fruta)
# Com indice usando enumerate
for i, fruta in enumerate(frutas):
print(f'{i}: {fruta}')
# Iterando duas listas em paralelo
nomes = ['Ana', 'Bruno', 'Carla']
notas = [9.5, 7.8, 8.2]
for nome, nota in zip(nomes, notas):
print(f'{nome}: {nota}')
Listas como Pilhas e Filas
# Pilha (LIFO) — eficiente com listas
pilha = []
pilha.append('a')
pilha.append('b')
pilha.append('c')
print(pilha.pop()) # 'c'
# Fila (FIFO) — use deque para eficiencia
from collections import deque
fila = deque(['a', 'b', 'c'])
fila.append('d')
print(fila.popleft()) # 'a'
Erros Comuns
O primeiro e mais perigoso e usar uma lista mutavel como valor padrao de parametro de funcao: def func(itens=[]). O Python avalia o valor padrao apenas uma vez, e chamadas subsequentes compartilham a mesma lista. O correto e usar None como padrao e criar a lista dentro da funcao. O segundo erro e modificar uma lista durante a iteracao, o que pode pular elementos ou causar comportamentos inesperados. O terceiro e confundir append() (adiciona um elemento) com extend() (adiciona varios elementos de um iteravel).
Boas Praticas
Use list comprehension em vez de loops for com append() quando a logica for simples. Prefira sorted() quando precisar preservar a lista original. Para colecoes grandes que serao apenas iteradas, considere generators em vez de listas para economizar memoria. Use collections.deque se precisar de insercoes ou remocoes eficientes no inicio da lista.
Quando Usar
Listas sao ideais quando voce precisa de uma colecao ordenada e mutavel de elementos. Se a colecao nao deve ser alterada, prefira tuplas. Se precisa de busca rapida por valor, considere conjuntos. Se precisa associar chaves a valores, use dicionarios. A escolha correta da estrutura de dados e fundamental para escrever codigo eficiente e legivel.