Capítulo 04 - Trabalhando com listas

No Capítulo 3, você aprendeu a fazer uma lista simples e a trabalhar com os elementos individuais em uma lista. Neste capítulo, você aprenderá a fazer um loop por uma lista inteira usando apenas algumas linhas de código, independentemente do tamanho da lista. O loop permite que você execute a mesma ação, ou conjunto de ações, com cada item em uma lista. Como resultado, você poderá trabalhar eficientemente com listas de qualquer tamanho, incluindo aquelas com milhares ou até milhões de itens.

Percorrendo uma lista inteira

Muitas vezes você vai querer percorrer todas as entradas em uma lista, realizando a mesma tarefa com cada item. Por exemplo, em um jogo, você pode querer mover todos os elementos na tela na mesma quantidade. Em uma lista de números, você pode querer realizar a mesma operação estatística em todos os elementos. Ou talvez você queira exibir cada título de uma lista de artigos em um site. Quando você quiser fazer a mesma ação com cada item em uma lista, você pode usar o loop for do Python.

Digamos que temos uma lista de nomes de mágicos e queremos imprimir cada nome na lista. Poderíamos fazer isso recuperando cada nome da lista individualmente, mas essa abordagem poderia causar vários problemas. Por um lado, seria repetitivo fazer isso com uma longa lista de nomes. Além disso, teríamos que alterar nosso código cada vez que o comprimento da lista mudasse. Usar um loop for evita esses dois problemas, permitindo que o Python os gerencie internamente.

Vamos usar um loop for para imprimir cada nome em uma lista de mágicos:

magicos = ['felipe', 'criss', 'houdini']

for magico in magicos:

  print(magico)

Começamos definindo uma lista, assim como fizemos no Capítulo 3. Então definimos um loop for. Esta linha diz ao Python para extrair um nome da lista magicos e associá-lo à variável magico. Em seguida, dizemos ao Python para imprimir o nome que acabou de ser atribuído a magico. O Python então repete essas duas últimas linhas, uma para cada nome na lista. Pode ajudar ler este código como "Para cada mágico na lista de mágicos, imprima o nome do mágico". A saída é uma impressão simples de cada nome na lista.

Um olhar mais atento ao looping

O loop é importante porque é uma das formas mais comuns de um computador automatizar tarefas repetitivas. Por exemplo, em um loop simples como o que fizemos, o Python inicialmente lê a primeira linha do loop:

for magico in magicos

Esta linha diz ao Python para recuperar o primeiro valor da lista magicos e associá-lo à variável magico. Este primeiro valor é 'felipe'. O Python então lê a próxima linha:

print(magico)

Python imprime o valor atual de magico, que ainda é 'felipe'. Como a lista contém mais valores, Python retorna para a primeira linha do loop:

for magico in magicos

Python recupera o próximo nome na lista, 'criss', e associa esse valor à variável magico. Python então executa a linha:

print(magico)

Python imprime o valor atual de magico novamente, que agora é 'criss'. Python repete o loop inteiro mais uma vez com o último valor na lista, 'houdini'. Como não há mais valores na lista, Python passa para a próxima linha no programa. Neste caso, nada vem depois do loop for, então o programa termina.

Quando estiver usando loops pela primeira vez, tenha em mente que o conjunto de etapas é repetido uma vez para cada item na lista, não importa quantos itens estejam na lista. Se você tiver um milhão de itens na sua lista, o Python repete essas etapas um milhão de vezes — e geralmente muito rapidamente.

Também tenha em mente, ao escrever seus próprios loops for, que você pode escolher qualquer nome que quiser para a variável temporária que será associada a cada valor na lista. No entanto, é útil escolher um nome significativo que represente um único item da lista. Por exemplo, aqui está uma boa maneira de iniciar um loop for para uma lista de gatos, uma lista de cães e uma lista geral de itens:

for gato in gatos:

for cachorro in cachorros:

for item in lista_de_itens:

Essas convenções de nomenclatura podem ajudar você a seguir a ação sendo feita em cada item dentro de um loop for. Usar nomes singulares e plurais pode ajudar você a identificar se uma seção de código está trabalhando com um único elemento da lista ou com a lista inteira.

Fazendo mais trabalho dentro de um loop for

Você pode fazer praticamente qualquer coisa com cada item em um loop for. Vamos construir sobre o exemplo anterior imprimindo uma mensagem para cada mágico, dizendo a eles que eles realizaram um grande truque:

magicos = ['felipe', 'criss', 'houdini']

for magico in magicos:

  print(f'{magico.title()}, isso foi um grande truque!')

A única diferença neste código é onde compomos uma mensagem para cada mágico, começando com o nome daquele mágico. Na primeira vez no loop, o valor de magico é 'felipe', então o Python inicia a primeira mensagem com o nome 'Felipe'. Na segunda vez, a mensagem começará com 'Criss', e na terceira vez, a mensagem começará com 'Houdini'. A saída mostra uma mensagem personalizada para cada mágico na lista.

Você também pode escrever quantas linhas de código quiser no loop for. Cada linha recuada após a linha for magico in magicos é considerada dentro do loop, e cada linha recuada é executada uma vez para cada valor na lista. Portanto, você pode fazer tanto trabalho quanto quiser com cada valor na lista.

Vamos adicionar uma segunda linha à nossa mensagem, dizendo a cada mágico que estamos ansiosos pelo seu próximo truque:

magicos = ['felipe', 'criss', 'houdini']

for magico in magicos:

  print(f'{magico.title()}, isso foi um grande truque!')

  print(f'Mal posso esperara para o seu truque seguinte, {magico.title()}.\n')

Como recuamos ambas as chamadas para print(), cada linha será executada uma vez para cada mágico na lista. A nova linha ('\n') na segunda chamada print()insere uma linha em branco após cada passagem pelo loop. Isso cria um conjunto de mensagens que são agrupadas ordenadamente para cada pessoa na lista.

Você pode usar quantas linhas quiser em seus loops for. Na prática, você frequentemente achará útil fazer uma série de operações diferentes com cada item em uma lista quando usar um loop for.

Fazendo algo após um loop for

O que acontece quando um loop for termina de ser executado? Normalmente, você vai querer resumir um bloco de saída ou passar para outro trabalho que seu programa deve realizar.

Quaisquer linhas de código após o loop for que não sejam recuadas são executadas uma vez sem repetição. Vamos escrever um agradecimento ao grupo de mágicos como um todo, agradecendo-os por fazerem um show excelente. Para exibir esta mensagem de grupo após todas as mensagens individuais terem sido impressas, colocamos a mensagem de agradecimento após o loop for, sem recuo:

magicos = ['felipe', 'criss', 'houdini']

for magico in magicos:

  print(f'{magico.title()}, isso foi um grande truque!')

  print(f'Mal posso esperara para o seu truque seguinte, {magico.title()}.\n')

print('Muito obrigado a todos pelo show! Foi fantástico!')

As duas primeiras chamadas para print() são repetidas uma vez para cada mágico na lista, como você viu antes. No entanto, como a última linha não é recuada, ela é impressa apenas uma vez.

Ao processar dados usando um loop for, você verá que esta é uma boa maneira de resumir uma operação que foi realizada em um conjunto de dados inteiro. Por exemplo, você pode usar um loop for para inicializar um jogo executando uma lista de personagens e exibindo cada personagem na tela. Você pode então escrever algum código adicional após este loop que exibe um botão Jogar Agora depois que todos os personagens foram desenhados na tela.

Evitando erros de indentação

Python usa indentação para determinar como uma linha, ou grupo de linhas, está relacionada ao resto do programa. Nos exemplos anteriores, as linhas que imprimiam mensagens para mágicos individuais faziam parte do loop for porque eram recuadas. O uso de recuo pelo Python torna o código muito fácil de ler. Basicamente, ele usa espaços em branco para forçar você a escrever um código bem formatado com uma estrutura visual clara. Em programas Python mais longos, você notará blocos de código recuados em alguns níveis diferentes. Esses níveis de recuo ajudam você a ter uma noção geral da organização geral do programa.

Conforme você começa a escrever código que depende de recuo adequado, você precisará observar alguns erros de indentação comuns. Por exemplo, as pessoas às vezes recuam linhas de código que não precisam ser recuadas ou esquecem de recuar linhas que precisam ser recuadas. Ver exemplos desses erros agora ajudará você a evitá-los no futuro e corrigi-los quando eles aparecerem em seus próprios programas.

Vamos examinar alguns dos erros de indentação mais comuns.

Esquecendo de indentar

Sempre recue a linha após a instrução for em um loop. Se você esquecer, o Python irá lembrá-lo:

magicos = ['felipe', 'criss', 'houdini']

for magico in magicos:

print(magico)  # 1

A chamada para print() (1) deveria ser recuada, mas não é. Quando o Python espera um bloco recuado e não encontra nenhum, ele permite que você saiba com qual linha ele teve um problema.

Esquecendo de indentar linhas adicionais

Às vezes, seu loop rodará sem erros, mas não produzirá o resultado esperado. Isso pode acontecer quando você está tentando fazer várias tarefas em um loop e esquece de recuar algumas de suas linhas.

Por exemplo, é isso que acontece quando esquecemos de recuar a segunda linha do loop que diz a cada mágico que estamos ansiosos pelo seu próximo truque:

magicos = ['felipe', 'criss', 'houdini']

for magico in magicos:

  print(f'{magico.title()}, isso foi um grande truque!')

print(f'Mal posso esperara para o seu truque seguinte, {magico.title()}.\n')  # 1

A segunda chamada para print() (1) deve ser recuada, mas como o Python encontra pelo menos uma linha recuada após a instrução for, ele não relata um erro. Como resultado, a primeira chamada print() é executada uma vez para cada nome na lista porque é recuada. A segunda chamada print() não é indentada, então ela é executada apenas uma vez após o loop terminar de ser executado. Como o valor final associado a magico é 'houdini', ela é a única que recebe a mensagem “Mal posso esperara para o seu truque seguinte”.

