Listas no Python

✅ Atualizado para Python 3.13 (Dezembro 2025)
Conteúdo enriquecido com 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

Vá Direto ao Assunto…

• Introdução
• Criando listas
• Acessando dados da lista
• Percorrendo listas
• 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ído 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]

Também podemos utilizar a função list do próprio Python (built-in function):

1

lista = list(["Python Academy"])

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

List Comprehensions Não domina List Comprehensions? Então já clica aqui para ler nosso post completo sobre esse assunto!

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'

Estou construindo o DevBook, uma plataforma que usa IA para criar ebooks técnicos — com código formatado e exportação em PDF. Depois de ler, dá uma passada lá!

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]

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

Que tal poupar algumas linhas e obter o mesmo resultado com List Comprehension?

1
2
3
4

[print(num) for num in lista]

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

A saída será a mesma!

Métodos para manipulação de Listas

O Python tem vários métodos disponíveis em listas que nos permite manipulá-las.

Separamos esse conteúdo em outro post que você pode acessar agora clicando aqui!

Conclusão

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)

Próximos passos:

• Pratique list comprehensions (mais Pythônico!)
• Explore collections.deque para filas eficientes
• Aprenda slicing avançado
• Estude manipulação de listas com Pandas

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: