Compreendendo Listas no Python 3

Introdução

A list is a data structure in Python that is a mutable, or changeable, ordered sequence of elements. Each element or value that is inside of a list is called an item. Just as strings are defined as characters between quotes, lists are defined by having values between square brackets [ ].

Listas são ótimas para usar quando você quer trabalhar com muitos valores relacionados. Elas permitem que você mantenha dados juntos que pertencem juntos, condense seu código e execute os mesmos métodos e operações em vários valores de uma vez.

Ao pensar sobre listas em Python e outras estruturas de dados que são tipos de coleções, é útil considerar todas as diferentes coleções que você tem no seu computador: sua variedade de arquivos, suas playlists de músicas, seus favoritos do navegador, seus e-mails, a coleção de vídeos aos quais você pode acessar em um serviço de streaming e muito mais.

Pré-requisitos

Você deve ter o Python 3 instalado e um ambiente de programação configurado no seu computador ou servidor. Se você não tiver um ambiente de programação configurado, pode consultar os guias de instalação e configuração para um ambiente de programação local ou para um ambiente de programação no seu servidor apropriado para o seu sistema operacional (Ubuntu, CentOS, Debian, etc.).

Listas de Strings

Para começar, vamos criar uma lista que contenha itens do tipo de dados string:

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

Ao imprimir a lista, a saída responde exatamente como a lista que criamos:

print(sea_creatures)