Este é um erro lógico. A sintaxe é um código Python válido, mas o código não produz o resultado desejado porque ocorre um problema em sua lógica. Se você espera ver uma determinada ação repetida uma vez para cada item em uma lista e ela é executada apenas uma vez, determine se você precisa simplesmente recuar uma linha ou um grupo de linhas.

Indentação desnecessária

Se você acidentalmente recuar uma linha que não precisa ser recuada, o Python informa sobre o recuo inesperado:

mensagem = 'Olá, Mundo Python!'

  print(mensagem)

Não precisamos recuar a chamada print(), porque ela não faz parte de um loop; portanto, o Python relata este erro.

Você pode evitar erros de indentação inesperados indentando somente quando tiver um motivo específico para isso. Nos programas que você está escrevendo neste ponto, as únicas linhas que você deve recuar são as ações que você quer repetir para cada item em um loop for.

Indentação desnecessária após o loop

Se você acidentalmente recuar o código que deveria ser executado após um loop ter terminado, esse código será repetido uma vez para cada item na lista. Às vezes, isso faz com que o Python relate um erro, mas frequentemente isso resultará em um erro lógico.

Por exemplo, vamos ver o que acontece quando acidentalmente recuamos a linha que agradeceu aos mágicos como um grupo por fazerem um bom show:

magicos = ['felipe', 'criss', 'houdini']

for magico in magicos:

  print(f'{magico.title()}, isso foi um grande truque!')

  print(f'Mal posso esperara para o seu truque seguinte, {magico.title()}.\n')

  print('Muito obrigado a todos pelo show! Foi fantástico!')  # 1

Como a última linha (1) é recuada, ela é impressa uma vez para cada pessoa na lista.

Este é outro erro lógico, similar ao de Esquecendo de indentar linhas adicionais. Como o Python não sabe o que você está tentando fazer com seu código, ele executará todo o código escrito em sintaxe válida. Se uma ação for repetida muitas vezes quando deveria ser executada apenas uma vez, você provavelmente precisará desindentar o código para essa ação.

Esquecendo os dois pontos

Os dois pontos no final de uma instrução for informam ao Python para interpretar a próxima linha como o início de um loop:

magicos = ['felipe', 'criss', 'houdini']

for magico in magicos  # 1

  print(magico)

Se você acidentalmente esquecer os dois pontos (1), você receberá um erro de sintaxe porque o Python não sabe exatamente o que você está tentando fazer.

O Python não sabe se você simplesmente esqueceu os dois pontos ou se você quis escrever código adicional para configurar um loop mais complexo. Se o interpretador puder identificar uma possível correção, ele sugerirá uma, como adicionar dois pontos no final de uma linha, como faz aqui com a resposta expected ':'. Alguns erros têm correções fáceis e óbvias, graças às sugestões nos tracebacks do Python. Alguns erros são muito mais difíceis de resolver, mesmo quando a correção eventual envolve apenas um único caractere. Não se sinta mal quando uma pequena correção demorar muito para ser encontrada; você não está sozinho nessa experiência.

Tente você mesmo!

Exercício 01: Pense em pelo menos três tipos de sua pizza favorita. Armazene esses nomes de pizza em uma lista e, em seguida, use um loop for para imprimir o nome de cada pizza:

• Modifique seu loop for para imprimir uma frase usando o nome da pizza, em vez de imprimir apenas o nome da pizza. Para cada pizza, você deve ter uma linha de saída contendo uma declaração simples como Eu gosto de pizza de bacon.

• Adicione uma linha no final do seu programa, fora do loop for, que declare o quanto você gosta de pizza. A saída deve consistir em três ou mais linhas sobre os tipos de pizza que você gosta e então uma frase adicional, como Eu realmente amo pizza!

Exercício 02: Pense em pelo menos três animais diferentes que tenham uma característica comum. Armazene os nomes desses animais em uma lista e, em seguida, use um loop for para imprimir o nome de cada animal:

• Modifique seu programa para imprimir uma declaração sobre cada animal, como Um cachorro seria um ótimo animal de estimação.

• Adicione uma linha no final do seu programa, declarando o que esses animais têm em comum. Você pode imprimir uma frase, como Qualquer um desses animais é um ótimo animal de estimação!

Fazendo listas numéricas

Existem muitos motivos para armazenar um conjunto de números. Por exemplo, você precisará manter o controle das posições de cada personagem em um jogo, e você pode querer manter o controle das pontuações mais altas de um jogador também. Em visualizações de dados, você quase sempre trabalhará com conjuntos de números, como temperaturas, distâncias, tamanhos populacionais ou valores de latitude e longitude, entre outros tipos de conjuntos numéricos.

Listas são ideais para armazenar conjuntos de números, e o Python fornece uma variedade de ferramentas para ajudar você a trabalhar eficientemente com listas de números. Depois que você entender como usar essas ferramentas efetivamente, seu código funcionará bem mesmo quando suas listas contiverem milhões de itens.

Usando a função range()

A função range() do Python facilita a geração de uma série de números. Por exemplo, você pode usar a função range() para imprimir uma série de números como esta:

for valor in range (1, 5):

  print(valor)

Embora esse código pareça imprimir os números de 1 a 5, ele não imprime o número 5.

