Familiarizando-se com Listas

Além dos tipos de dados mais simples, como números inteiros (int), ou de ponto-flutuante (float)
e strings (str), Python conta com outros dados mais sofisticados, que servem para organizar
coleções, tais como as tuplas (tuple) e as listas, que você estudará nesta aula. Esses tipos voltados
para fins de organização são chamados de estruturas de dados e, quando escolhidos e usados
corretamente, permitem resolver problemas de formas mais eficientes e legíveis, tornando seus
códigos elegantes e compactos.

As listas são estruturas de dados caracterizadas pela ordenação dos seus elementos, ou seja, os
membros de uma lista aparecem em uma ordem específica. Elas possuem muitas características
parecidas com as tuplas, mas você poderá perceber o que diferencia essas duas estruturas, para
conseguir utilizá-las corretamente.

Seja lá como você usa uma lista, é fundamental ser capaz de anotar os itens, poder contar quantos
eles são e reler cada um deles, certo? Portanto, essas são exatamente as habilidades que você irá
aprender para manipular e criar listas através da linguagem Python neste tópico.

Listas em Python correspondem a um novo tipo de dados chamado list. Uma lista é criada usando
um par de colchetes ao redor de uma sequência de zero ou mais elementos separados por vírgula. O
comando abaixo cria uma lista com os nomes de 4 animais e a armazena na variável animais:

Um outro exemplo de lista é uma sequência de gastos em reais, representados como números de
ponto-flutuante guardados na lista gastos, acompanhe abaixo:

E como você pode colocar zero ou mais elementos entre colchetes, na prática, as listas também
podem ser vazias. A lista abaixo não contém nenhum elemento, pois é definida por um simples par de
colchetes, sem nada entre eles:

Seguindo a convenção da língua inglesa, os pontos separam as unidades das casas decimais, enquanto
as vírgulas separam os elementos da lista. Então, não confunda [10.15, 32.55, 23.49], que é
uma lista de três números, todos com duas casas decimais, com [10, 15, 32, 55, 23, 49], que
é uma lista de seis números! Okay?

Quando uma lista é muito grande, você pode quebrar as linhas após as vírgulas para que seu programa
não fique muito comprido na direção horizontal. Isso facilita a leitura e a compreensão do seu código.
O mais comum é quebrar a linha após o colchete de abertura e adicionar 4 espaços a mais que a
margem esquerda da variável a qual a lista é atribuída. No caso da lista de animais, ficaria assim:
Para obter o tamanho de uma lista sem ter que imprimi-la e contar seus elementos manualmente, use
a função len com a lista desejada entre parênteses. Assim, qual seria o resultado da execução do
código da linha a seguir?

A execução dessa linha de código, que faz a chamada da função len(), com as listas animais, gastos
e vazia, imprime a string '4 3 0' em tela, visto que estes são os respectivos tamanhos dessas
listas, conforme a tabela abaixo, que indica os resultados da chamada de len() obtidos para cada uma
delas.

len(animais) len(gastos) len(vazia)

4 3 0
Com as listas, você pode guardar qualquer número de dados em uma única variável, tal como ocorre
com tuplas. Por exemplo, para representar 3 gastos você poderia criar 3 variáveis, conforme o código
abaixo:

E poderia calcular o seu gasto total com a expressão aritmética gasto_1 + gasto_2 + gasto_3.
Se você quiser uma forma mais compacta de representar esses valores, é possível fazer o processo de
empacotamento (do inglês packing), conforme a linha abaixo:

Ou seja, você empacotará os valores armazenados nas 3 variáveis gasto_1, gasto_2, e gasto_3
em uma lista e atribuirá essa lista à variável gastos. Esta linha é equivalente ao trecho gastos =
[10.15, 32.55, 23.49]. Essa é uma das vantagens de trabalhar com estruturas de dados, como
listas, elas permitem guardar uma quantidade flexível de dados em uma única variável.

Quer saber como calcular o gasto total a partir de uma lista de gastos? Essa é fácil, basta usar a função
sum, que significa soma em inglês, passando uma lista como parâmetro, conforme o código abaixo,
cujo resultado é 66.19.
Se você passar uma lista de valores não numéricos, a função resulta num erro do tipo TypeError. E
se passar uma lista vazia, a soma é simplesmente zero. A função sum é muito útil quando nosso
problema se resume a somar números, mas há muitas outras coisas que você pode fazer com listas
que requerem a habilidade de acessar os elementos de uma lista seletivamente e fazer outras
operações. Então, isso é o que você aprenderá a seguir.

Você pode acessar os elementos individuais de uma lista da mesma forma que acessa os elementos
individuais de uma tupla e de toda estrutura onde haja ordem entre os elementos: através de um
índice. Assim, para acessar um dado em uma lista, basta escrever o nome da lista seguido do índice
entre colchetes. Que tal definir uma lista, como a apresentada abaixo, para entender como isso
funciona?

Listas também são indexadas a partir de zero, da esquerda para a direita. Logo, os resultados possíveis,
usando a lista animais, são ilustrados pela tabela abaixo:

..
animais[0] animais[1] animais[2] animais[3] animais[4] animais[5]
.
..
'gato' 'ouriço' 'pardal' 'camaleão' IndexError IndexError
.
Se você utilizar um índice igual ou maior que len(animais), ou seja 4, aparecerá uma mensagem de
erro contendo um IndexError, tipo de erro que você provavelmente já conhece e que acontece
toda vez que um índice se refere a uma posição que não existe. Outro engano possível é tentar indexar
uma lista com um índice que não seja um número inteiro, como animais[1.5], por exemplo. Nesse
caso, o erro gerado é:

Sim, também é possível acessar os elementos de uma lista do final para o começo, contando da direita
para esquerda, com um índice negativo. Como não existe zero negativo, o primeiro índice negativo é
-1 e o último é -4, como exemplifica a tabela abaixo:

... animais[-6] animais[-5] animais[-4] animais[-3] animais[-2] animais[-1]

... IndexError IndexError 'gato' 'ouriço' 'pardal' 'camaleão'
E também é apresentado um IndexError caso você tente acessar elementos fora da lista. Essa forma
de acessar os elementos com base na sua posição é igual ao tipo de dados tuple. Se estamos
colocando que tudo é igual às tuplas, você pode estar neste momento se perguntando, “por que
estudar listas se as tuplas são iguais?” No próximo tópico, você irá entender melhor o que diferencia
essas duas estruturas!

Manipulando Listas

Tudo bem até aqui? Você já aprendeu como definir uma lista de elementos conhecidos, como obter
o seu tamanho e como recuperar elementos em posições específicas. Mas já parou para pensar que
listas não costumam permanecer as mesmas, pois com o tempo surge a necessidade de modificá-las?
No cotidiano, é comum que listas precisem ser alteradas, por exemplo: remover uma tarefa concluída,
substituir um ingrediente em uma receita ou adicionar mais itens à lista de compras.

Assim como essas listas comuns do cotidiano, as listas como estrutura de dados também permitem
que você realize modificações em seus componentes e são nessas características que moram as
grandes diferenças entre listas e tuplas. Listas aumentam e diminuem de tamanho, podendo ser
alteradas o tempo todo. Já as tuplas não podem ser modificadas. Uma vez construídas, elas têm seu
formato e seus dados mantidos o tempo todo. Dizemos, então, que tuplas são estruturas imutáveis e
listas são mutáveis!

Para iniciar, você aprenderá a como modificar valores individuais em uma lista. A operação de
indexação permite acessar elementos especificando seu índice entre colchetes. Então, para modificar
um elemento, também faz sentido usar sua posição, certo? Por exemplo, acompanhe na linha de
código a seguir uma lista de gastos:

gastos = [23.5, 45.6, 5.24, 2.36, 99.49]

O valor 5.24 é o terceiro da lista, portanto, corresponde ao índice 2. Supondo que esse valor esteja
errado e deva ser trocado por 3.29, você pode fazer isso combinando as notações de indexação e de
atribuição de variável da seguinte forma:

gastos[2] = 3.29

Agora, se você imprimir a lista, o que aparecerá? Caso tenha pensado em [23.5, 45.6, 3.29,
2.36, 99.49], então você acertou! Só para dar mais um exemplo, digamos que o valor 2.36
também esteja errado e deva ser trocado por 1.75. Usando a indexação negativa, esse é o valor da
posição -2, que pode ser ajustado assim:

gastos[-2] = 1.75

Agora, o conteúdo da lista passou a ser [23.5, 45.6, 3.29, 1.75, 99.49]. Bem simples, não
acha?

