---
title: "Listas em Python: Guia Completo com Exemplos"
url: "https://python.dev.br/algoritmos/listas-python/"
markdown_url: "https://python.dev.br/algoritmos/listas-python.MD"
description: "Aprenda tudo sobre listas em Python. Metodos, slicing, list comprehension, listas aninhadas, performance e quando usar listas vs outras estruturas de dados."
date: "2026-04-27"
author: "Equipe Python Brasil"
---

# Listas em Python: Guia Completo com Exemplos

Aprenda tudo sobre listas em Python. Metodos, slicing, list comprehension, listas aninhadas, performance e quando usar listas vs outras estruturas de dados.


## O que sao Listas em Python?

Listas sao a estrutura de dados mais utilizada em Python. Elas armazenam colecoes ordenadas de elementos que podem ser modificados apos a criacao — ou seja, sao **mutaveis**. Listas permitem duplicatas, suportam diferentes tipos de dados no mesmo container e oferecem dezenas de metodos para manipulacao.

Se voce esta comecando com Python, dominar listas e essencial antes de avancar para estruturas mais complexas como [dicionarios](/algoritmos/dicionarios-python/) e [pilhas e filas](/algoritmos/pilhas-filas-python/). Confira nosso guia [Como Comecar com Python](/blog/como-comecar-com-python/) para uma introducao a linguagem.

---

## Criando Listas

Existem varias formas de criar listas em Python:

```python
# Lista vazia
lista_vazia = []
lista_vazia2 = list()

# Lista com elementos
frutas = ["maca", "banana", "laranja"]
numeros = [1, 2, 3, 4, 5]

# Lista com tipos mistos
misturada = [42, "texto", 3.14, True, None]

# Lista a partir de range
sequencia = list(range(1, 11))  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Lista a partir de string
caracteres = list("Python")  # ['P', 'y', 't', 'h', 'o', 'n']
```

Listas sao delimitadas por colchetes `[]` e os elementos sao separados por virgulas. A funcao `list()` converte outros iteraveis (strings, tuplas, ranges) em listas.

---

## Acessando Elementos: Indexacao e Slicing

Python usa indexacao baseada em zero. O primeiro elemento esta no indice 0:

```python
frutas = ["maca", "banana", "laranja", "uva", "manga"]

# Indexacao positiva
print(frutas[0])   # "maca"
print(frutas[2])   # "laranja"

# Indexacao negativa (conta do final)
print(frutas[-1])  # "manga"
print(frutas[-2])  # "uva"
```

### Slicing (Fatiamento)

Slicing permite extrair sublistas usando a sintaxe `lista[inicio:fim:passo]`:

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

# Primeiros 5 elementos
print(numeros[:5])     # [0, 1, 2, 3, 4]

# Do indice 3 ao 7
print(numeros[3:8])    # [3, 4, 5, 6, 7]

# Ultimos 3 elementos
print(numeros[-3:])    # [7, 8, 9]

# Passo de 2 (pula elementos)
print(numeros[::2])    # [0, 2, 4, 6, 8]

# Reverter a lista
print(numeros[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# Copiar a lista
copia = numeros[:]
```

Slicing sempre retorna uma nova lista, nunca modifica a original. Para mais sobre manipulacao de dados, veja nosso guia sobre [estruturas de dados em Python](/blog/estruturas-de-dados-python/).

---

## Metodos Essenciais de Listas

Python oferece metodos embutidos para manipular listas. Aqui estao os mais importantes:

### Adicionando Elementos

```python
frutas = ["maca", "banana"]

# Adicionar ao final — O(1) amortizado
frutas.append("laranja")
# ["maca", "banana", "laranja"]

# Inserir em posicao especifica — O(n)
frutas.insert(1, "manga")
# ["maca", "manga", "banana", "laranja"]

# Adicionar multiplos elementos — O(k)
frutas.extend(["uva", "pera"])
# ["maca", "manga", "banana", "laranja", "uva", "pera"]
```

### Removendo Elementos

```python
frutas = ["maca", "banana", "laranja", "banana", "uva"]

# Remover por valor (primeira ocorrencia) — O(n)
frutas.remove("banana")
# ["maca", "laranja", "banana", "uva"]

# Remover por indice e retornar — O(n) ou O(1) para o final
ultimo = frutas.pop()       # Remove e retorna "uva"
segundo = frutas.pop(1)     # Remove e retorna "laranja"

# Remover por indice sem retornar
del frutas[0]

# Limpar toda a lista
frutas.clear()
```

### Ordenacao e Busca

```python
numeros = [3, 1, 4, 1, 5, 9, 2, 6]

# Ordenar in-place — O(n log n)
numeros.sort()
# [1, 1, 2, 3, 4, 5, 6, 9]

# Ordenar em ordem decrescente
numeros.sort(reverse=True)
# [9, 6, 5, 4, 3, 2, 1, 1]

# Reverter a lista — O(n)
numeros.reverse()

# Contar ocorrencias — O(n)
print(numeros.count(1))  # 2

# Encontrar indice — O(n)
print(numeros.index(5))  # Retorna o indice do primeiro 5
```

Para uma analise mais aprofundada de algoritmos de ordenacao, confira nosso guia sobre [ordenacao em Python](/algoritmos/ordenacao-python/).

---

## List Comprehension

List comprehension e uma forma concisa e Pythonica de criar listas. E mais rapida que loops tradicionais e muito usada no dia a dia:

```python
# Forma tradicional
quadrados = []
for x in range(10):
    quadrados.append(x ** 2)

# Com list comprehension
quadrados = [x ** 2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Com condicao (filtro)
pares = [x for x in range(20) if x % 2 == 0]
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# Com transformacao e filtro
nomes = ["ana", "CARLOS", "maria", "PEDRO"]
minusculos = [nome.lower() for nome in nomes if len(nome) > 3]
# ["carlos", "maria", "pedro"]

# Comprehension aninhada (matriz para lista plana)
matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
plana = [num for linha in matriz for num in linha]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
```

List comprehension e um dos recursos mais poderosos de Python. Para mais detalhes, leia nosso artigo sobre [compreensao de listas](/blog/compreensao-de-listas-python/).

---

## Listas Aninhadas (Matrizes)

Listas podem conter outras listas, criando estruturas multidimensionais:

```python
# Matriz 3x3
matriz = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Acessar elemento: linha 1, coluna 2
print(matriz[1][2])  # 6

# Percorrer toda a matriz
for i, linha in enumerate(matriz):
    for j, valor in enumerate(linha):
        print(f"matriz[{i}][{j}] = {valor}")

# Criar matriz com list comprehension
zeros = [[0] * 4 for _ in range(3)]
# [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
```

> **Cuidado**: Nao use `[[0] * 4] * 3` — isso cria 3 referencias para a mesma lista interna. Use list comprehension para criar listas independentes.

Para trabalhar com matrizes numericas de forma eficiente, considere usar [NumPy](/glossario/numpy/), que oferece arrays multidimensionais otimizados.

---

## Performance: Complexidade de Operacoes

Entender a performance de cada operacao e fundamental para escrever codigo eficiente. A tabela abaixo mostra a complexidade Big O das operacoes mais comuns:

| Operacao | Complexidade | Exemplo |
|---|---|---|
| Acesso por indice | O(1) | `lista[i]` |
| Append | O(1) amortizado | `lista.append(x)` |
| Pop do final | O(1) | `lista.pop()` |
| Pop do inicio | O(n) | `lista.pop(0)` |
| Insert no inicio | O(n) | `lista.insert(0, x)` |
| Insert no meio | O(n) | `lista.insert(i, x)` |
| Busca (in) | O(n) | `x in lista` |
| Remove | O(n) | `lista.remove(x)` |
| Sort | O(n log n) | `lista.sort()` |
| Len | O(1) | `len(lista)` |
| Slice | O(k) | `lista[a:b]` |
| Extend | O(k) | `lista.extend(outra)` |

### Quando Nao Usar Listas

Listas nao sao a melhor escolha para todos os cenarios:

- **Insercoes/remocoes frequentes no inicio**: Use `collections.deque` — veja [pilhas e filas](/algoritmos/pilhas-filas-python/)
- **Busca frequente por valor**: Use `set` ou `dict` para buscas O(1) — veja [dicionarios](/algoritmos/dicionarios-python/)
- **Dados imutaveis**: Use tuplas para dados que nao mudam
- **Calculos numericos pesados**: Use [NumPy](/glossario/numpy/) arrays

Para mais sobre [estruturas de dados em Python](/blog/estruturas-de-dados-python/) e como escolher a mais adequada para cada caso.

---

## Funcoes Uteis com Listas

Python oferece funcoes embutidas que trabalham muito bem com listas:

```python
numeros = [3, 1, 4, 1, 5, 9, 2, 6]

# Funcoes basicas
print(len(numeros))    # 8
print(sum(numeros))    # 31
print(min(numeros))    # 1
print(max(numeros))    # 9

# Sorted (retorna nova lista, nao altera a original)
ordenada = sorted(numeros)
# [1, 1, 2, 3, 4, 5, 6, 9]

# Enumerate (indice + valor)
for i, num in enumerate(numeros):
    print(f"Indice {i}: {num}")

# Zip (combinar listas)
nomes = ["Ana", "Carlos", "Maria"]
idades = [25, 30, 28]
for nome, idade in zip(nomes, idades):
    print(f"{nome} tem {idade} anos")

# Map e Filter
dobros = list(map(lambda x: x * 2, numeros))
grandes = list(filter(lambda x: x > 4, numeros))

# Any e All
print(any(x > 8 for x in numeros))  # True (9 > 8)
print(all(x > 0 for x in numeros))  # True (todos positivos)
```

Para entender melhor funcoes [lambda](/glossario/lambda/) e programacao funcional, consulte nosso glossario.

---

## Boas Praticas com Listas

1. **Prefira list comprehension** a loops com append — e mais rapido e legivel
2. **Use `enumerate()`** em vez de `range(len(lista))` para iterar com indice
3. **Evite modificar lista durante iteracao** — crie uma nova lista ou itere sobre uma copia
4. **Use unpacking** para extrair valores: `primeiro, *resto = lista`
5. **Use `deque`** quando precisar de insercoes/remocoes em ambas as pontas

```python
# Evite isso
for i in range(len(lista)):
    print(lista[i])

# Faca isso
for item in lista:
    print(item)

# Ou com indice
for i, item in enumerate(lista):
    print(i, item)
```

Para mais sobre boas praticas em Python, leia nosso artigo sobre [boas praticas Python em 2026](/blog/boas-praticas-python-2026/).

---

## Conclusao

Listas sao a base de qualquer programa Python. Dominar seus metodos, entender sua performance e saber quando usar alternativas como tuplas, sets ou deque e essencial para escrever codigo eficiente e profissional.

Continue aprendendo sobre estruturas de dados e algoritmos com nossos outros guias: [dicionarios](/algoritmos/dicionarios-python/), [ordenacao](/algoritmos/ordenacao-python/), [busca binaria](/algoritmos/busca-binaria-python/) e [pilhas e filas](/algoritmos/pilhas-filas-python/).

Se voce esta construindo uma carreira com Python, confira tambem nossas [vagas Python atualizadas](/vagas/) e o guia de [salarios Python no Brasil](/carreira/salarios-python-brasil/).

<p>Se voce gosta de Python, explore tambem nossos sites irmãos sobre outras linguagens de programacao: <a href="https://golang.com.br" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', { destination: 'golang.com.br' })">Go</a>, <a href="https://rustlang.com.br" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', { destination: 'rustlang.com.br' })">Rust</a> e <a href="https://kotlin.dev.br" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', { destination: 'kotlin.dev.br' })">Kotlin</a>.</p>