Neste exemplo, range() imprime apenas os números de 1 a 4. Este é outro resultado do comportamento off-by-one que você verá frequentemente em linguagens de programação. A função range() faz com que o Python comece a contar no primeiro valor que você der a ele, e pare quando atingir o segundo valor que você fornecer. Como ele para nesse segundo valor, a saída nunca contém o valor final, que seria 5 neste caso.

Para imprimir os números de 1 a 5, você usaria range(1, 6):

for valor in range(1, 6):

  print(valor)

Desta vez a saída começa em 1 e termina em 5.

Se sua saída for diferente do que você espera ao usar range(), tente ajustar seu valor final em 1.

Você também pode passar à range() apenas um argumento, e ele iniciará a sequência de números em 0. Por exemplo, range(6) retornaria os números de 0 a 5.

Usando range() para fazer uma lista de números

Se você quiser fazer uma lista de números, você pode converter os resultados de range() diretamente em uma lista usando a função list(). Quando você envolve list() em torno de uma chamada para a função range(), a saída será uma lista de números.

No exemplo da seção anterior, nós simplesmente imprimimos uma série de números. Podemos usar list() para converter esse mesmo conjunto de números em uma lista:

numeros = list(range(1, 6))

print(numeros)

Também podemos usar a função range() para dizer ao Python para pular números em um intervalo dado. Se você passar um terceiro argumento para range(), o Python usa esse valor como um tamanho de passo ao gerar números.

Por exemplo, veja como listar os números pares entre 1 e 10:

numeros_pares = list(range(2, 11, 2))

print(numeros_pares)

Neste exemplo, a função range() começa com o valor 2 e então adiciona 2 a esse valor. Ela adiciona 2 repetidamente até atingir ou passar o valor final.

Você pode criar quase qualquer conjunto de números que quiser usando a função range(). Por exemplo, considere como você pode fazer uma lista dos primeiros 10 números quadrados (ou seja, o quadrado de cada inteiro de 1 a 10). Em Python, dois asteriscos (**) representam expoentes. Veja como você pode colocar os primeiros 10 números quadrados em uma lista:

quadrados = []

for valor in range(1, 11):

  quadrado = valor ** 2  # 1

  quadrados.append(quadrado)  # 2

print(quadrados)

Começamos com uma lista vazia chamada quadrados. Então, dizemos ao Python para fazer um loop em cada valor de 1 a 10 usando a função range(). Dentro do loop, o valor atual é elevado à segunda potência e atribuído à variável quadrado (1). Cada novo valor de quadrado é então anexado à lista quadrados (2). Finalmente, quando o loop termina de ser executado, a lista de quadrados é impressa.

Para escrever este código de forma mais concisa, omita a variável temporária quadrado e anexe cada novo valor diretamente à lista:

quadrados = []

for valor in range(1, 11):

  quadrados.append(valor ** 2)

print(quadrados)

Esta linha faz o mesmo trabalho que as linhas dentro do loop for na listagem anterior. Cada valor no loop é elevado à segunda potência e então imediatamente anexado à lista de quadrados.

Você pode usar qualquer uma dessas abordagens quando estiver fazendo listas mais complexas. Às vezes, usar uma variável temporária torna seu código mais fácil de ler; outras vezes, torna o código desnecessariamente longo. Concentre-se primeiro em escrever um código que você entenda claramente e que faça o que você quer que ele faça. Então, procure abordagens mais eficientes ao revisar seu código.

Estatísticas simples com uma lista de números

Algumas funções Python são úteis ao trabalhar com listas de números. Por exemplo, você pode facilmente encontrar o mínimo, o máximo e a soma de uma lista de números:

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

print(min(numeros))

print(max(numeros))

print(sum(numeros))

List Comprehensions

A abordagem descrita anteriormente para gerar a lista quadrados consistia em usar três ou quatro linhas de código. Uma list comprehension permite que você gere essa mesma lista em apenas uma linha de código. Uma list comprehension combina o loop for e a criação de novos elementos em uma linha, e anexa automaticamente cada novo elemento. As list comprehensions nem sempre são apresentadas a iniciantes, mas eu as incluí aqui porque você provavelmente as verá assim que começar a olhar o código de outras pessoas.

O exemplo a seguir cria a mesma lista de números quadrados que você viu anteriormente, mas usa uma list comprehension:

quadrados = [valor ** 2 for valor in range(1, 11)]

print(quadrados)

Para usar essa sintaxe, comece com um nome descritivo para a lista, como quadrados. Em seguida, abra um conjunto de colchetes e defina a expressão para os valores que você deseja armazenar na nova lista. Neste exemplo, a expressão é valor ** 2, que eleva o valor à segunda potência. Em seguida, escreva um loop for para gerar os números que você deseja alimentar na expressão e feche os colchetes. O loop for neste exemplo é for valor in range(1, 11), que alimenta os valores de 1 a 10 na expressão valor ** 2. Observe que nenhum dois pontos é usado no final da instrução for. O resultado é a mesma lista de números quadrados que você viu antes.

É preciso prática para escrever suas próprias list comprehensions, mas você as achará valiosas quando se sentir confortável criando listas comuns. Quando estiver escrevendo três ou quatro linhas de código para gerar listas e começar a parecer repetitivo, considere escrever suas próprias list comprehensions.

Tente você mesmo!

Exercício 03: Use um loop for para imprimir os números de 1 a 20, inclusive.

Exercício 04: Faça uma lista dos números de um a um milhão e, em seguida, use um loop for para imprimir os números. (Se a saída estiver demorando muito, pare-a pressionando CTRL+C ou fechando a janela de saída).

Exercício 05: Faça uma lista de números de um a um milhão e, em seguida, use min() e max() para garantir que sua lista realmente comece em um e termine em um milhão. Além disso, use a função sum() para ver o quão rápido o Python pode adicionar um milhão de números. 

Exercício 06:  Use o terceiro argumento da função range() para criar uma lista dos números ímpares de 1 a 20. Use um loop for para imprimir cada número. 

Exercício 07: Faça uma lista dos múltiplos de 3, de 3 a 30. Use um loop for para imprimir os números na sua lista.

Exercício 08: Um número elevado à terceira potência é chamado de cubo. Por exemplo, o cubo de 2 é escrito como 2**3 em Python. Faça uma lista dos primeiros 10 cubos (ou seja, o cubo de cada inteiro de 1 a 10) e use um loop for para imprimir o valor de cada cubo.

Exercício 09: Use uma compreensão de lista para gerar uma lista dos 10 primeiros cubos.

Trabalhando com parte de uma lista

No Capítulo 3, você aprendeu como acessar elementos únicos em uma lista, e neste capítulo você aprendeu como trabalhar com todos os elementos em uma lista. Você também pode trabalhar com um grupo específico de itens em uma lista, chamado de fatiamento (slice, em inglês) em Python.

Fatiando uma lista

Para fazer uma fatia, você especifica o índice do primeiro e do último elementos com os quais deseja trabalhar. Assim como na função range(), o Python para um item antes do segundo índice que você especifica. Para gerar os três primeiros elementos em uma lista, você solicitaria os índices de 0 a 3, que retornariam os elementos 0, 1 e 2.

O exemplo a seguir envolve uma lista de jogadores de um time:

jogadores = ['pelé', 'messi', 'neymar', 'garrincha', 'ronaldo']

print(jogadores[0:3])

Este código imprime uma fatia da lista. A saída retém a estrutura da lista e inclui os três primeiros jogadores na lista.

Você pode gerar qualquer subconjunto de uma lista. Por exemplo, se você quiser o segundo, terceiro e quarto itens em uma lista, você começaria a fatia no índice 1 e terminaria no índice 4:

print(jogadores[1:4])

Desta vez a fatia começa com 'messi' e termina com 'ronaldo'.

Se você omitir o primeiro índice em uma fatia, o Python iniciará automaticamente sua fatia no início da lista:

print(jogadores[:4])

Sem um índice inicial, o Python começa no início da lista.

Uma sintaxe similar funciona se você quiser uma fatia que inclua o fim de uma lista. Por exemplo, se você quiser todos os itens do terceiro item até o último item, você pode começar com o índice 2 e omitir o segundo índice:

print(jogadores[2:])

Python retorna todos os itens do terceiro item até o final da lista.

Esta sintaxe permite que você produza todos os elementos de qualquer ponto da sua lista até o final, independentemente do tamanho da lista. Lembre-se de que um índice negativo retorna um elemento a uma certa distância do final de uma lista; portanto, você pode produzir qualquer fatia do final de uma lista. Por exemplo, se quisermos produzir os últimos três jogadores na lista, podemos usar a fatia jogadores[-3:]:

print(jogadores[-3:])

Isso imprime os nomes dos últimos três jogadores e continuará funcionando conforme a lista de jogadores muda de tamanho.

Você pode incluir um terceiro valor nos colchetes indicando uma fatia. Se um terceiro valor for incluído, isso informa ao Python quantos itens pular entre os itens no intervalo especificado.

Looping através de uma fatia

Você pode usar um slice em um loop for se quiser fazer um loop por um subconjunto dos elementos em uma lista. No próximo exemplo, fazemos um loop pelos três primeiros jogadores e imprimimos seus nomes como parte de uma lista simples:

jogadores = ['pelé', 'messi', 'neymar', 'garrincha', 'ronaldo']

print('Aqui estão os três primeiros jogadores do time:')

for jogador in jogadores[:3]:  # 1

  print(jogador.title())

Em vez de percorrer toda a lista de jogadores, o Python percorre apenas os três primeiros nomes (1).

Fatias são muito úteis em várias situações. Por exemplo, quando você está criando um jogo, você pode adicionar a pontuação final de um jogador a uma lista toda vez que ele termina de jogar. Você pode então obter as três maiores pontuações de um jogador classificando a lista em ordem decrescente e pegando uma fatia que inclui apenas as três primeiras pontuações. Quando você está trabalhando com dados, você pode usar fatias para processar seus dados em pedaços de um tamanho específico. Ou, quando você está construindo um aplicativo da web, você pode usar fatias para exibir informações em uma série de páginas com uma quantidade apropriada de informações em cada página.

