Lista

Definição

Uma lista é uma coleção ordenada e mutável. É possível existir itens duplicados na lista.

• Exemplo de lista com itens diversos e sem repetição

x = [1, 'abc', 2.3]

• Exemplo de lista com itens repetidos

x = [1, 'abc', 1, 'abc', 2.3]

• Exemplo de lista dentro de lista

x = [1, 'abc', [4,5,6], 2.3]

• Exemplo de lista vazia

x = []

Índices

Pode-se acessar os itens de uma lista usando índices que começam com o valor zero.

x = [1, 'abc', [4,5,6], 2.3]
print('x[0] =', x[0])
print('x[1] =', x[1])
print('x[2] =', x[2])
print('x[3] =', x[3])
print('x[2][0] = ', x[2][0])
print('x[2][1] = ', x[2][1])
print('x[2][2] = ', x[2][2])

A execução do programa mostra que é possível acessar os itens de uma lista e os itens de uma lista que estão dentro de outra lista.

x[0] = 1
x[1] = abc
x[2] = [4, 5, 6]
x[3] = 2.3
x[2][0] = 4
x[2][1] = 5
x[2][2] = 6

Abaixo um programa onde temos três listas, uma dentro da outra.

x = [1, 'abc', [4,['a','b','c'], 5 ,6], 2.3]
print('x[2][1][0] = ', x[2][1][0])
print('x[2][1][1] = ', x[2][1][1])
print('x[2][1][2] = ', x[2][1][2])

A resposta do programa é mostrada abaixo.

x[2][1][0] = a
x[2][1][1] = b
x[2][1][2] = c

É possível usar índices negativos. Neste caso, os índices são numerados a partir de -1 indo do item mais à direita para o item mais à esquerda da lista.

x = [1, 'abc', [4, 5 ,6], 2.3]
print('x[-1] = ', x[-1])
print('x[-2] = ', x[-2])
print('x[-3] = ', x[-3])
print('x[-4] = ', x[-4])
print('x[-2][-1] = ', x[-2][-1])
print('x[-2][-2] = ', x[-2][-2])
print('x[-2][-3] = ', x[-2][-3])

O resultado da execução do programa é mostrado abaixo.

x[-1] = 2.3
x[-2] = [4, 5, 6]
x[-3] = abc
x[-4] = 1
x[-2][-1] = 6
x[-2][-2] = 5
x[-2][-3] = 4

É possível misturar índices positivos e negativos.

x = [1, 'abc', [4, 5 ,6], 2.3]
print('x[-2][0] = ', x[-2][0])
print('x[-2][1] = ', x[-2][1])
print('x[-2][2] = ', x[-2][2])
print('x[2][-1] = ', x[2][-1])
print('x[2][-2] = ', x[2][-2])
print('x[2][-3] = ', x[2][-3])

A resposta do programa é

x[-2][0] = 4
x[-2][1] = 5
x[-2][2] = 6
x[2][-1] = 6
x[2][-2] = 5
x[2][-3] = 4

Pode-se usar slice (fatia) para selecionar vários itens de uma lista. Um slice usa o formato definido a seguir.

início : fim : incremento

O programa abaixo apresenta vários exemplos do uso de slice.

x = [1, 'abc', [4, 5 ,6], 2.3]
print('1 - x[:] = ', x[:])
print('2 - x[0:4] = ', x[0:4])
print('3 - x[1:] = ', x[1:])
print('4 - x[1:3] = ', x[1:3])
print('5 - x[:2] = ', x[:2])
print('6 - x[::2] = ', x[::2])
print('7 - x[:2:2] = ', x[:2:2])
print('8 - x[-1::-1] = ', x[-1::-1])

A resposta do programa é mostrada abaixo.

1 - x[:] = [1, 'abc', [4, 5, 6], 2.3]
2 - x[0:4] = [1, 'abc', [4, 5, 6], 2.3]
3 - x[1:] = ['abc', [4, 5, 6], 2.3]
4 - x[1:3] = ['abc', [4, 5, 6]]
5 - x[:2] = [1, 'abc']
6 - x[::2] = [1, [4, 5, 6]]
7 - x[:2:2] = [1]
8 - x[-1::-1] = [2.3, [4, 5, 6], 'abc', 1]

• No primeiro slice, nenhum índice é definido, usa-se então toda a lista com incremento 1.
• O slice 2 mostra o mesmo resultado do slice anterior. Note que, embora os índices da lista sejam de zero a 3, o segundo índice é 4. Neste caso, para qualquer valor maior que 3, percorre-se toda a lista. O uso do valor 3 faria com que o último item da lista não fosse considerado.
• O slice 3 mostra todos os itens da lista a partir do item com índice 1.
• O slice 4 vai do item com índice 1 até o item com índice 2 (não inclui o item com índice 3).
• O slice 5 mostra os itens desde o início da lista até o item com índice 1 (não inclui o item com índice 2)
• O slice 6 começa no início da lista mostrando apenas os itens com índices pares (0, 2, 4, …) por causa do incremento 2.
• O slice 7 começa no início da lista, vai até o item de índice 1 (não inclui o item com índice 2) e usa incremento 2. Neste caso, apenas o item com índice 1 atende à definição.
• O slice 8 faz uso de índices negativos e mostra os itens da lista começando com o último item até chegar no primeiro.

Atribuição e Conteúdo

Uma variável pode receber uma lista, parte de uma lista ou apenas um item da lista.

x = [1, 'abc', [4, 5 ,6], 2.3]
a = x
b = x[1:3]
c = x[1]
print('a = ', a)
print('b = ', b)
print('c = ', c)

A resposta do programa é

a = [1, 'abc', [4, 5, 6], 2.3]
b = ['abc', [4, 5, 6]]
c = abc

Pode-se fazer atribuição múltipla dos itens de uma lista.

x = [1, 'abc', [4, 5 ,6], 2.3]
a, b , c , d = x
print('a = ', a)
print('b = ', b)
print('c = ', c)
print('d = ', d)

O resultado é mostrado abaixo. É importante destacar que a quantidade de variáveis e o tamanho da lista devem ser exatamente iguais

a = 1
b = abc
c = [4, 5, 6]
d = 2.3

Para mostrar todos os itens de uma lista, pode-se usar uma das formas mostradas no programa abaixo. No primeiro caso, a variável i representa cada item da lista. No segundo caso, a variável i representa os índices da lista.

x = [1, 'abc', [4, 5 ,6], 2.3]
for i in x:
    print(i)
for i in range(len(x)):
    print(x[i])

Pode-se também verificar se um determinado dado está na lista. O programa abaixo faz a verificação para três tipos de dados de uma lista: inteiro, string e lista.

x = [1, 'abc', [4, 5 ,6], 2.3]
if 1 in x:
   print('1 está em x')
if 'abc' in x:
   print('\'abc\' está em x')
if [4, 5, 6] in x:
   print('[4,5,6] está em x')

O resultado do programa é mostrado abaixo.

1 está em x
'abc' está em x
[4,5,6] está em x

Concatenação e Repetição

Pode-se usar o operador ‘+’ para concatenar listas e o operador ‘*’ para repetir listas.

x = [1, 2, 3]
y = ['a', 'b', 'c']
print('1 - x + y =', x + y)
print('2 - y + x =', y + x)
print('3 - x + 2 * y =', x + 2*y)
print('4 - x[1] + y[0] =', x[1:2] + y[0:1])
print('5 - x[1:2] + y[0:1] =', x[1:2] + y[0:1])
print('6 - x[1:2] + y[0] =', x[1:2] + y[0:1])
print('7 - 2 * (x[1] + y[0]) =', 2*(x[1:2] + y[0:1]))

A resposta do programa pode ser vista abaixo.

1 - x + y = [1, 2, 3, 'a', 'b', 'c']
2 - y + x = ['a', 'b', 'c', 1, 2, 3]
3 - x + 2 * y = [1, 2, 3, 'a', 'b', 'c', 'a', 'b', 'c']
4 - x[1] + y[0] = [2, 'a']
5 - x[1:2] + y[0:1] = [2, 'a']
6 - x[1:2] + y[0] = [2, 'a']
7 - 2 * (x[1] + y[0]) = [2, 'a', 2, 'a']

• O exemplo 1 mostra que a lista final é composta dos itens da lista x seguidos dos itens da lista y.
• O exemplo 2 mostra que a lista final é composta dos itens da lista y seguidos dos itens da lista x.
• No exemplo 3, o resultado corresponde aos itens da lista x e a repetição (duas vezes) dos itens da lista y.
• Os exemplos 4, 5 e 6 mostram o mesmo resultado. Portanto, é possível selecionar itens de diferentes lista para formar uma outra lista.
• O exemplo 7 mostra a definição de uma lista a partir da repetição e concatenação de itens de diferentes listas.

Observação: uma lista não é um vetor (array). Isto pode ser verificado pela forma como o operador ‘+’ funciona com as listas. Se fosse um vetor, os valores dos itens de uma lista seriam somados aos valores dos itens da outra lista. Mas como vimos acima, isso não acontece. Use a biblioteca NumPy para definir vetores em Python.

Métodos

Existem vários métodos que podem ser usados com listas.

• Método append() – adiciona um item ao final de uma lista.

x = [1, 2, 3]
y = ['a', 'b', 'c']
x.append(32.4)
x.append('teste')
x.append(y)
print(x)

O resultado é mostrado abaixo. Note que ao incluir uma lista, o método inclui toda a lista e não apenas os itens da lista.

[1, 2, 3, 32.4, 'teste', ['a', 'b', 'c']]

• Método insert() – adiciona um item em uma determinada posição da lista.

x = ['a', 'b', 'c']
x.insert(1, 'teste')
x.insert(0, 23.9)
x.insert(2,[1,2,3])
print(x)

O resultado do programa mostra que o índice da lista pode variar durante a execução. A string ‘teste’ foi incluída na posição 1, mas ao final do programa a string tinha índice 3.

[23.9, 'a', [1, 2, 3], 'teste', 'b', 'c']

• Método remove() – remove um item da lista.

x =[4, 9, 6, 9, 1, 9, 0]
x.remove(9)
print(x)

O resultado do programa mostra que apenas o primeiro item igual a 9 foi removido.

[4, 6, 9, 1, 9, 0]

O programa abaixo faz a deleção de todos os itens iguais a 9.

x =[4, 9, 6, 9, 1, 9, 0]
for i in x:
   if i == 9:
      x.remove(i)
print(x)

• Método pop() – remove um determinado item da lista.

x =[4, 9, 6, 9, 1]
x.pop(2)
print(x)

O resultado da execução mostra que apenas o item com índice 2 foi removido.

[4, 9, 9, 1]

• Método clear() – remove todos os elementos de uma lista.

x =[4, 9, 6, 9, 1]
x.clear()
print(x)

A lista x, ao final do programa, é uma lista vazia.

• Método index() – retorna o índice de um determinado item da lista.

x =[4, 9, 6, 9, 1]
print(x.index(9))

Neste exemplo, o resultado é o índice 1, pois o programa retorna o índice do primeiro item da lista com valor 9.

• Método count() – conta o número de itens com um determinado valor na lista.

x =[4, 9, 6, 9, 1]
print(x.count(9))

O programa retorna o valor 2, pois existem dois itens com esse valor.

• Método copy() – copia uma lista.

x =[4, 9, 6]
y = x.copy()
print(y)

A lista y é uma cópia da lista x.

• Método extend() – adiciona elementos de uma lista ao final de outra lista.

x = [1, 2, 3]
y = ['a', 'b', 'c']
x.extend(y)
y.extend(x[2:4])
print(x)
print(y)

O resultado é

[1, 2, 3, 'a', 'b', 'c']
['a', 'b', 'c', 3, 'a']

• Método sort() – ordena itens de uma lista.

x = ['4', '9', 'd', 'a', '0', 'bat']
y = [9, 3.2, 0, 4.1]
x.sort()
y.sort()
print(x)
print(y)

O resultado é mostrado abaixo. A ordenação só é possível com valores de um mesmo tipo (não é possível ordenar uma lista que tenha números e strings).

['0', '4', '9', 'a', 'bat', 'd']
[0, 3.2, 4.1, 9]

• Método reverse() – inverte a ordem dos itens da lista.

x =[4, 9, 6]
x.reverse()
print(x)

O resultado é

[6, 9, 4]

• Método list() – cria uma lista. É o método construtor de listas.

x = list(['4', '9', 'd', 'a'])
y = list(('4', '9', 'd', 'a'))
print(x)
print(y)

As variáveis x e y possuem listas com os mesmos itens. O uso de parêntesis ou de colchetes não altera a criação da lista.

List Comprehension

List comprehension (Compreensão de lista) é uma forma simples e elegante de criar listas de forma concisa. A sintaxe básica é mostrada abaixo

[expressão for item in lista]

onde se deve aplicar a expressão em cada item da lista.

• Para criar uma lista unidimensional com 4 itens numerados de 1 a 4, podemos usar o programa abaixo.

n = 4
vetor = []
for i in range(n):
  vetor.append(i + 1)
print(vetor)

Podemos obter o mesmo resultado usando list comprehension.

n = 4
vetor = [i+1 for i in range(n)]
print(vetor)

O resultado dos dois programas acima é o mesmo.

[1, 2, 3, 4]

• Para criar uma lista bidimensional 4 \times 3 com os itens numerados de acordo com as duas dimensões, podemos definir

import pprint
n1 = 4
n2 = 3
matriz = []
for i in range(n1):
   linha = []
   for j in range(n2):
      linha.append(i*n2+j+1)
   matriz.append(linha)
pprint.pprint(matriz,width=20)

A list comprehension correspondente é mostrada abaixo.

import pprint
n1 = 4
n2 = 3
matriz = [[i*n2+j+1 for j in range(n2)] for i in range(n1)]
pprint.pprint(matriz,width=20)

O resultado dos dois programas é mostrado abaixo. Note que foi usada a biblioteca pprint para formatar a saída do comando e facilitar a visualização.

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

• Para criar uma lista tridimensional 4 \times 3 \times 2 com os itens numerados de acordo com as 3 dimensões, podemos usar o código abaixo.

import pprint
n1 = 4
n2 = 3
n3 = 2
matriz = []
for i in range(n1):
   linha = []
   for j in range(n2):
      celula = []
      for k in range(n3):
         celula.append(i*n2*n3+j*n3+k+1)
      linha.append(celula)
   matriz.append(linha)
pprint.pprint(matriz)

A list comprehension correspondente ao código acima é

import pprint
n1 = 4
n2 = 3
n3 = 2
matriz = [[[i*n2*n3+j*n3+k+1 for k in range(n3)] for j in range(n2)] for i in range(n1)]
pprint.pprint(matriz)

O resultado obtido pelos programas é mostrado a seguir.

[[[1, 2], [3, 4], [5, 6]],
[[7, 8], [9, 10], [11, 12]],
[[13, 14], [15, 16], [17, 18]],
[[19, 20], [21, 22], [23, 24]]]

• É possível usar a expressão else para indicar uma alternativa para a expressão definida com if. No exemplo abaixo, a lista terá valor igual a 1 se os dois índices têm valores iguais e zero nos outros casos.

import pprint
n = 4
matriz = [[1 if j == i else 0 for j in range(n) ] for i in range(n)]
pprint.pprint(matriz, width=20)

O resultado obtido é mostrado abaixo. Note que a lista corresponde a uma matriz Identidade.

[[1, 0, 0, 0],
 [0, 1, 0, 0],
 [0, 0, 1, 0],
 [0, 0, 0, 1]]

• É possível fazer uso de várias expressões if e else. No exemplo mostrado a seguir, os valores acima da diagonal recebem 2 e os valores abaixo da diagonal recebem 0.

import pprint
n = 4
matriz = [[1 if j == i else 0 if i >= j else 2 for j in range(n) ] for i in range(n)]
pprint.pprint(matriz, width=20)

A resposta do programa é

[[1, 2, 2, 2],
 [0, 1, 2, 2],
 [0, 0, 1, 2],
 [0, 0, 0, 1]]

Identificador

Ao fazer uma cópia de uma lista é preciso ter cuidado, pois pode-se apenas estar dando mais um nome para uma mesma lista.

a = [1, 2, 3]
b = [1, 2, 3]
c = a
d = a.copy()
print('id(a) =', id(a))
print('id(b) =', id(b))
print('id(c) =', id(c))
print('id(d) =', id(d))
c[1] = 'teste'
print('a =', a)
print('b =', b)
print('c =', c)
print('d =', d)

O resultado obtido com o programa mostra que as variáveis a e c são dois nomes para a mesma lista (note que possuem a mesma identificação). Por isso, ao modificar um item da lista c, a lista a também é modificada.

id(a) = 140439918762120
id(b) = 140439918762184
id(c) = 140439918762120
id(d) = 140439918762312
a = [1, 'teste', 3]
b = [1, 2, 3]
c = [1, 'teste', 3]
d = [1, 2, 3]

Entretanto, ao alterar uma lista dentro de uma lista, a resposta é diferente.

a = ['a', [1,2,3], 32.6]
b = ['a', [1,2,3], 32.6]
c = a
d = a.copy()
print('id(a) =', id(a))
print('id(b) =', id(b))
print('id(c) =', id(c))
print('id(d) =', id(d))
c[1][2] = 'teste'
print('a =', a)
print('b =', b)
print('c =', c)
print('d =', d)

A resposta mostra que, embora a lista d tenha uma identificação diferente das listas a e c, quando um item da lista interna de c é alterada, a lista d também é alterada.

id(a) = 139924089657544
id(b) = 139924089657608
id(c) = 139924089657544
id(d) = 139924089657736
a = ['a', [1, 2, 'teste'], 32.6]
b = ['a', [1, 2, 3], 32.6]
c = ['a', [1, 2, 'teste'], 32.6]
d = ['a', [1, 2, 'teste'], 32.6]

O problema é como o método copy() funciona. Ao fazer uma cópia, o método cria uma nova lista e copia os itens, inclusive as referências que a lista original possui. Assim as listas a, c e d apontam para uma mesma lista interna.

Para resolver este problema, pode-se usar o método deepcopy() da biblioteca copy.

import copy
a = ['a', [1,2,3], 32.6]
b = ['a', [1,2,3], 32.6]
c = a
d = copy.deepcopy(a)
c[1][2] = 'teste'
print('a =', a)
print('b =', b)
print('c =', c)
print('d =', d)

O resultado agora é diferente.

a = ['a', [1, 2, 'teste'], 32.6]
b = ['a', [1, 2, 3], 32.6]
c = ['a', [1, 2, 'teste'], 32.6]
d = ['a', [1, 2, 3], 32.6]