Listas em Python: Guia Completo com Métodos e Exercícios

✅ Artigo atualizado em Setembro 2026 Nova tabela completa de métodos (retorno e se altera a lista), seções sobre os comandos append, insert, remove e pop, ordenação e lista de dicionários, erros comuns com traceback e 8 exercícios resolvidos.

1
2
3
4
5

frutas = ['maçã', 'banana', 'uva']
frutas.append('manga')      # adiciona no final
print(frutas[0])            # maçã
print(frutas[-1])           # manga
print(len(frutas))          # 4

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, pop, sort) e o que cada um retorna
• ✅ Casos de uso reais (filas, pilhas, processamento)
• ✅ Lista vs Tupla vs Array - quando usar cada uma
• ✅ Erros comuns e exercícios resolvidos (inclusive no formato de questão de prova)

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. A referência oficial é o capítulo de estruturas de dados do tutorial do Python.

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
• Comandos de lista em Python: append, insert, remove e pop
• Como ordenar uma lista em Python
• Casos de Uso Reais
• Lista de dicionários em Python
• Lista vs Tupla vs Array
• Erros comuns
• Exercícios resolvidos

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]

Repare que o 10 não entra: o valor final do range() é sempre exclusivo. Os detalhes (início, fim e passo) estão no post sobre a função range() do Python.

Mais dois atalhos úteis para criar listas: repetir um valor com * e quebrar uma string em palavras com split():

1
2
3
4
5

zeros = [0] * 5
print(zeros)            # [0, 0, 0, 0, 0]

palavras = 'python academy blog'.split()
print(palavras)         # ['python', 'academy', 'blog']

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

Como o primeiro índice é 0, o último índice válido é sempre len(lista) - 1. Nesta lista de 5 frutas, os índices vão de 0 a 4, e frutas[5] gera IndexError (veja em Erros comuns).

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

Também dá para percorrer a lista com while, controlando o índice na mão. É o formato que mais aparece em exercícios de faculdade, com a condição i < len(lista):

1
2
3
4
5
6

lista = [10, 20, 30]
i = 0

while i < len(lista):
    print(i, lista[i])
    i += 1

Saída:

1
2
3

0 10
1 20
2 30

Por que i < len(lista) e não i <= len(lista)? Porque os índices vão de 0 a len(lista) - 1: com <=, a última volta tentaria ler lista[3] e quebraria com IndexError. Na prática, prefira o for (com enumerate() quando precisar do índice); o while e o for i in range(len(lista)) são mais verbosos. Veja todas as formas de laço no post sobre estruturas de repetição (for e while) no Python.

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, buscar e reordenar elementos. A tabela abaixo reúne os 11 métodos de lista, o que cada um retorna e se ele altera a lista original (os exemplos partem sempre de l = ['a', 'b', 'c']):

Repare na coluna “Retorna”: quase todo método que altera a lista devolve None. A exceção é o pop(), que devolve o item removido:

1
2
3
4
5
6
7

l = ['a', 'b', 'c']

print(l.append('d'))   # None: o append altera a lista, não devolve nada
print(l)               # ['a', 'b', 'c', 'd']
print(l.pop())         # d
print(l.index('b'))    # 1
print(l.count('a'))    # 1

A lista oficial de métodos, com a assinatura de cada um, está na documentação do Python sobre listas.

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.

Comandos de lista em Python: append, insert, remove e pop

Esses quatro comandos são os que mais caem em prova (em especial nas questões de “associe a coluna A à coluna B”) e os que você mais vai usar no dia a dia:

• append(x): adiciona x ao final da lista.
• insert(i, x): insere x na posição i, empurrando os itens seguintes para a direita.
• remove(x): remove a primeira ocorrência do valor x.
• pop(i): remove o item do índice i e devolve esse item; sem argumento, remove e devolve o último.

Veja os quatro em ação, na ordem:

1
2
3
4
5
6
7
8
9

tarefas = ['estudar', 'codar']

tarefas.append('testar')        # ['estudar', 'codar', 'testar']
tarefas.insert(0, 'planejar')   # ['planejar', 'estudar', 'codar', 'testar']
tarefas.remove('codar')         # ['planejar', 'estudar', 'testar']
ultima = tarefas.pop()          # remove e devolve 'testar'

print(tarefas)
print(ultima)

Saída:

1
2

['planejar', 'estudar']
testar

A confusão mais comum é entre remove e pop: remove recebe o valor e não devolve nada; pop recebe o índice e devolve o item removido.

Como remover um item de uma lista

Existem quatro formas de remover itens, e a escolha depende do que você tem em mãos (o valor ou a posição) e se vai usar o item removido:

O remove() só apaga a primeira ocorrência. Para tirar todas, gere uma nova lista filtrando o valor:

1
2
3

lista = ['a', 'b', 'c', 'b']
sem_b = [x for x in lista if x != 'b']
print(sem_b)   # ['a', 'c']

Como ordenar uma lista em Python

Há duas formas de ordenar: o método lista.sort(), que altera a própria lista, e a função sorted(lista), que devolve uma nova lista e deixa a original intacta. As duas aceitam reverse=True (ordem decrescente) e key (critério de ordenação):

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

numeros = [5, 2, 9, 1]

ordenada = sorted(numeros)    # nova lista
print(ordenada)               # [1, 2, 5, 9]
print(numeros)                # [5, 2, 9, 1] (não mudou)

numeros.sort(reverse=True)    # altera numeros e retorna None
print(numeros)                # [9, 5, 2, 1]

nomes = ['Bernardo', 'Ana', 'Caio']
nomes.sort(key=len)           # ordena pelo tamanho do nome
print(nomes)                  # ['Ana', 'Caio', 'Bernardo']

Dois cuidados: nunca escreva lista = lista.sort() (a variável vira None, veja em Erros comuns) e não misture tipos que não se comparam, como números e strings - [3, 'a', 1].sort() gera TypeError: '<' not supported between instances of 'str' and 'int'.

Antes de ver esses casos de uso, vale reforçar: entender listas de verdade é dominar boa parte da base de Python - e essa base, construída com projetos guiados, é o que ensinamos na Jornada Python:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

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)  # ['cd /home', 'pwd', 'mkdir test', 'rm test', 'cat file.txt']

Lista de dicionários em Python

Uma lista de dicionários é o formato mais comum para guardar vários registros com os mesmos campos - alunos, produtos, pedidos, linhas de um JSON. Cada item da lista é um dicionário, e você combina o índice da lista com a chave do dicionário:

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

alunos = [
    {'nome': 'Ana', 'nota': 8.5},
    {'nome': 'Bruno', 'nota': 6.0},
    {'nome': 'Carla', 'nota': 9.2},
]

for aluno in alunos:
    print(f"{aluno['nome']}: {aluno['nota']}")

aprovados = [a['nome'] for a in alunos if a['nota'] >= 7]
print(aprovados)

melhor = max(alunos, key=lambda a: a['nota'])
print(melhor['nome'])

Saída:

1
2
3
4
5

Ana: 8.5
Bruno: 6.0
Carla: 9.2
['Ana', 'Carla']
Carla

Para acessar um campo direto, use os dois índices em sequência: alunos[0]['nome'] devolve 'Ana'. Se os dicionários ainda são novidade, leia o guia de dicionários no Python; o key=lambda ... é explicado no post sobre funções lambda.

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

Erros comuns

Estes são os erros que mais aparecem com listas, com a mensagem real que o Python mostra (ou o resultado errado, quando o bug é silencioso).

Acessar um índice que não existe (IndexError)

1
2

frutas = ['maçã', 'banana', 'uva']
print(frutas[3])

1

IndexError: list index out of range

A lista tem 3 itens, então os índices vão de 0 a 2. Correção: use frutas[2] ou, para o último item sem se preocupar com o tamanho, frutas[-1].

Atribuir o resultado do sort() (lista = lista.sort())

1
2
3
4

numeros = [3, 1, 2]
numeros = numeros.sort()
print(numeros)
print(numeros[0])

O primeiro print() mostra None, e o segundo quebra com:

1

TypeError: 'NoneType' object is not subscriptable

O sort() ordena a lista no lugar e retorna None, e a atribuição joga a lista fora. Correção: chame só numeros.sort(), sem atribuir, ou use numeros = sorted(numeros). O mesmo vale para append(), reverse() e os demais métodos que retornam None.

Achar que b = a copia a lista (bug silencioso)

1
2
3
4

original = [1, 2, 3]
backup = original
original.append(4)
print(backup)

1

[1, 2, 3, 4]

Não há erro, mas o “backup” mudou junto, porque os dois nomes apontam para a mesma lista. Correção: backup = original.copy() (ou copy.deepcopy() se houver listas aninhadas), como explicado na seção de cópia vs. referência acima.

Remover itens da lista durante o for (bug silencioso)

1
2
3
4
5

numeros = [1, 2, 2, 3, 4]
for n in numeros:
    if n % 2 == 0:
        numeros.remove(n)
print(numeros)

1

[1, 2, 3]

A ideia era remover todos os pares, mas um 2 sobrou. Ao remover um item, os seguintes andam uma posição para trás e o for pula o próximo. Correção: crie uma nova lista com numeros = [n for n in numeros if n % 2 != 0] (resultado [1, 3]) ou percorra uma cópia com for n in numeros[:]:.

Remover um valor que não está na lista (ValueError)

1
2

cores = ['azul', 'verde']
cores.remove('vermelho')

1

ValueError: list.remove(x): x not in list

Correção: confira antes com in - if 'vermelho' in cores: cores.remove('vermelho'). O index() tem o mesmo comportamento e gera ValueError: 'vermelho' is not in list.

Exercícios resolvidos

Tente resolver cada exercício antes de abrir a solução. Todos os códigos foram executados e as saídas conferidas.

Exercício 1. Crie a lista ['segunda', 'terça', 'quarta', 'quinta', 'sexta'] e imprima o primeiro dia, o último dia e a quantidade de dias.

1
2
3
4

dias = ['segunda', 'terça', 'quarta', 'quinta', 'sexta']
print(dias[0])
print(dias[-1])
print(len(dias))

Exercício 2 (questão de prova). Pensando na manipulação de listas, observe os comandos da coluna A e associe-os às funções da coluna B.

Assinale a alternativa que apresenta a sequência correta da coluna B, de cima para baixo:

a) 4, 1, 2, 3
b) 1, 4, 3, 2
c) 4, 2, 1, 3
d) 2, 1, 4, 3

1
2
3
4
5
6

lista = ['a', 'b', 'c']
lista.append('d')        # 1: adiciona no final
lista.insert(1, 'X')     # 3: insere na posição 1
lista.remove('b')        # 2: remove o valor 'b'
item = lista.pop()       # 4: remove e retorna o último
print(lista, item)

Exercício 3 (questão de prova). Qual é a saída do código abaixo?

1
2

numeros = [10, 20, 30, 40, 50]
print(numeros[1:4])

a) [10, 20, 30, 40]
b) [20, 30, 40]
c) [20, 30, 40, 50]
d) [10, 20, 30]

Exercício 4. Dada a lista de notas [7.5, 8.0, 6.5, 9.0], calcule a média e conte quantas notas ficaram acima dela.

1
2
3
4
5
6
7
8
9
10

notas = [7.5, 8.0, 6.5, 9.0]
media = sum(notas) / len(notas)

acima = 0
for nota in notas:
    if nota > media:
        acima += 1

print(f'Média: {media:.2f}')
print(f'Acima da média: {acima}')

Exercício 5. Usando for, range() e append(), monte uma lista com os números pares de 1 a 10.

1
2
3
4
5
6

pares = []
for n in range(1, 11):
    if n % 2 == 0:
        pares.append(n)

print(pares)

Exercício 6 (questão de prova). O que o código abaixo imprime?

1
2
3
4

a = [1, 2, 3]
b = a
b.append(4)
print(a)

a) [1, 2, 3]
b) [1, 2, 3, 4]
c) [4]
d) Gera um erro

Exercício 7. Remova os itens repetidos de ['python', 'java', 'python', 'go', 'java'], mantendo a ordem da primeira aparição.

1
2
3
4
5
6
7

linguagens = ['python', 'java', 'python', 'go', 'java']
unicas = []
for item in linguagens:
    if item not in unicas:
        unicas.append(item)

print(unicas)

Exercício 8. Sem usar max(), encontre o maior valor de [12, 45, 7, 45, 30] e a posição da primeira vez em que ele aparece.

1
2
3
4
5
6
7
8
9
10

valores = [12, 45, 7, 45, 30]
maior = valores[0]
posicao = 0

for i, v in enumerate(valores):
    if v > maior:
        maior = v
        posicao = i

print(f'Maior: {maior} na posição {posicao}')

Quer praticar listas, dicionários e o resto da base da linguagem construindo projetos guiados? Conheça a Jornada Python, nosso curso de Python completo.

Conclusão

Neste guia completo sobre Listas, você aprendeu:

✅ Operações básicas - Criar, acessar, modificar
✅ Métodos essenciais - append, extend, insert, remove, pop, sort (e o que cada um retorna)
✅ Casos de uso reais - Filas, pilhas, processamento em lote, lista de dicionários
✅ Lista vs Tupla vs Array - Quando usar cada uma
✅ Erros comuns - IndexError, lista = lista.sort(), cópia por referência e remoção durante o for

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:

• 
•