---
title: "Lista: O que É e Como Funciona | Python Brasil"
url: "https://python.dev.br/glossario/lista/"
markdown_url: "https://python.dev.br/glossario/lista.MD"
description: "Guia completo sobre listas em Python: criacao, metodos, fatiamento, list comprehension, ordenacao e boas praticas para manipular colecoes de dados."
date: "2025-06-10"
author: ""
---

# 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

```python
# 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

```python
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.

```python
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.

```python
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

```python
# 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

```python
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

```python
# 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.