Listas no Python

✅ Atualizado para Python 3.13 / 3.14 (2026) Conteúdo enriquecido com cópia vs. referência (alias), casos de uso reais, comparação com outras estruturas e quando usar listas vs tuplas.

Salve salve Pythonista!

Listas são a estrutura de dados mais versátil do Python! Mutáveis, dinâmicas e heterogêneas, são perfeitas para armazenar coleções de dados que precisam ser modificadas.

Neste guia completo, você vai aprender:

• ✅ Criação e operações básicas
• ✅ Métodos essenciais (append, extend, insert, remove)
• ✅ Casos de uso reais (filas, pilhas, processamento)
• ✅ Lista vs Tupla vs Array - quando usar cada uma

Se prepare que o post está C-O-M-P-L-E-T-O! Então já abre seu terminal e vamos nessa!

Ops, Fallout

O que é uma lista em Python? Uma lista (list) em Python é uma coleção ordenada e mutável de valores, escrita entre colchetes e separada por vírgulas - por exemplo ['Python', 'Academy', 2021]. Ela aceita itens de tipos diferentes, permite acesso por índice (começando em 0), pode crescer ou encolher em tempo de execução e é a estrutura de dados mais usada da linguagem.

Este é o guia-pilar de Listas da Python Academy. A partir daqui você se aprofunda nos posts dedicados de manipulação de listas (métodos), fatiamento (slicing) de listas e list comprehensions.

Vá Direto ao Assunto…

• Introdução
• Criando listas
• Acessando dados da lista
• Percorrendo listas
• Cópia vs. referência (alias)
• Métodos para manipulação de Listas
• Casos de Uso Reais
• Lista vs Tupla vs Array

Introdução

Uma Lista (list) em Python, nada mais é que uma coleção ordenada de valores, separados por vírgula e dentro de colchetes [].

Elas são utilizadas para armazenar diversos itens em uma única variável. Entender este conteúdo é de extrema importância para dominar a linguagem por completo!

Abaixo temos um exemplo de uma lista:

1
2
3
4

# Exemplo de lista:
lista = ['Python', 'Academy']

print(lista)

Saída do código acima:

1

['Python', 'Academy']

Podemos observar a classe de uma lista com type():

1
2
3

lista = []

print(type(lista))

Saída do código acima:

1

<class 'list'>

Criando listas

Existem várias maneiras de se criar uma lista.

A maneira mais simples é envolver os elementos da lista por colchetes, por exemplo:

1
2

# Lista com apenas um elemento
lista = ["PythonAcademy"]

Também podemos criar uma lista vazia:

1

lista = []

Para criar uma lista com diversos itens, podemos fazer:

1

lista = ['Python', 'Academy', 2021]

Para uma lista com um único elemento, basta usar os colchetes diretamente:

1

lista = ["Python Academy"]

A função list do próprio Python (built-in function) serve para converter outro iterável em lista - por exemplo, uma tupla ou uma string:

1

lista = list(('Python', 'Academy'))

Outra forma é criar listas resultantes de uma operação de List Comprehensions!

Não domina List Comprehensions? Então leia nosso guia completo de List Comprehensions no Python!

1

[item for item in iteravel]

Podemos ainda criar listas através da função range(), dessa forma:

1

list(range(10))

O que resultará em:

1

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Acessando dados da lista

Todos os itens de uma lista são indexados, ou seja para cada item da lista um índice é atribuído da seguinte forma: lista[indice].

Exemplo com itens:

1

frutas = ['Maça', 'Banana', 'Jaca', 'Melão', 'Abacaxi']

E assim ficaria a sequência de índices:

Em Python os índices são iniciados em 0.

Ou seja, como podemos acessar o primeiro item da lista que é o índice 0? Veja abaixo:

1

print(frutas[0])

A saída como previsível foi a string com a palavra Maça por ocupar o índice 0:

1

Maça

Agora vamos ver sobre Indexação Negativa!

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Agora que se inscreveu, podemos seguir!

Indexação negativa

E se o desejado for o último item?

Neste momento entramos no conceito de indexação negativa, que significa começar do fim.

-1 irá se referir ao último item. Por exemplo:

Dessa forma, para buscar pelo último item da lista:

1

print(frutas[-1])

Resultando em:

1

Abacaxi

Lista dentro de lista

Suponha que exista uma lista dentro de uma lista, assim:

1

lista = ['item1', ['python', 'Academy'], 'item3']

Como podemos acessar o primeiro índice do item que é uma lista?

A resposta é simples, basta selecionar a posição em que se localiza a lista para ter acesso a ela, assim:

1
2

sublista = lista[1]
print(sublista[0])

Ou ainda:

1

print(lista[1][0])

Ambos obtém mesmo resultado:

1

python

Repare que o print() exibe o valor da string sem aspas: as aspas só aparecem quando a string está dentro de uma estrutura, como ao imprimir a lista inteira.