Copiando uma lista

Muitas vezes, você vai querer começar com uma lista existente e fazer uma lista inteiramente nova com base na primeira. Vamos explorar como a cópia de uma lista funciona e examinar uma situação em que copiar uma lista é útil.

Para copiar uma lista, você pode fazer uma fatia que inclua toda a lista original omitindo o primeiro índice e o segundo índice ([:]). Isso diz ao Python para fazer uma fatia que começa no primeiro item e termina no último item, produzindo uma cópia da lista inteira.

Por exemplo, imagine que temos uma lista de nossas comidas favoritas e queremos fazer uma lista separada de comidas que um amigo gosta. Esse amigo gosta de tudo em nossa lista até agora, então podemos criar a lista dele copiando a nossa:

minhas_comidas = ['pizza', 'bolo de fubá', 'macarrão']

comidas_amigo = minhas_comidas[:]  # 1

print('Minhas comidas favoritas são:')

print(minhas_comidas)

print('\nComidas favoritas do meu amigo:')

print(comidas_amigo)

Primeiro, fazemos uma lista dos alimentos que gostamos chamada minhas_comidas. Então fazemos uma nova lista chamada comidas_amigo. Fazemos uma cópia de minhas_comidas pedindo uma fatia de minhas_comidas sem especificar nenhum índice (1), e atribuímos a cópia a comidas_amigo. Quando imprimimos cada lista, vemos que ambas contêm os mesmos alimentos.

Para provar que realmente temos duas listas separadas, adicionaremos um novo alimento a cada lista e mostraremos que cada lista mantém o controle dos alimentos favoritos da pessoa apropriada:

minhas_comidas = ['pizza', 'bolo de fubá', 'macarrão']

comidas_amigo = minhas_comidas[:]  # 1

minhas_comidas.append('frango')  # 2

comidas_amigo.append('sorvete')  # 3

print('Minhas comidas favoritas são:')

print(minhas_comidas)

print('\nComidas favoritas do meu amigo:')

print(comidas_amigo)

Copiamos os itens originais em minhas_comidas para a nova lista comidas_amigo, como fizemos no exemplo anterior (1). Em seguida, adicionamos um novo alimento a cada lista: adicionamos 'frango' a minhas_comidas (2), e adicionamos 'sorvete' a comidas_amigo (3). Em seguida, imprimimos as duas listas para ver se cada um desses alimentos está na lista apropriada.

A saída mostra que 'frango' agora aparece em nossa lista de comidas favoritas, mas 'sorvete' não. Podemos ver que 'sorvete' agora aparece na lista de nossos amigos, mas 'frango' não. Se tivéssemos simplesmente definido comidas_amigo igual a minhas_comidas, não produziríamos duas listas separadas. Por exemplo, aqui está o que acontece quando você tenta copiar uma lista sem usar uma fatia:

minhas_comidas = ['pizza', 'bolo de fubá', 'macarrão']

# --- Isso não funcionará --- #

comidas_amigo = minhas_comidas

minhas_comidas.append('frango')

comidas_amigo.append('sorvete')

print('Minhas comidas favoritas são:')

print(minhas_comidas)

print('\nComidas favoritas do meu amigo:')

print(comidas_amigo)

Em vez de atribuir uma cópia de minhas_comidas a comidas_amigo, definimos comidas_amigo igual a minhas_comidas. Essa sintaxe na verdade diz ao Python para associar a nova variável comidas_amigo à lista que já está associada a minhas_comidas, então agora ambas as variáveis ​​apontam para a mesma lista. Como resultado, quando adicionamos 'frango' a minhas_comidas, ele também aparecerá em comidas_amigo. Da mesma forma, 'sorvete' aparecerá em ambas as listas, embora pareça ter sido adicionado apenas a comidas_amigo.

A saída mostra que ambas as listas são iguais agora, o que não é o que queríamos.

Não se preocupe com os detalhes neste exemplo por enquanto. Se você estiver tentando trabalhar com uma cópia de uma lista e vir um comportamento inesperado, certifique-se de que está copiando a lista usando um fatiamento, como fizemos no primeiro exemplo.

Tente você mesmo!

Exercício 10: Usando um dos programas que você escreveu neste capítulo, adicione várias linhas ao final do programa que façam o seguinte:

• Imprima a mensagem Os três primeiros itens da lista são:. Em seguida, use uma fatia para imprimir os três primeiros itens da lista desse programa.

• Imprima a mensagem Os três itens do meio da lista são:. Em seguida, use uma fatia para imprimir três itens do meio da lista.

• Imprima a mensagem Os últimos três itens da lista são:. Em seguida, use uma fatia para imprimir os últimos três itens da lista.

Exercício 11: Comece com seu programa do exercício 1. Faça uma cópia da lista de pizzas e chame-a de pizzas_amigo. Então, faça o seguinte:

• Adicione uma nova pizza à lista original.

• Adicione uma pizza diferente à lista pizzas_amigo.