Output
['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

Como uma sequência ordenada de elementos, cada item em uma lista pode ser chamado individualmente, através de indexação. Listas são um tipo de dados composto por partes menores e são muito flexíveis porque podem ter valores adicionados, removidos e alterados. Quando você precisa armazenar muitos valores ou iterar sobre valores, e deseja ser capaz de modificar prontamente esses valores, provavelmente você vai querer trabalhar com tipos de dados de lista.

Neste tutorial, vamos passar por algumas das maneiras pelas quais podemos trabalhar com listas em Python.

Indexando Listas

Cada item em uma lista corresponde a um número de índice, que é um valor inteiro, começando com o número de índice 0.

Para a lista sea_creatures, a quebra do índice parece com isso:

O primeiro item, a string 'shark' começa no índice 0, e a lista termina no índice 4 com o item 'anemone'.

Porque cada item em uma lista do Python tem um número de índice correspondente, somos capazes de acessar e manipular listas da mesma forma que podemos com outros tipos de dados sequenciais.

Agora podemos chamar um item discreto da lista referindo-se ao seu número de índice:

print(sea_creatures[1])

Output
cuttlefish

Os números de índice para esta lista variam de 0 a 4, como mostrado na tabela acima. Portanto, para chamar qualquer um dos itens individualmente, nos referiríamos aos números de índice assim:

sea_creatures[0] = 'shark'
sea_creatures[1] = 'cuttlefish'
sea_creatures[2] = 'squid'
sea_creatures[3] = 'mantis shrimp'
sea_creatures[4] = 'anemone'

Se chamarmos a lista sea_creatures com um número de índice maior que 4, estará fora de alcance pois não será válido:

print(sea_creatures[18])

Output
IndexError: list index out of range

Além dos números de índice positivos, também podemos acessar itens da lista com um número de índice negativo, contando de trás para frente a partir do final da lista, começando em -1. Isso é especialmente útil se tivermos uma lista longa e quisermos identificar um item em direção ao final de uma lista.

Para a mesma lista sea_creatures, a decomposição do índice negativo parece assim:

Portanto, se quisermos imprimir o item 'squid' usando seu número de índice negativo, podemos fazer assim:

print(sea_creatures[-3])

Output
squid

Podemos concatenar itens de string em uma lista com outras strings usando o operador +:

print('Sammy is a ' + sea_creatures[0])

Output
Sammy is a shark

Conseguimos concatenar o item de string no índice número 0 com a string 'Sammy é um '. Também podemos usar o operador + para concatenar 2 ou mais listas juntas.

Com números de índice que correspondem a itens dentro de uma lista, podemos acessar cada item de uma lista discretamente e trabalhar com esses itens.

Modificando Itens em Listas

Podemos usar indexação para alterar itens dentro da lista, definindo um número de índice igual a um valor diferente. Isso nos dá maior controle sobre as listas, pois somos capazes de modificar e atualizar os itens que elas contêm.

Se quisermos alterar o valor da string do item no índice 1 de 'peixe-cavalo' para 'polvo', podemos fazer assim:

sea_creatures[1] = 'octopus'

Agora, quando imprimimos criaturas_do_mar, a lista será diferente:

print(sea_creatures)

Output
['shark', 'octopus', 'squid', 'mantis shrimp', 'anemone']

Também podemos alterar o valor de um item usando um número de índice negativo:

sea_creatures[-3] = 'blobfish'
print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']

Agora 'peixe-gota' substituiu 'lula' no número de índice negativo de -3 (que corresponde ao número de índice positivo de 2).

Ser capaz de modificar itens em listas nos dá a capacidade de alterar e atualizar listas de forma eficiente.

Fatiamento de Listas

Também podemos chamar alguns itens da lista. Digamos que queremos apenas imprimir os itens do meio de sea_creatures, podemos fazer isso criando um pedaço. Com fatias, podemos chamar vários valores criando um intervalo de números de índice separados por dois pontos [x:y]:

print(sea_creatures[1:4])

Output
['octopus', 'blobfish', 'mantis shrimp']

Ao criar uma fatia, como em [1:4], o primeiro número de índice é onde a fatia começa (inclusivo), e o segundo número de índice é onde a fatia termina (exclusivo), é por isso que em nosso exemplo acima os itens nas posições 1, 2 e 3 são os itens que são impressos.

Se quisermos incluir qualquer extremidade da lista, podemos omitir um dos números na sintaxe lista[x:y]. Por exemplo, se quisermos imprimir os primeiros 3 itens da lista sea_creatures — que seriam 'shark', 'octopus', 'blobfish' — podemos fazer isso digitando:

print(sea_creatures[:3])

Output
['shark', 'octopus', 'blobfish']

Isso imprimiu o início da lista, parando logo antes do índice 3.

Para incluir todos os itens no final de uma lista, inverteríamos a sintaxe:

print(sea_creatures[2:])

Output
['blobfish', 'mantis shrimp', 'anemone']

Também podemos usar números de índice negativos ao fatiar listas, semelhante aos números de índice positivos:

print(sea_creatures[-4:-2])
print(sea_creatures[-3:])

Output
['octopus', 'blobfish']
['blobfish', 'mantis shrimp', 'anemone']

O último parâmetro que podemos usar com o fatiamento é chamado de passo, que se refere a quantos itens avançar após o primeiro item ser recuperado da lista. Até agora, omitimos o parâmetro de passo, e o Python padrão para o passo é 1, para que cada item entre dois números de índice seja recuperado.

A sintaxe para esta construção é lista[x:y:z], com z referindo-se ao passo. Vamos fazer uma lista maior, então fatiá-la e dar ao passo um valor de 2:

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

print(numbers[1:11:2])

Output
[1, 3, 5, 7, 9]

Nossa construção números[1:11:2] imprime os valores entre os números de índice inclusive de 1 e exclusivo de 11, então o valor de passo de 2 diz ao programa para imprimir apenas a cada outro item.

Podemos omitir os dois primeiros parâmetros e usar apenas o passo como um parâmetro com a sintaxe lista[::z]:

print(numbers[::3])

Output
[0, 3, 6, 9, 12]

Ao imprimir a lista números com o passo definido como 3, apenas cada terceiro item é impresso:

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

O fatiamento de listas com números de índice positivos e negativos e indicando o passo nos fornece o controle para manipular listas e obter a saída que estamos tentando alcançar.

Modificando Listas com Operadores

Operadores podem ser usados para fazer modificações em listas. Vamos revisar o uso dos operadores + e * e suas formas compostas += e *=.

O operador + pode ser usado para concatenar duas ou mais listas juntas:

sea_creatures = ['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']
oceans = ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

print(sea_creatures + oceans)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

Porque o operador + pode concatenar, ele pode ser usado para adicionar um item (ou vários) em forma de lista ao final de outra lista. Lembre-se de colocar o item entre colchetes:

sea_creatures = sea_creatures + ['yeti crab']
print (sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

O operador * pode ser usado para multiplicar listas. Talvez você precise fazer cópias de todos os arquivos em um diretório em um servidor, ou compartilhar uma lista de reprodução com amigos — nestes casos, você precisaria multiplicar coleções de dados.

Vamos multiplicar a lista sea_creatures por 2 e a lista oceans por 3:

print(sea_creatures * 2)
print(oceans * 3)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']
['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

Ao usar o operador *, podemos replicar nossas listas pelo número de vezes que especificarmos.

Também podemos usar formas compostas dos operadores + e * com o operador de atribuição =. Os operadores compostos += e *= podem ser usados para popular listas de forma rápida e automatizada. Você pode usar esses operadores para preencher listas com marcadores que você pode modificar posteriormente com entrada fornecida pelo usuário, por exemplo.

Vamos adicionar um item em forma de lista à lista sea_creatures. Este item atuará como um marcador e gostaríamos de adicionar este item marcador várias vezes. Para fazer isso, vamos usar o operador += com um loop for.

for x in range(1,4):
    sea_creatures += ['fish']
    print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish', 'fish']

Para cada iteração do loop for, um item extra da lista 'fish' é adicionado à lista original sea_creatures.

O operador *= se comporta de maneira semelhante:

sharks = ['shark']

for x in range(1,4):
    sharks *= 2
    print(sharks)

Output
['shark', 'shark']
['shark', 'shark', 'shark', 'shark']
['shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

Os operadores + e * podem ser usados para concatenar listas e multiplicar listas. Os operadores compostos += e *= podem concatenar listas e multiplicar listas e passar a nova identidade para a lista original.

Removendo um Item de uma Lista

Itens podem ser removidos das listas usando a declaração del. Isso irá excluir o valor no número de índice que você especificar dentro de uma lista.

Da lista sea_creatures, vamos remover o item 'octopus'. Este item está localizado na posição do índice 1. Para remover o item, vamos usar a declaração del e depois chamar a variável da lista e o número de índice desse item:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1]
print(sea_creatures)

Output
['shark', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

Agora o item na posição do índice 1, a string 'octopus', não está mais em nossa lista sea_creatures.

Também podemos especificar um intervalo com a declaração del. Digamos que queríamos remover não apenas o item 'octopus', mas também 'blobfish' e 'mantis shrimp' também. Podemos chamar um intervalo em sea_creatures com a declaração del para realizar isso:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1:4]
print(sea_creatures)

Output
['shark', 'anemone', 'yeti crab']

Ao usar um intervalo com a instrução del, conseguimos remover os itens entre o número do índice 1 (inclusive) e o número do índice 4 (exclusivo), deixando-nos com uma lista de 3 itens após a remoção de 3 itens.

A instrução del permite remover itens específicos do tipo de dados lista.

Construindo uma Lista com Itens de Lista

As listas podem ser definidas com itens compostos por listas, com cada lista entre colchetes fechada dentro dos colchetes maiores da lista pai:

sea_names = [['shark', 'octopus', 'squid', 'mantis shrimp'],['Sammy', 'Jesse', 'Drew', 'Jamie']]

Essas listas dentro de listas são chamadas de listas aninhadas.

Para acessar um item dentro dessa lista, precisaremos usar múltiplos índices:

print(sea_names[1][0])
print(sea_names[0][0])

Output
Sammy
shark

A primeira lista, por ser igual a um item, terá o número do índice 0, que será o primeiro número na construção, e a segunda lista terá o número do índice 1. Dentro de cada lista aninhada interna, haverá números de índice separados, que chamaremos de segundo número de índice:

sea_names[0][0] = 'shark'
sea_names[0][1] = 'octopus'
sea_names[0][2] = 'squid'
sea_names[0][3] = 'mantis shrimp'

sea_names[1][0] = 'Sammy'
sea_names[1][1] = 'Jesse'
sea_names[1][2] = 'Drew'
sea_names[1][3] = 'Jamie'

Ao trabalhar com listas de listas, é importante ter em mente que será necessário se referir a mais de um número de índice para acessar itens específicos dentro da lista aninhada relevante.

Conclusão

O tipo de dados lista é um tipo de dados flexível que pode ser modificado ao longo do curso do seu programa. Este tutorial abrangeu os recursos básicos das listas, incluindo indexação, fatiamento, modificação e concatenação de listas.

A partir daqui, você pode descobrir mais sobre como trabalhar com listas em Python lendo “Como Usar Métodos de Lista”, e sobre compreensões de lista para criar listas com base em listas existentes. Para saber mais sobre tipos de dados em geral, você pode ler nosso tutorial “Compreendendo Tipos de Dados”.