Estou construindo o Ebookr.ai, uma plataforma onde você cria ebooks profissionais com IA sobre qualquer assunto - do zero ao PDF pronto, com capas e infográficos gerados automaticamente. Dá uma olhada!

Fatiando uma lista (slicing)

O fatiamento de listas, do inglês slicing, é a extração de um conjunto de elementos contidos numa lista. Ele é feito da seguinte forma:

1

lista[ inicio : fim : passo ]

Explicando cada elemento:

• início se refere ao índice de início do fatiamento.
• fim se refere ao índice final do fatiamento. A lista final não vai conter esse elemento.
• passo é um parâmetro opcional e é utilizado para se pular elementos da lista original

Vamos entender melhor em seguida!

Se quisermos criar uma fatia de uma lista do índice 2 ao 4, podemos fazer da seguinte forma:

1
2
3

lista = [10, 20, 30, 40, 50, 60]

print(lista[2:5])

O slicing conta a partir do índice 2 até o índice 5 (mas não o utiliza), pegando os índices 2, 3, 4.

Sua saída será:

1

[30, 40, 50]

O slicing tem ainda mais truques (passo negativo, inverter listas, copiar com lista[:]). Veja todos no nosso guia completo de fatiamento (slicing) de listas no Python.

Percorrendo listas

A forma mais comum de percorrer os elementos em uma lista é com um loop for elemento in lista, assim:

1
2
3
4

lista = [10, 20, 30, 40, 50, 60]

for num in lista:
    print(num)

Saída:

1
2
3
4
5
6

10
20
30
40
50
60

Com a função enumerate() podemos percorrer também o índice referente a cada valor da lista:

1
2
3
4

lista = [10, 20, 30, 40, 50, 60]

for indice, valor in enumerate(lista):
    print(f'índice={indice}, valor={valor}')

Sua saída será:

1
2
3
4
5
6

índice=0, valor=10
índice=1, valor=20
índice=2, valor=30
índice=3, valor=40
índice=4, valor=50
índice=5, valor=60

Cuidado com um antipadrão comum: você até veria a mesma saída escrevendo [print(num) for num in lista], mas não faça isso. Uma list comprehension existe para construir uma lista; ao usá-la só pelo efeito colateral do print, você cria e descarta uma lista inteira de None:

1
2
3
4

lista = [10, 20]
resultado = [print(num) for num in lista]

print(resultado)

Saída:

1
2
3

10
20
[None, None]

Para apenas percorrer e imprimir, prefira sempre o for normal - é mais legível e não desperdiça memória. Reserve as list comprehensions para quando o objetivo for de fato gerar uma nova lista.

Cópia vs. referência (alias)

Atribuir uma lista a outra variável não a copia. lista2 = lista1 cria um alias: os dois nomes apontam para o mesmo objeto na memória. Por isso, mutar um afeta o outro:

1
2
3
4
5
6
7
8

lista1 = [1, 2, 3]
lista2 = lista1          # alias: mesmo objeto, NÃO é cópia

lista2.append(4)

print('lista1:', lista1)
print('lista2:', lista2)
print('mesmo objeto?', lista1 is lista2)

Saída:

1
2
3

lista1: [1, 2, 3, 4]
lista2: [1, 2, 3, 4]
mesmo objeto? True

Repare: alteramos lista2, mas lista1 mudou junto. O operador is confirma que é o mesmo objeto.

Para obter uma cópia independente (uma cópia rasa, ou shallow copy), use .copy(), list(lista) ou o slicing lista[:]:

1
2
3
4
5
6
7
8

lista1 = [1, 2, 3]
copia = lista1.copy()    # ou list(lista1), ou lista1[:]

copia.append(4)

print('lista1:', lista1)
print('copia:', copia)
print('mesmo objeto?', lista1 is copia)

Saída:

1
2
3

lista1: [1, 2, 3]
copia: [1, 2, 3, 4]
mesmo objeto? False

Cuidado com listas aninhadas. Uma cópia rasa copia só o nível externo: as sublistas continuam compartilhadas entre original e cópia. Para uma cópia totalmente independente, use copy.deepcopy():

1
2
3
4
5
6
7
8
9
10
11
12

import copy

original = [[1, 2], [3, 4]]

rasa = original.copy()        # cópia rasa: sublistas compartilhadas
rasa[0].append(99)
print('apos copy() rasa:', original)

original = [[1, 2], [3, 4]]
profunda = copy.deepcopy(original)   # cópia profunda: tudo independente
profunda[0].append(99)
print('apos deepcopy():', original)

Saída:

1
2

apos copy() rasa: [[1, 2, 99], [3, 4]]
apos deepcopy(): [[1, 2], [3, 4]]

Ou seja: na cópia rasa, mexer na sublista vazou para o original; com deepcopy(), o original ficou intacto.