• Prove que você tem duas listas separadas. Imprima a mensagem Minhas pizzas favoritas são: e, em seguida, use um loop for para imprimir a primeira lista. Imprima a mensagem As pizzas favoritas do meu amigo são: e, em seguida, use um loop for para imprimir a segunda lista. Certifique-se de que cada nova pizza esteja armazenada na lista apropriada.

Tuplas

Listas funcionam bem para armazenar coleções de itens que podem mudar ao longo da vida de um programa. A capacidade de modificar listas é particularmente importante quando você está trabalhando com uma lista de usuários em um site ou uma lista de personagens em um jogo. No entanto, às vezes você vai querer criar uma lista de itens que não podem mudar. Tuplas permitem que você faça exatamente isso. Python se refere a valores que não podem mudar como imutáveis, e uma lista imutável é chamada de tupla.

Definindo uma Tupla

Uma tupla se parece com uma lista, exceto que você usa parênteses em vez de colchetes. Depois de definir uma tupla, você pode acessar elementos individuais usando o índice de cada item, assim como faria para uma lista.

Por exemplo, se temos um retângulo que deve sempre ter um determinado tamanho, podemos garantir que seu tamanho não mude colocando as dimensões em uma tupla:

dimensoes = (200, 50)

print(dimensoes[0])

print(dimensoes[1])

Definimos a tupla dimensoes, usando parênteses em vez de colchetes. Então imprimimos cada elemento na tupla individualmente, usando a mesma sintaxe que temos usado para acessar elementos em uma lista.

Vamos ver o que acontece se tentarmos alterar um dos itens na tupla dimensoes:

dimensoes = (200, 50)

dimensoes[0] = 250

Este código tenta alterar o valor da primeira dimensão, mas Python retorna um TypeError (erro de tipo). Como estamos tentando alterar uma tupla, o que não pode ser feito para esse tipo de objeto, Python nos diz que não podemos atribuir um novo valor a um item em uma tupla.

Isso é benéfico porque queremos que o Python gere um erro quando uma linha de código tentar alterar as dimensões do retângulo.

Tuplas são tecnicamente definidas pela presença de uma vírgula; os parênteses as fazem parecer mais organizadas e legíveis. Se você quiser definir uma tupla com um elemento, precisa incluir uma vírgula final:

minha_tupla = (3,)

Muitas vezes não faz sentido construir uma tupla com um elemento, mas isso pode acontecer quando as tuplas são geradas automaticamente.

Percorrendo todos os valores em uma tupla

Você pode percorrer todos os valores em uma tupla usando um loop for, assim como fez com uma lista:

dimensoes = (200, 50)

for dimensao in dimensoes:

  print(dimensao)

Python retorna todos os elementos na tupla, assim como faria para uma lista.

Escrevendo sobre uma tupla

Embora você não possa modificar uma tupla, você pode atribuir um novo valor a uma variável que representa uma tupla. Por exemplo, se quiséssemos alterar as dimensões deste retângulo, poderíamos redefinir a tupla inteira:

dimensoes = (200, 50)

print('Dimensões originais:')

for dimensao in dimensoes:

  print(dimensao)

dimensoes = (400, 100)

print('\nDimensões modificadas:')

for dimensao in dimensoes:

  print(dimensao)

As quatro primeiras linhas definem a tupla original e imprimem as dimensões iniciais. Então, associamos uma nova tupla à variável dimensoes e imprimimos os novos valores. O Python não levanta nenhum erro dessa vez, porque reatribuir uma variável é válido.

Quando comparadas com listas, tuplas são estruturas de dados simples. Use-as quando quiser armazenar um conjunto de valores que não devem ser alterados durante a vida de um programa.

Tente você mesmo!

Exercício 12: Um restaurante estilo buffet oferece apenas cinco alimentos básicos. Pense em cinco alimentos simples e armazene-os em uma tupla:

• Use um loop for para imprimir cada comida que o restaurante oferece.

• O restaurante muda seu menu, substituindo dois dos itens por comidas diferentes. Adicione uma linha que reescreva a tupla e, em seguida, use um loop for para imprimir cada um dos itens no menu revisado.

• Tente modificar um dos itens e certifique-se de que o Python rejeite a alteração.

Estilizando seu código

Agora que você está escrevendo programas mais longos, é uma boa ideia aprender a estilizar seu código consistentemente. Tire um tempo para tornar seu código o mais fácil possível de ler. Escrever código fácil de ler ajuda você a acompanhar o que seus programas estão fazendo e ajuda outros a entenderem seu código também.

Os programadores Python concordaram com uma série de convenções de estilo para garantir que o código de todos seja estruturado aproximadamente da mesma maneira. Depois de aprender a escrever código Python limpo, você deve ser capaz de entender a estrutura geral do código Python de qualquer outra pessoa, desde que sigam as mesmas diretrizes. Se você espera se tornar um programador profissional em algum momento, deve começar a seguir essas diretrizes o mais rápido possível para desenvolver bons hábitos.

O Guia de Estilo

Quando alguém quer fazer uma mudança na linguagem Python, ele escreve uma Proposta de Melhoria Python (em inglês, Python Enhancement Proposal, PEP). Uma das PEPs mais antigas é a PEP 8, que instrui os programadores Python sobre como estilizar seu código. A PEP 8 é bem longa, mas muito dela se relaciona a estruturas de codificação mais complexas do que as que você viu até agora.