Dado que você sabe como modificar o valor de um elemento em uma lista, deve estar pensando, “por
que não posso fazer o mesmo com uma tupla?” Entenda a seguir o que acontece caso você tente fazer
esse tipo de modificação em uma tupla.

Para construir uma lista, você deve utilizar um par de colchetes; e para construir uma tupla, um par
de parênteses. Vamos então recriar a variável gastos na forma de tuplas, conforme a linha a seguir:

gastos = (23.5, 45.6, 5.24, 2.36, 99.49)

Em seguida, novamente, tente trocar o valor 5.24 por 3.29, que é acessado pelo índice 2, ou seja, é
o terceiro elemento da tupla. Se você tentar digitar a mesma operação feita anteriormente, conforme
o trecho a seguir, ao executá-la, vai receber um erro do tipo TypeError: 'tuple' object does not
support item assignment, que traduzido para o português explica perfeitamente por que chamamos
a tupĺa de imutável, “o objeto 'tupla' não suporta atribuição a itens”.

gastos[2] = 3.29

Dessa forma, a linguagem Python garante que você use tuplas quando precisar de coleções que não
mudam durante a execução do seu problema e listas que podem ser modificadas durante a execução
do mesmo. Com essa informação, você pode escolher qual tipo de estrutura se adapta melhor ao
programa que está desenvolvendo.

Mas as possibilidades com listas não se esgotam aqui. Entenda, a seguir, como utilizar as operações
de remoção e inserção de elementos em listas.

Para remover elementos da lista, também se usa a notação de indexação. Nesse caso, adicione o
comando del antes da lista indexada na posição que você pretende remover. Assim, interprete o
trecho a seguir:

Analisando o trecho acima, a primeira linha foi instanciada à lista gastos, na segunda foi impresso o
tamanho dela seguido do seu conteúdo, na terceira foi deletado o elemento gastos[1] e na quarta
voltamos a imprimir o tamanho da lista e seu conteúdo após a remoção. Assim, na linha 2, será
impresso '5 [23.5, 45.6, 3.29, 1.75, 99.49]’, visto que a lista tem tamanho 5 e o conteúdo
é a lista de números que se segue.

Logo após a deleção da linha 3, gastos se tornará uma lista com 4 elementos cujo conteúdo é [23.5,
3.29, 1.75, 99.49]. Então, o resultado da execução da linha 4 será '4 [23.5, 3.29, 1.75,
99.49]'.

O que acontece se você tentar acessar gastos[4] agora? Como a lista só tem 4 elementos, só é possível
acessá-los via índices de 0 a 3. Com isso, a execução resultará em um IndexError, erro que também
vai ocorrer se você tentar excluir uma posição que não existe, como del gastos[300], por exemplo.

O comando para inserir novos valores, aumentando o tamanho da lista, é um pouco diferente: ele não
usa colchetes, mas também se baseia na lógica de indexação. Para dar um exemplo, considere que a
lista gastos está com valor igual a [23.5, 45.6, 3.29, 1.75, 99.49]. Para inserir o valor 77.7
na posição 2, onde agora está o 3.29, você escreveria:

Nesse trecho, você terá como novidade o que é apresentado na linha 3. Nesta linha, terá a variável
gastos seguida de um . e depois a chamada da função insert() com os parâmetros 2 e 77.7. Ao
contrário de len(), insert() é o que chamamos de função membro ou método, ou seja, é uma
função que faz parte de uma lista qualquer. Assim, quando executar gastos.insert(), você está
executando uma função que é parte da variável gastos.
Como ficaria a lista? Dica: é o contrário do que faz o del. Ou seja, os elementos antigos são deslocados
para a direita para dar lugar ao novo. Então, a lista passa a ser [23.5, 45.6, 77.7, 3.29, 1.75,
99.49]. Dessa forma, ao se executar a linha 2 do trecho, o valor impresso será '5 [23.5, 45.6,
3.29, 1.75, 99.49]' e ao executar a linha 4 o valor será '6 [23.5, 45.6, 77.7, 3.29, 1.75,
99.49]'.

E como adicionar 100.0 no final da lista após o último elemento? Pense um pouco, pois essa é a
pergunta mais desafiadora!

A resposta correta é gastos.insert(6, 100.0), e não gastos.insert(5, 100.0). Nesse

caso, já que o comportamento é empurrar o que sobra para a direita, é preciso usar o próprio tamanho
da lista, o que é até mais fácil com gastos.insert(len(gastos), 100.0). Esse é o único caso
em que podemos usar o tamanho da lista como índice sem gerar um IndexError.