Métodos para manipulação de Listas

As listas têm métodos próprios para adicionar, remover e reordenar elementos. A tabela abaixo resume os mais usados no dia a dia:

Cada um desses métodos tem detalhes importantes (complexidade, cópia vs. ordenação in-place, key/reverse no sort). Aprofundamos todos eles no nosso guia dedicado de manipulação de listas no Python.

Casos de Uso Reais

1. Implementar Fila (FIFO)

1
2
3
4
5
6
7
8
9
10
11
12

# Fila: First In, First Out
fila_atendimento = []

# Adicionar pessoas na fila
fila_atendimento.append('Alice')
fila_atendimento.append('Bob')
fila_atendimento.append('Charlie')

# Atender (remover do início)
atendido = fila_atendimento.pop(0)  # 'Alice'
print(f"Atendendo: {atendido}")
print(f"Fila atual: {fila_atendimento}")  # ['Bob', 'Charlie']

2. Implementar Pilha (LIFO)

1
2
3
4
5
6
7
8
9
10
11
12

# Pilha: Last In, First Out
pilha_pratos = []

# Empilhar pratos
pilha_pratos.append('Prato 1')
pilha_pratos.append('Prato 2')
pilha_pratos.append('Prato 3')

# Desempilhar (remover do final)
prato = pilha_pratos.pop()  # 'Prato 3'
print(f"Prato retirado: {prato}")
print(f"Pilha: {pilha_pratos}")  # ['Prato 1', 'Prato 2']

3. Processar Dados em Lote

1
2
3
4
5
6
7
8

# Processar IDs de usuários em lotes de 100
user_ids = list(range(1, 1001))  # 1000 usuários

batch_size = 100
for i in range(0, len(user_ids), batch_size):
    batch = user_ids[i:i + batch_size]
    print(f"Processando lote {i//batch_size + 1}: {len(batch)} usuários")
    # process_users(batch)  # Função de processamento

4. Manter Histórico (limitado)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# Histórico de comandos (máximo 5)
history = []
MAX_HISTORY = 5

def add_command(cmd):
    history.append(cmd)
    if len(history) > MAX_HISTORY:
        history.pop(0)  # Remove o mais antigo

add_command('ls')
add_command('cd /home')
add_command('pwd')
add_command('mkdir test')
add_command('rm test')
add_command('cat file.txt')  # Remove 'ls'

print(history)  # [últimos 5 comandos]

Lista vs Tupla vs Array

Comparação Rápida

Quando Usar Cada Uma?

✅ Use Lista quando:

• Precisa modificar dados (adicionar/remover)
• Coleção dinâmica (tamanho varia)
• Tipos mistos (strings, ints, objetos)
• Operações gerais de programação

1
2
3

# Lista: flexível e mutável
tasks = ['estudar', 'codar', 'testar']
tasks.append('deploy')  # ✅ Pode modificar

✅ Use Tupla quando:

• Dados imutáveis (não mudam)
• Chaves de dicionário (precisam ser hasheáveis)
• Retornar múltiplos valores de função
• Coordenadas, configs, constantes

1
2
3

# Tupla: imutável e mais rápida
position = (10, 20)  # Coordenada (x, y)
# position[0] = 15  # ❌ Erro! Imutável

✅ Use Array (numpy) quando:

• Cálculos numéricos intensivos
• Todos elementos mesmo tipo
• Operações matemáticas (vetorização)
• Data Science, Machine Learning

1
2
3
4
5

import numpy as np

# Array: otimizado para números
temperatures = np.array([25.5, 26.0, 24.8, 27.2])
mean_temp = temperatures.mean()  # Operações rápidas

Conclusão

Neste guia completo sobre Listas, você aprendeu:

✅ Operações básicas - Criar, acessar, modificar ✅ Métodos essenciais - append, extend, insert, remove, pop ✅ Casos de uso reais - Filas, pilhas, processamento em lote ✅ Lista vs Tupla vs Array - Quando usar cada uma

Principais lições:

• Listas são mutáveis e versáteis
• Use tuplas para dados imutáveis
• Use numpy arrays para cálculos numéricos
• .append() adiciona no final (O(1))
• .pop(0) remove do início (O(n) - use deque se fizer muito)

Continue pela trilha de listas:

• Domine todos os métodos de manipulação de listas (append, sort, remove e cia.)
• Aprofunde o fatiamento (slicing) de listas com passo e índices negativos
• Pratique list comprehensions para gerar listas de forma mais Pythônica
• Explore collections.deque para filas eficientes

Dominá-las é muito importante e ajuda muito no dia a dia do desenvolvedor Python!

Nos vemos no próximo post, dev!

Por Erickson Lopes em 14/06/2021

O infinito é o limite

Bora se conectar no LinkedIn! ericksonlopes

Minhas redes: