Manipulação de Listas no Python: operações práticas com exemplos

✅ Artigo atualizado em Setembro 2026 Nova tabela de comandos por tarefa, seções sobre ordenar com key, juntar, dividir e achatar listas, erros comuns com traceback e 8 exercícios resolvidos (inclusive questões de prova).

1
2
3
4
5
6

nums = [3, 1, 2, 3]
print(sorted(nums))                # [1, 2, 3, 3]  ordenar
print(nums.count(3))               # 2  contar
print(nums[::-1])                  # [3, 2, 1, 3]  inverter
print(list(dict.fromkeys(nums)))   # [3, 1, 2]  remover duplicatas
print(max(nums), min(nums), sum(nums))  # 3 1 9

Olá Pythonista!

Este é o post de operações práticas com listas: ordenar (e com qual critério), buscar, remover duplicatas, juntar, dividir em pedaços, achatar, filtrar, copiar e tirar maior, menor e soma.

Se você ainda está começando, leia antes o nosso guia de Listas em Python (criação, índices e métodos básicos). Aqui partimos do princípio de que você já sabe criar uma lista e acessar seus itens pelo índice.

A referência oficial de todos os métodos está no capítulo de estruturas de dados do tutorial do Python.

Vá Direto ao Assunto…

• Lista de comandos Python para manipular listas
• Métodos para manipulação de Listas
• Keywords de manipulação de Listas
• Como ordenar uma lista em Python com key e reverse
• Como juntar, dividir e achatar listas em Python
• Casos Práticos Combinados
• Performance dos Métodos
• Erros comuns
• Exercícios resolvidos

Lista de comandos Python para manipular listas

Antes dos detalhes, a tabela abaixo responde à pergunta “qual comando eu uso para…?”. Todos os exemplos partem de l = [3, 1, 2, 3] e foram executados no Python 3.

Regra prática: método que altera a lista (sort, reverse, extend, append…) retorna None; função ou operador (sorted, +, fatiamento, max…) devolve um valor novo e não mexe na original.

Métodos para manipulação de Listas

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

Veremos agora quais são os métodos e como utilizá-los!

Método index

Utilizado para encontrar a posição de um valor especificado. Exemplo:

1
2
3
4
5

lista = ['Carro', 'Casa', 'Hotel', 'Casa']

pos = lista.index('Casa')

print(f'O item desejado está na posição: {pos}')

Saída:

1

O item desejado está na posição: 1

Repare que o index() devolve só a primeira ocorrência. Para procurar a partir de outra posição, passe o início como segundo argumento. E se você só quer saber se o item existe, use o operador in, que devolve True ou False e nunca gera erro:

1
2
3
4
5

lista = ['Carro', 'Casa', 'Hotel', 'Casa']

print('Casa' in lista)         # True
print('Moto' in lista)         # False
print(lista.index('Casa', 2))  # 3: busca a partir do índice 2

Se o valor não estiver na lista, o index() gera ValueError (veja em Erros comuns como evitar).

Método count

O método count(elemento) retorna o número de vezes que o valor especificado aparece na lista. Exemplo:

1
2
3
4
5

lista = ['Carro', 'Casa', 'Hotel', 'Casa']

qtd = lista.count('Casa')

print(f'O item desejado aparece: {qtd}')

Saída:

1

O item desejado aparece: 2

Método append

Para adicionar um elemento ao final da lista, use o método append(elemento):

1
2
3
4
5

lista = ['Python', 'Academy']

lista.append('adicionado')

print(lista)

Saída:

1

['Python', 'Academy', 'adicionado']

Método insert

Para adicionar um item em um índice especificado, use o método insert(índice, elemento):

1
2
3
4
5

lista = ['Python', 'Academy']

lista.insert(0, 'Blog')

print(lista)

Saída:

1

['Blog', 'Python', 'Academy']

Método extend

O método extend(iterável) adiciona os elementos de uma lista especificada (ou qualquer outro iterável) ao final da lista:

1
2
3
4
5
6

sacola = ['Laranja', 'Banana']
legumes = ['Xuxu', 'Batata']

sacola.extend(legumes)

print(sacola)

Saída:

1

['Laranja', 'Banana', 'Xuxu', 'Batata']

É possível concatenar as listas para obter o mesmo resultado em uma nova variável. Exemplo:

1
2
3
4
5
6

sacola = ['Laranja', 'Banana']
legumes = ['Xuxu', 'Batata']

juntos = sacola + legumes

print(juntos)

Saída:

1

['Laranja', 'Banana', 'Xuxu', 'Batata']

E também podemos percorrer uma das listas, adicionando elementos à outra com o método append(), assim:

1
2
3
4
5
6
7

sacola = ['Laranja', 'Banana']
legumes = ['Xuxu', 'Batata']

for legume in legumes:
    sacola.append(legume)

print(sacola)

Saída:

1

['Laranja', 'Banana', 'Xuxu', 'Batata']

Estou desenvolvendo o Ebookr.ai, uma plataforma que transforma suas ideias em ebooks profissionais usando IA - com geração de capa, infográficos e exportação em PDF. Te convido a conhecer!

Método remove

Para remover um item com valor especificado, use o método remove(elemento):

1
2
3

lista = ['Blog', 'Python', 'Academy']
lista.remove('Blog')
print(lista)

Saída:

1

['Python', 'Academy']

Outra forma de remover elementos de uma lista é utilizando a instrução del do próprio Python, assim:

1
2
3

lista = [10, 20, 30, 40, 50]
del lista[2]
print(lista)

Saída:

1

[10, 20, 40, 50]

Com a del também é possível excluir uma lista completamente:

1
2
3

lista = [10, 20, 40, 50]
del lista
print(lista)

Aqui o Python irá retornar um erro, já que a variável lista não está mais definida no momento da chamada do print:

1
2
3
4

Traceback (most recent call last):
  File "listas_testes.py", line 3, in <module>
    print(lista)
NameError: name 'lista' is not defined. Did you mean: 'list'?

A sugestão “Did you mean” aparece a partir do Python 3.10; em versões anteriores a mensagem termina em is not defined.

Método pop

Para remover um item do índice especificado e ainda retorná-lo, use o método pop(índice), dessa forma:

1
2
3
4
5
6

lista = ['Banana', 'limão', 'Carro', 'Laranja']

item = lista.pop(2)

print('Item:', item)
print('Lista:', lista)

Saída:

1
2

Item: Carro
Lista: ['Banana', 'limão', 'Laranja']

Método clear

Esse método é utilizado para remover todos os elementos de uma lista, dessa forma:

1
2
3
4
5

lista = [10, 20, 40, 50]

lista.clear()

print(lista)

Saída:

1

[]

Método copy

Esse método retorna uma cópia da lista especificada.

1
2
3
4
5
6

lista = ['Python', 'Academy']

lista_copiada = lista.copy()

print(lista_copiada)
print(lista)

Saída:

1
2

['Python', 'Academy']
['Python', 'Academy']

O fatiamento lista[:] e list(lista) fazem exatamente a mesma coisa. As três formas criam uma cópia rasa: se a lista tiver outras listas dentro, essas sublistas continuam compartilhadas. Nesse caso use copy.deepcopy() (há um exemplo em Erros comuns). A diferença entre copiar e apenas criar outro nome para a mesma lista (b = a) é explicada em detalhes no guia de listas.

Método reverse

O método reverse é utilizado para reverter a ordem dos elementos de uma lista:

1
2
3
4
5

lista = [1, 2, 3, 4, 5]

lista.reverse()

print(lista)

Saída:

1

[5, 4, 3, 2, 1]

O reverse() altera a própria lista. Se você precisa manter a original, use o fatiamento com passo negativo, que devolve uma nova lista invertida:

1
2
3
4
5
6

n = [1, 2, 3, 4]

invertida = n[::-1]

print(invertida)   # [4, 3, 2, 1]
print(n)           # [1, 2, 3, 4] (não mudou)

O passo -1 e outros truques de fatiamento estão no post sobre fatiamento (slicing) de listas.

Método sort

Esse método é utilizado para ordenar a lista.

Também é possível criar uma função para definir seus próprios critérios de ordenação com sort(key=funcao) (veja exemplos em Como ordenar uma lista em Python com key e reverse).

Exemplo:

1
2
3
4
5

lista = [1, 4, 5, 2, 4]

lista.sort()

print(lista)

Saída:

1

[1, 2, 4, 4, 5]