Além da notação de indexação para acessar, alterar e remover elementos únicos, as listas e as tuplas
permitem uma maneira bem versátil de extrair alguns de seus elementos, chamada de fatiamento,
em inglês, slicing. Em essência, um fatiamento extrai apenas alguns elementos, indicando um índice
inicial, um índice final e, opcionalmente, um espaçamento (ou incremento). Como exemplo, vamos
usar uma lista dos múltiplos de 10 entre 0 e 100, pois é mais fácil de entender assim. Acompanhe a
linha a seguir:

1 numeros = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

A fatia numeros[2:5] corresponde à lista [20, 30, 40], porque copia os elementos entre as posições
2 e 5, excluindo a posição 5. Outra fatia é numeros[:5], sinônimo de numeros[0:5], que resulta na
lista [0, 10, 20, 30, 40]. E a fatia numeros[5:], sinônima de numeros[5:11], corresponde a [50,
60, 70, 80, 90, 100]. Consegue entender a lógica aqui? Resumidamente,

• O primeiro número indica a posição inicial, mas se omitido vale 0;

• O segundo número indica a posição final, mas se omitido vale len(numeros).

Uma forma mais geral de fatiamento permite adicionar um terceiro número, separado do índice final
por dois pontos, para indicar o espaçamento entre os elementos destacados. Assim, a fatia
numeros[3:8:2] corresponde à lista [30, 50, 70], pois inicia no índice 3, avança de 2 em 2 e para
antes do índice 8. Quando o espaçamento é omitido, vale 1. Como o início e o fim também podem ser
omitidos, é possível escrever fatiamentos só com o espaçamento, como numeros[::3], cujo resultado
é [0, 30, 60, 90].

Um último detalhe sobre fatiamentos é que eles também permitem índices negativos. Os valores
implícitos dos índices inicial e final, nesse caso, ficam invertidos. Apesar desse caso ser um pouco mais
confuso, seu uso mais comum são numeros[::-1], que correspondem a uma cópia da lista de trás
para a frente.

A tabela abaixo resume as principais formas de fatiamento. A primeira coluna representa a notação
de fatiamento abreviada, a segunda coluna o resultado e a terceira a notação de fatiamento completa
(sem valores implícitos). O exemplo é baseado na lista numeros = [0, 10, 20, 30, 40, 50,
60, 70, 80, 90, 100].

Fatia Resultado Fatia (completa)

numeros[2:5] [20, 30, 40] numeros[2:5:1]
numeros[5:] [50, 60, 70, 80, 90, 100] numeros[5:11:1]
numeros[:5] [0, 10, 20, 30, 40] numeros[0:5:1]
 numeros[3:8:2] [30, 50, 70] numeros[3:8:2]
numeros[3::2] [ 30, 50, 70, 90] numeros[3:11:2]
numeros[:5:2] [0, 20, 40] numeros[0:5:2]
numeros[::2] [0, 20, 40, 60, 80, 100] numeros[0:11:2]
[100, 90, 80, 70, 60, 50, 40, 30,
numeros[::-1] numeros[11:0:-1]
20, 10, 0]
numeros[4:4] [] numeros[4:4:1]
[20, 30, 40, 50, 60, 70, 80, 90,
numeros[2:50] numeros[2:50:1]
100]
Cuidado com as sutilezas! O fatiamento “numeros[4:4]”, na penúltima linha da tabela corresponde a
uma lista vazia, pois o índice inicial é 4, mas o índice final, que também é 4, deve ser excluído. Então,
não sobra nada. Uma fatia nunca gera IndexError no caso de índices inexistentes, mas ela não pode
retornar mais elementos do que a lista contém. Por isso, o fatiamento da última linha, apesar de
especificar 48 elementos, só resulta em 9, pois as posições de 11 a 50 não existem. Advinha a única
coisa que gera problemas em fatiamentos? Sim, usar 0 como espaçamento resulta em ValueError.

Para encerrar esse tópico de manipulação de listas, você precisa entender como usar alguns
operadores aritméticos e relacionais com listas.

Operadores aritméticos em Python (+, -, *, /, %, // e **) permitem produzir expressões matemáticas

envolvendo números inteiros ou de ponto-flutuante. Já os operadores relacionais (==, !=, >=, <=, > e
<) permitem fazer comparações entre números e podem ser usados para tomar decisões e desviar o
curso do programa. No caso de listas, alguns desses operadores também podem ser utilizados para
escrever programas mais curtos e fáceis de ler.

Para entender isso, considere as duas listas de compras criadas abaixo:

A operação de concatenação de listas, ou seja, emendar uma lista após a outra, pode ser realizada
pelo operador de soma. Por exemplo, a concatenação das listas compras1 e compras2, expressa
como compras1 + compras2, resulta em:

['manteiga', 'aveia', 'sabao em pó', 'detergente', 'carvao', 'arroz']

Bem intuitivo, não é mesmo? A operação de repetição de uma lista, ou seja, de concatenar múltiplas
cópias da mesma lista, corresponde ao operador de multiplicação, *. Por exemplo, 2 repetições da
lista compras2, expressas como 2 * compras2, resulta em:

['detergente', 'carvao', 'arroz', 'detergente', 'carvao', 'arroz']

Os únicos operadores aritméticos que funcionam com lista são o de soma (+) e de multiplicação (*) e
suas versões com atribuição, soma com atribuição (+=) e multiplicação com atribuição (*=). Somar
uma lista com qualquer outra coisa que não seja uma lista ou multiplicá-la por qualquer coisa que não
seja um número inteiro resultam em um erro, no caso o TypeError.

Foram muitas novidades até aqui, não foram? Edição de listas com indexação, métodos, fatiamentos
e operadores. Para amarrar um pouco os conceitos e mostrar como essas ferramentas podem se
encaixar pra resolver um problema real, que tal um exemplo combinando operadores aritméticos e
fatiamentos? Considere uma lista chamada casas_pares, que armazena os números pares de casas
em uma rua, definida da seguinte forma:

1 casas_pares = [216, 220, 222, 268, 270]

Suponha que haja bastante terreno vazio entre as casas 222 e 268. Se novas casas com números 232,
240 e 252 forem construídas nesse espaço, como obter uma lista atualizada das casas pares nessa
rua? Resolvendo por partes, note que:

• As três primeiras casas fazem parte da fatia casas_pares[:3];

• As duas últimas casas fazem parte da fatia casas_pares[3:]; e
• As novas casas podem ser representadas pela lista [232, 240, 252], que se encaixa
perfeitamente entre essas duas fatias.

Portanto, uma solução possível é dada pela expressão abaixo:

1 casas_pares = casas_pares[:3] + [232, 240, 252] + casas_pares[3:]

O lado direito dessa expressão combina fatias da lista casas_pares original com uma lista nova e atribui
o resultado novamente à variável casas_pares. Se você imprimir essa lista com
print(casas_pares), o novo valor dela será [216, 220, 222, 232, 240, 252, 268, 270],
conforme esperado.

Esse breve exemplo mostra como os operadores de listas que você aprendeu podem ser combinados
de maneiras criativas para resolver problemas reais usando listas.

A seguir, confira alternativas a essas operações.

A lista é versátil, mas como nem todas as estruturas de dados em Python suportam fatiamentos e
operadores aritméticos, além de alguns programadores acharem essa notação confusa, o tipo list
possui alguns métodos que servem para expressar essas operações usando verbos da língua inglesa,
deixando a linguagem mais consistente. Esses métodos são descritos na tabela abaixo, em que a
primeira coluna descreve a operação, a segunda apresenta a notação com métodos e a terceira
apresenta a notação equivalente com somas, fatiamentos e atribuições.

Perceba novamente que chamamos append, extend e pop de métodos, pois ele são parte das
diferentes listas. Métodos (ou funções membro) serão temas abordados mais profundamente na aula
voltada para Programação Orientada a Objetos, mas é importante desde já você se acostumar com o
jargão da área.

Acompanhe na próxima página uma dica de como utilizar esses métodos.

Em geral, no caso de métodos como append, extend e pop, não use o comando de atribuição para
atualizar a variável que guarda a lista. A presença da variável à esquerda do ponto já é suficiente para
que a alteração seja feita na própria lista guardada, ao invés de gerar uma nova. Já com os operadores
de fatiamento, soma e multiplicação, uma nova lista sempre é gerada, daí a necessidade de
operadores de atribuição para atualizar a variável casas_pares com o resultado da expressão na
coluna direita da tabela. A atribuição até pode ser usada com o método pop para recuperar o
elemento removido, por exemplo, x = casas_pares.pop(3), mas os métodos append e extend
não retornam nenhum valor, apenas modificam a lista silenciosamente.

As possibilidades de operadores e notações que você pode usar em Python são enormes, o que traz
uma grande quantidade de alternativas, mesmo para uma linguagem que preza a simplicidade! Se
quiser saber mais sobre as operações do tipo list, você pode acessar a documentação oficial
de Python, ou acessar esse outro link, ainda na documentação, com mais informações sobre esse tipo
de estrutura de dados.

Ordenação e Busca

Listas podem ser utilizadas de diversas formas na solução de problemas. Às vezes, a ordem dos
elementos é fundamental para o problema que se quer resolver, mas em outras situações ela pode
ser apenas uma consequência de como você ou o programa adquirem os dados. Por exemplo, uma
lista de tarefas, um roteiro de viagens ou uma receita devem ser seguidos na ordem em que os passos
estão descritos. Por outro lado, você pode escrever uma lista de materiais ou de compras na ordem
em que se lembra dos itens, mas não precisa necessariamente executá-los na mesma ordem.

Uma outra necessidade comum é determinar se um elemento ocorre em uma lista, em quais posições
e quantas vezes. Por exemplo, se você tem uma lista de compras e vai fazer uma receita,
provavelmente, quer saber se os ingredientes aparecem na lista de compras, na quantidade correta,
não é mesmo?

Como recuperar elementos de uma lista em Python? Até o momento, você aprendeu como fazer isso
usando um índice inteiro que corresponde a um deslocamento a partir do começo ou do final da lista.
Isso é ótimo quando você constrói uma lista de forma interativa e sabe onde estão os elementos ou
quando a posição é informativa por si só. Por exemplo, em uma lista de tarefas ordenada por
prioridade decrescente, o primeiro elemento é, geralmente, a tarefa mais importante e o último é a
tarefa mais dispensável.

Imagine que você tem um aplicativo que te ajuda a criar e manter listas de compras. Internamente,
ele pode guardar os seus itens em uma lista, em uma variável chamada compras, sem nenhuma
ordenação especial. Se você pedir ao aplicativo que adicione 'farinha' à lista, por causa de uma
receita que você irá preparar, o mínimo que o aplicativo deverá fazer é verificar se o item 'farinha'
já não faz parte dessa lista, certo? Em Python, isso poderia ser feito com a expressão 'farinha' in
compras, que resulta em True ou False. O código abaixo usa o comando if para só adicionar o item
à lista se o mesmo estiver faltando:
Os parênteses são apenas para melhorar a legibilidade. Você também poderia escrever not item in
compras, ou item not in compras que o resultado seria o mesmo. Perceba que, nessas 3 expressões,
estamos utilizando os diferentes operadores Python estudados para verificar se um item pertence a
uma coleção. Essa combinação também pode ser utilizada em tuplas. Então, tudo que fazemos com
listas, que não envolva a modificação de seus elementos, pode ser reproduzido em tuplas. Lembre-se
sempre disso.

Digamos que você queira adicionar mais um item caso ele não tenha sido adicionado limite vezes.
Nesse caso, você pode utilizar o método count(), conforme o trecho a seguir, onde assumimos que
a lista compras já existe, definimos o item e o limite nas linhas 1 e 2 e, nas linhas 3 e 4, fazemos a
inserção dependendo do método count(), que significa "contar" ou "conte" em inglês, que percorre
a lista inteira para contar o número de vezes que item aparece na mesma:

Seguindo no exemplo da lista de compras, suponha que você precise substituir um item, como trocar
farinha por farinha integral. Com indexação por posição, você só pode alterar um elemento se souber
onde ele está localizado. Usando o método index do tipo list, é possível descobrir o índice da
primeira ocorrência, da esquerda para a direita, de um elemento na lista. O código abaixo faz a
substituição usando esse método:

Porém, caso haja outras ocorrências de 'farinha' em compras, elas permanecerão inalteradas.
Uma forma de substituir todas as ocorrências é usar um laço de repetição while, como está
apresentado abaixo:
O subprograma de dentro é repetido enquanto a condição for verdadeira, então todas as ocorrências
são substituídas. Será que pode ocorrer algum erro ao se fazer a chamada do método index()?
Confira a resposta abaixo:

O método index() resulta em IndexError se o valor pedido não fizer parte da lista. Por outro lado,
o método count simplesmente retorna zero caso o elemento não exista. O exemplo com while
acima é seguro, pois o método index não é chamado a não ser que ainda exista alguma ocorrência de
'farinha' em compras.

Digamos que você gostou tanto de programar em Python que abriu sua própria escola de
programação. Então, para avaliar uma das turmas de sua escola, resolveu representar as notas dos
alunos através de uma lista. A lista notas = [7.3, 4.5, 6.7, 5.2, 8.4, 1.2, 9.4] armazena
as notas obtidas por um aluno em uma das disciplinas. A regra de avaliação da disciplina informa que
as 3 menores notas serão descartadas e a média será calculada pelas notas restantes. Então, se a lista
estiver em ordem ascendente, basta uma fatia do índice 3 em diante para obter as notas usadas no
cálculo da nota final. O programa abaixo usa o método sort na segunda linha para ordenar a lista, além
das funções sum e len na quarta linha para calcular a nota final:

O método sort(), assim como append(), extend() e insert(), altera a lista a partir da qual é
feita a chamada ao método. Uma alternativa, se você precisar preservar a ordem da lista original, é
usar a função sorted(), que significa "ordenado" em inglês e que retorna uma cópia ordenada da lista
passada sem afetar a original. Interessante, não acha?

Digamos também que a regra de avaliação para outra disciplina é diferente: ao invés de remover as
três menores notas, você deve excluir a menor e a maior notas e fazer a média com as demais.
Utilizando a função sorted(), você consegue fazer um código que implemente essa regra? Pense um
pouco antes de verificar a solução na página a seguir.

DICA: lembre-se de que sort() é um método e sorted() é uma função! Métodos são colocados após
a variável em que eles são membros. Já para executar sorted() corretamente você deve passar a
variável que quer ordenar como parâmetro.

Para resolver essa questão conforme pedido, você pode novamente utilizar as diferentes peças que
estudou para manipular listas e, em poucas linhas, construir um algoritmo um tanto complexo!
Verifique o trecho a seguir:
Novamente, foi iniciado a lista notas na linha 1 e, na linha 2, foi utilizada a função sorted() para gerar
uma cópia ordenada dessa lista. Com isso, atribuímos essa cópia para a variável notas_uteis. Nas
linhas 3 e 4, temos um trecho bem compacto que primeiro remove a nota mais baixa do aluno, aquela
que está na posição 0, e depois removemos a nota mais alta dele, ou seja, a nota que está na última
posição disponível dessa lista. Utilizamos a indexação negativa -1 para facilmente acessar esse
elemento! Já na linha 5, fazemos novamente o cálculo da nota final do aluno e na última linha do
trecho apresentamos a média e a lista de notas utilizadas.

Você aprendeu sobre uma das estruturas de dados mais importantes e versáteis do Python: listas.
Com elas, você pode apresentar coleções de objetos relacionados que aparecem em uma sequência
específica, como listas de compras, seus livros favoritos, suas tarefas semanais ou seus gastos
mensais.Além de descrever uma lista, você aprendeu também algumas operações que podem ser
usadas para modificar sua estrutura, adicionando, removendo, recombinando e reordenando
elementos.Em outros momentos, você poderá perceber as listas aparecendo diversas vezes na
solução de problemas, além de outras estruturas de dados que permitem a organização. Esse
repertório é fundamental, pois depois que você se acostuma com ele, tem um arsenal de técnicas à
sua disposição para resolver muitos tipos de problemas.

Referências
• Eric Matthes. Curso Intensivo de Python - Uma introdução prática e baseada em projetos à
programação (capítulos 3 e 4). Editora Novated, 2016.
• Uma introdução informal ao Python – Introdução – Listas (documentação oficial traduzida),
acessado em 18/05/2020.
• Uma introdução informal ao Python – Estruturas de Dados – Mais sobre listas (documentação
oficial traduzida), acessado em 18/05/2020.
• A Biblioteca padrão do Python – Tipos de Sequências – list, tuple, range (documentação oficial
traduzida), acessado em 10/05/2020.
• Compo pensar com um cientista da computação - listas, Tradução do livro How to Think Like
a Computer Scientist, de Brad Miller e David Ranum, pelo Instituto de Matemática e Estatística
da USP, acessado em 18/05/2020.
• The History of Python: Why Python uses 0-based indexing, acessado em 21/05/2020.
• Quais os prós e contras de indexar vetores por 0