O guia de estilo Python foi escrito com o entendimento de que o código é lido com mais frequência do que escrito. Você escreverá seu código uma vez e então começará a lê-lo conforme começa a depuração. Quando você adiciona recursos a um programa, você gastará mais tempo lendo seu código. Quando você compartilha seu código com outros programadores, eles também lerão seu código.

Dada a escolha entre escrever código que seja mais fácil de escrever ou código que seja mais fácil de ler, os programadores Python quase sempre o encorajarão a escrever código que seja mais fácil de ler. As diretrizes a seguir ajudarão você a escrever código claro desde o início.

Indentação

O PEP 8 recomenda que você use quatro espaços por nível de recuo. Usar quatro espaços melhora a legibilidade, deixando espaço para vários níveis de recuo em cada linha.

Em um documento de processamento de texto, as pessoas geralmente usam tabulações em vez de espaços para recuar. Isso funciona bem para documentos de processamento de texto, mas o interpretador Python fica confuso quando as tabulações são misturadas com espaços. Todo editor de texto fornece uma configuração que permite que você use a tecla TAB, mas depois converte cada tabulação em um número definido de espaços. Você definitivamente deve usar sua tecla TAB, mas também certifique-se de que seu editor esteja configurado para inserir espaços em vez de tabulações em seu documento.

Misturar tabulações e espaços no seu arquivo pode causar problemas muito difíceis de diagnosticar. Se você acha que tem uma mistura de tabulações e espaços, você pode converter todas as tabulações em um arquivo para espaços na maioria dos editores.

Comprimento da linha

Muitos programadores Python recomendam que cada linha tenha menos de 80 caracteres. Historicamente, essa diretriz se desenvolveu porque a maioria dos computadores conseguia encaixar apenas 79 caracteres em uma única linha em uma janela de terminal. Atualmente, as pessoas conseguem encaixar linhas muito maiores em suas telas, mas existem outros motivos para aderir ao comprimento de linha padrão de 79 caracteres.

Programadores profissionais geralmente têm vários arquivos abertos na mesma tela, e usar o comprimento de linha padrão permite que eles vejam linhas inteiras em dois ou três arquivos que estão abertos lado a lado na tela. O PEP 8 também recomenda que você limite todos os seus comentários a 72 caracteres por linha, porque algumas das ferramentas que geram documentação automática para projetos maiores adicionam caracteres de formatação no início de cada linha comentada.

As diretrizes do PEP 8 para comprimento de linha não são imutáveis, e algumas equipes preferem um limite de 99 caracteres. Não se preocupe muito com o comprimento da linha em seu código enquanto estiver aprendendo, mas esteja ciente de que as pessoas que estão trabalhando de forma colaborativa quase sempre seguem as diretrizes do PEP 8. A maioria dos editores permite que você configure uma dica visual, geralmente uma linha vertical na tela, que mostra onde estão esses limites.

Linhas em branco

Para agrupar partes do seu programa visualmente, use linhas em branco. Você deve usar linhas em branco para organizar seus arquivos, mas não faça isso excessivamente. Seguindo os exemplos fornecidos neste livro, você deve encontrar o equilíbrio certo. Por exemplo, se você tem cinco linhas de código que constroem uma lista e depois outras três linhas que fazem algo com essa lista, é apropriado colocar uma linha em branco entre as duas seções. No entanto, você não deve colocar três ou quatro linhas em branco entre as duas seções.

Linhas em branco não afetarão como seu código é executado, mas afetarão a legibilidade do seu código. O interpretador Python usa recuo horizontal para interpretar o significado do seu código, mas desconsidera o espaçamento vertical.

Outras Diretrizes de Estilo

O PEP 8 tem muitas recomendações de estilo adicionais, mas a maioria das diretrizes se refere a programas mais complexos do que o que você está escrevendo neste momento. Conforme você aprende estruturas Python mais complexas, compartilharei as partes relevantes das diretrizes do PEP 8.

Resumo

Neste capítulo, você aprendeu como trabalhar eficientemente com os elementos em uma lista. Você aprendeu como trabalhar em uma lista usando um loop for, como Python usa indentação para estruturar um programa e como evitar alguns erros comuns de recuo. Você aprendeu a fazer listas numéricas simples, bem como algumas operações que você pode executar em listas numéricas. Você aprendeu como fatiar uma lista para trabalhar com um subconjunto de itens e como copiar listas corretamente usando um fatiamento. Você também aprendeu sobre tuplas, que fornecem um grau de proteção a um conjunto de valores que não devem mudar, e como estilizar seu código cada vez mais complexo para torná-lo fácil de ler.

No Capítulo 5, você aprenderá a responder apropriadamente a diferentes condições usando instruções if. Você aprenderá a encadear conjuntos relativamente complexos de testes condicionais para responder apropriadamente exatamente ao tipo de situação ou informação que você está procurando. Você também aprenderá a usar instruções if ao percorrer uma lista para realizar ações específicas com elementos selecionados de uma lista.