Adicionando o parâmetro reverse=True, é possível ordenar a lista em ordem decrescente.

Para deixar do modo padrão basta colocar reverse=False:

1
2
3
4
5

lista = [1, 4, 5, 2, 4]

lista.sort(reverse=True)

print(lista)

Saída:

1

[5, 4, 4, 2, 1]

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

Keywords de manipulação de Listas

Nesta parte veremos algumas funções embutidas (built-in functions) da própria linguagem que recebem listas como parâmetro, executando alguma ação.

Keyword len()

Retorna a quantidade de itens em uma lista, utilizando a função len(iterável):

1
2
3

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

print('Quantidade de itens:',  len(lista))

Saída:

1

Quantidade de itens: 6

Keyword min()

A função min(iterável) devolve o item com menor valor da lista ou iterável de entrada:

1
2
3

lista = [2, 4, 8, 1]

print('Menor valor da lista:',  min(lista))

Saída:

1

Menor valor da lista: 1

Keyword max()

A função max(iterável) retorna o maior valor da lista ou iterável especificado:

1
2
3

lista = [2, 4, 8, 1]

print('Maior valor da lista:',  max(lista))

Saída:

1

Maior valor da lista: 8

Assim como o sort(), o max() e o min() aceitam o parâmetro key. Por exemplo, max(['kiwi', 'banana', 'uva'], key=len) devolve 'banana', a palavra mais comprida.

Keyword sum()

A função sum(iterável) soma todos os valores numéricos da lista. Combinada com len(), ela dá a média:

1
2
3
4
5
6
7

vendas = [120.0, 75.5, 310.25, 98.0]

total = sum(vendas)
media = total / len(vendas)

print('Total:', total)
print('Média:', round(media, 2))

Saída:

1
2

Total: 603.75
Média: 150.94

O sum() só funciona com números. Para juntar uma lista de strings em uma só, use ''.join(lista).

Keyword sorted()

A função sorted() é utilizada para ordenar a lista de entrada:

1
2
3
4

lista = [2, 4, 8, 1]

lista_ord = sorted(lista)
print(lista_ord)

Saída:

1

[1, 2, 4, 8]

Keyword reversed()

A função reversed() reverte a ordem da lista de entrada. Exemplo:

1
2
3
4

lista = [1, 2, 3, 4, 7]

for item in reversed(lista):
    print(item)

Saída:

1
2
3
4
5

7
4
3
2
1

O reversed() devolve um iterador, não uma lista. Para ter a lista invertida em uma variável, use list(reversed(lista)) ou lista[::-1].

Como ordenar uma lista em Python com key e reverse

A diferença básica você já viu: lista.sort() altera a própria lista (e retorna None), enquanto sorted(lista) devolve uma lista nova. O que realmente muda o resultado da ordenação são dois parâmetros que os dois aceitam:

• reverse=True: ordem decrescente.
• key=funcao: o Python aplica a função em cada item e ordena pelo valor que ela devolve, sem alterar os itens.

Um caso que confunde muita gente: strings são ordenadas pelo código de cada caractere, e todas as maiúsculas vêm antes das minúsculas. Para ordenar em ordem alfabética “de verdade”, use key=str.lower:

1
2
3
4

frutas = ['banana', 'Maçã', 'abacaxi', 'Uva']

print(sorted(frutas))                  # maiúsculas primeiro
print(sorted(frutas, key=str.lower))   # ignora maiúsculas/minúsculas

Saída:

1
2

['Maçã', 'Uva', 'abacaxi', 'banana']
['abacaxi', 'banana', 'Maçã', 'Uva']

Com key=len, a ordenação passa a ser pelo tamanho. E reverse=True inverte o critério:

1
2
3
4

palavras = ['python', 'é', 'muito', 'legal']

print(sorted(palavras, key=len))
print(sorted(palavras, key=len, reverse=True))

Saída:

1
2

['é', 'muito', 'legal', 'python']
['python', 'muito', 'legal', 'é']

Repare que 'muito' e 'legal' têm o mesmo tamanho e mantiveram a ordem original entre si: a ordenação do Python é estável.

Para listas de tuplas (ou de dicionários), o key costuma ser uma função lambda que escolhe o campo. Para ordenar por mais de um critério, devolva uma tupla; o sinal de menos inverte só o critério numérico:

1
2
3
4
5
6

produtos = [('caneta', 2.5), ('caderno', 18.9), ('borracha', 1.2)]
print(sorted(produtos, key=lambda p: p[1]))   # pelo preço

alunos = [('Ana', 8), ('Bruno', 9), ('Carla', 8), ('Davi', 9)]
# nota decrescente e, no empate, nome em ordem alfabética
print(sorted(alunos, key=lambda a: (-a[1], a[0])))

Saída:

1
2

[('borracha', 1.2), ('caneta', 2.5), ('caderno', 18.9)]
[('Bruno', 9), ('Davi', 9), ('Ana', 8), ('Carla', 8)]

Mais receitas (inclusive ordenar por atributos de objetos) estão no guia oficial de ordenação do Python.

Ordenar lista com key é só uma peça da manipulação de dados que você vai usar todo dia como desenvolvedor Python. Pra treinar isso com exercícios e projetos guiados, dá uma olhada 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!

Como juntar, dividir e achatar listas em Python

Juntar listas: +, extend e zip

Existem três jeitos de “juntar” listas, e eles fazem coisas diferentes:

• a + b cria uma nova lista com os itens de a seguidos dos de b.
• a.extend(b) adiciona os itens de b ao final da própria a.
• zip(a, b) emparelha os itens: o 1º de a com o 1º de b, o 2º com o 2º, e assim por diante.

1
2
3
4
5
6
7
8
9
10

nomes = ['Ana', 'Bruno', 'Carla']
notas = [8.5, 6.0, 9.2]

print(nomes + ['Davi'])           # nova lista
print(list(zip(nomes, notas)))    # pares (nome, nota)

for nome, nota in zip(nomes, notas):
    print(f'{nome}: {nota}')

print(dict(zip(nomes, notas)))    # vira um dicionário

Saída:

1
2
3
4
5
6

['Ana', 'Bruno', 'Carla', 'Davi']
[('Ana', 8.5), ('Bruno', 6.0), ('Carla', 9.2)]
Ana: 8.5
Bruno: 6.0
Carla: 9.2
{'Ana': 8.5, 'Bruno': 6.0, 'Carla': 9.2}

Cuidado para não usar append() no lugar de extend(): o append() coloca a outra lista inteira como um único item:

1
2
3

x = [1, 2]
x.append([3, 4])
print(x, len(x))   # [1, 2, [3, 4]] 3

Dividir uma lista em pedaços

Para quebrar uma lista em blocos de tamanho fixo (páginas, lotes de envio, linhas de uma tabela), combine range() com passo e fatiamento:

1
2
3
4

def dividir(lista, tamanho):
    return [lista[i:i + tamanho] for i in range(0, len(lista), tamanho)]

print(dividir([1, 2, 3, 4, 5, 6, 7, 8], 3))

Saída:

1

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

O range(0, len(lista), tamanho) gera os índices de início de cada pedaço (0, 3, 6) e o fatiamento pega tamanho itens a partir dali. O último pedaço fica menor quando a divisão não é exata, sem gerar erro. Veja como o passo funciona no post sobre a função range() do Python.

Achatar uma lista de listas

“Achatar” (flatten) é transformar [[1, 2], [3], [4, 5, 6]] em [1, 2, 3, 4, 5, 6]. A forma mais comum é uma list comprehension com dois for, lidos na mesma ordem de dois laços aninhados:

1
2
3
4
5
6

from itertools import chain

matriz = [[1, 2], [3], [4, 5, 6]]

print([item for sub in matriz for item in sub])
print(list(chain.from_iterable(matriz)))

Saída:

1
2

[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]

O chain.from_iterable() faz o mesmo sem criar laços explícitos; ele e outras ferramentas para iteráveis estão no post sobre a biblioteca itertools. As duas formas achatam um nível: listas com vários níveis de profundidade pedem uma função recursiva.

Casos Práticos Combinados

1. Remover Duplicatas Mantendo Ordem

1
2
3
4
5
6
7
8
9
10

# Preservar ordem original (Python 3.7+)
items = [1, 2, 2, 3, 1, 4, 3]
unique = list(dict.fromkeys(items))
print(unique)  # [1, 2, 3, 4]

# Alternativa: usando lista como acumulador
unique = []
for item in items:
    if item not in unique:
        unique.append(item)

O atalho list(set(items)) também remove os repetidos, mas um set não guarda a ordem de inserção, então a ordem do resultado não é garantida. Use-o quando a ordem não importa (mais sobre isso no post de sets no Python).

2. Filtrar e Transformar

1
2
3
4
5
6
7
8
9

prices = [10.5, 25.0, 5.99, 100.0, 15.75]

# Filtrar preços < 50 e aplicar desconto de 10%
discounted = []
for price in prices:
    if price < 50:
        discounted.append(round(price * 0.9, 2))

print(discounted)  # [9.45, 22.5, 5.39, 14.18]

O round(..., 2) evita resultados como 9.450000000000001, que aparecem porque números de ponto flutuante não representam todo decimal com exatidão. O mesmo filtro cabe em uma linha com list comprehension, [round(p * 0.9, 2) for p in prices if p < 50], ou com as funções map() e filter().

3. Mesclar e Ordenar Duas Listas

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

list1 = [3, 1, 4]
list2 = [2, 5, 0]

# Mesclar
merged = list1 + list2

# Ordenar in-place
merged.sort()
print(merged)  # [0, 1, 2, 3, 4, 5]

# Ordenar sem modificar original
sorted_list = sorted(list1 + list2, reverse=True)
print(sorted_list)  # [5, 4, 3, 2, 1, 0]

Performance dos Métodos

💡 Dica: Se fizer muitas inserções/remoções no início, use collections.deque em vez de lista!

1
2
3
4
5

from collections import deque

fila = deque([1, 2, 3])
fila.appendleft(0)  # O(1) - rápido!
fila.popleft()      # O(1) - rápido!

Erros comuns

Estes são os tropeços mais frequentes ao manipular listas, com a mensagem real que o Python mostra (ou o resultado errado, quando o bug é silencioso).

Usar o retorno do sort() (ele é None)

1
2
3

numeros = [3, 1, 2]
for n in numeros.sort():
    print(n)

1

TypeError: 'NoneType' object is not iterable

O sort() ordena a lista no lugar e devolve None, e o for tenta percorrer esse None. O mesmo acontece com reverse(), extend() e append(). Correção: ordene antes (numeros.sort() em uma linha e for n in numeros: na seguinte) ou use a função, que devolve a lista: for n in sorted(numeros):.

Ordenar uma lista com tipos misturados

1
2

dados = [10, 'dez', 3]
dados.sort()

1

TypeError: '<' not supported between instances of 'str' and 'int'

O Python 3 não sabe comparar texto com número. Isso é comum quando os dados vêm de input() ou de um arquivo, em que tudo chega como string. Correção: padronize o tipo antes de ordenar. Se os números estão como texto, use key=int - repare que sorted(['10', '2', '33']) devolve ['10', '2', '33'] (ordem de texto), enquanto sorted(['10', '2', '33'], key=int) devolve ['2', '10', '33'].

Cópia rasa com listas aninhadas (bug silencioso)

1
2
3
4
5

turmas = [['Ana', 'Bruno'], ['Carla']]
backup = turmas.copy()

turmas[0].append('Davi')
print(backup)

1

[['Ana', 'Bruno', 'Davi'], ['Carla']]

O copy() criou uma lista externa nova, mas as sublistas são as mesmas nas duas, então o “backup” mudou. Correção: import copy e backup = copy.deepcopy(turmas); aí o backup continua [['Ana', 'Bruno'], ['Carla']]. A mesma armadilha aparece ao criar uma matriz com [[0] * 3] * 3: as três linhas são a mesma lista, e matriz[0][0] = 1 muda as três. Crie com [[0] * 3 for _ in range(3)].

Procurar com index() um item que não existe

1
2

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

1

ValueError: 'uva' is not in list

Diferente do find() das strings, o index() de listas não devolve -1: ele quebra o programa. Correção: verifique com in antes, por exemplo pos = frutas.index('uva') if 'uva' in frutas else -1 (resultado -1), ou trate o erro com try/except ValueError.

Passar uma string para o extend() (bug silencioso)

1
2
3

letras = ['a']
letras.extend('bc')
print(letras)

1

['a', 'b', 'c']

O extend() percorre o iterável recebido, e uma string é um iterável de caracteres. Se a intenção era adicionar 'bc' como um item só, use letras.append('bc') ou letras.extend(['bc']); os dois resultam em ['a', 'bc'].

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. Ordene a lista ['banana', 'Abacaxi', 'caju', 'Uva'] em ordem alfabética, sem que as maiúsculas fiquem na frente.

1
2
3

frutas = ['banana', 'Abacaxi', 'caju', 'Uva']
frutas.sort(key=str.lower)
print(frutas)

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) 1, 5, 4, 3, 2
b) 5, 1, 4, 3, 2
c) 5, 1, 3, 4, 2
d) 4, 1, 5, 3, 2

1
2
3
4
5
6
7

lista = [3, 1, 2, 3]
print(lista.count(3))      # 4: conta ocorrências
print(lista.index(2))      # 5: posição da primeira ocorrência
lista.extend([7, 8])       # 3: adiciona os itens de outra lista
lista.sort()               # 1: ordena a própria lista
lista.reverse()            # 2: inverte a ordem
print(lista)

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

1
2
3

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

a) [3, 1, 2] [1, 2, 3]
b) [1, 2, 3] [1, 2, 3]
c) [1, 2, 3] None
d) None [1, 2, 3]

Exercício 4. Divida os números de 1 a 10 em pedaços de 4.

1
2
3
4

def dividir(lista, tamanho):
    return [lista[i:i + tamanho] for i in range(0, len(lista), tamanho)]

print(dividir(list(range(1, 11)), 4))

Exercício 5. Cada cliente tem uma lista com os valores dos seus pedidos: [[120, 80], [45], [300, 15, 60]]. Junte todos os valores em uma lista só e calcule o faturamento total.

1
2
3
4

pedidos = [[120, 80], [45], [300, 15, 60]]
todos = [valor for pedido in pedidos for valor in pedido]
print(todos)
print(sum(todos))

Exercício 6. Dadas as listas nomes = ['Ana', 'Bruno', 'Carla'] e notas = [8.5, 6.0, 9.2], mostre o nome de quem tirou a maior nota.

1
2
3
4
5

nomes = ['Ana', 'Bruno', 'Carla']
notas = [8.5, 6.0, 9.2]

nome, nota = max(zip(nomes, notas), key=lambda par: par[1])
print(f'{nome} tirou a maior nota: {nota}')

Exercício 7 (questão de prova). Qual valor é exibido pelo código abaixo?

1
2
3

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

a) 2
b) 3
c) 4
d) Gera um erro

Exercício 8. A partir de pontos = [40, 95, 12, 78, 95, 60], obtenha as 3 maiores pontuações sem alterar a lista original.

1
2
3
4

pontos = [40, 95, 12, 78, 95, 60]
top3 = sorted(pontos, reverse=True)[:3]
print(top3)
print(pontos)

Quer praticar essas operações em projetos guiados, do básico até aplicações completas? Conheça a Jornada Python, nosso curso de Python completo.

Conclusão

Neste guia de Manipulação de Listas, você aprendeu:

✅ Métodos essenciais - index, count, append, extend, insert, remove, pop, copy, reverse, sort
✅ Ordenação - sort() vs sorted(), key e reverse, vários critérios
✅ Operações práticas - juntar, dividir em pedaços, achatar, filtrar, remover duplicatas
✅ Performance - Complexidade O(n) dos métodos
✅ Erros comuns - retorno None do sort(), tipos misturados, cópia rasa e index() de item inexistente

Principais lições:

• .append() é O(1) - use sempre no final
• .insert(0, x) é O(n) - evite no início
• Use deque para fila (FIFO) eficiente
• .sort() ordena in-place (modifica original) e retorna None
• sorted() cria nova lista (preserva original)

Próximos passos:

• Pratique list comprehensions (mais eficiente!)
• Aprenda slicing com step ([::2], [::-1]) no post de fatiamento de listas
• Use key=lambda ... com mais confiança lendo sobre funções lambda
• Estude collections.deque para filas

Esse post mostrou como o Python nos entrega tudo que precisamos para manipular Listas de uma maneira rápida, prática e eficiente!

Espero que esse post tenha sido útil pra você e nos vemos no próximo post!

Por Erickson Lopes em 16/06/2021

O infinito é o limite

Bora se conectar no LinkedIn! ericksonlopes

Minhas redes:

• 
•