Tuplos e listas

As notas [12, 15] formam uma lista, uma sequência onde podemos acrescentar 18 ou substituir 12 por 20, enquanto o tuplo (12, 15) conserva os valores por ordem sem permitir alterar as suas posições; essa diferença chama-se mutabilidade.

Sequências e tuplos

Strings, listas e tuplos suportam len, índices, fatias e pertença com in. Uma lista escreve-se [12, 15]; um tuplo pode escrever-se (12, 15). A vírgula é que cria o tuplo: (12,) tem um elemento, mas (12) é apenas o inteiro 12 entre parênteses.

O desempacotamento associa elementos a nomes: x, y = (3, 4). Nesta forma, o número de nomes tem de coincidir com o número de elementos. a, b = b, a troca os valores porque o lado direito é calculado antes das atribuições.

Um tuplo é imutável, mas pode conter objetos mutáveis. Em registo = ("Ana", [12, 15]), não podes substituir registo[0], mas podes alterar a lista registo[1]. Imutabilidade do recipiente não significa imutabilidade de todos os objetos alcançáveis a partir dele.

Alterar uma lista

Segue uma lista concreta desde o início:

xs = [10, 20]
xs.append(30)
xs[0] = 11
print(xs)

A lista passa por [10, 20], depois [10, 20, 30] e depois [11, 20, 30]. append altera a própria lista; a atribuição por índice substitui um elemento existente.

append, extend, insert, remove, sort e reverse devolvem None. Não escrevas xs = xs.append(4), porque acabarias com xs associado a None.

Por exemplo, ys = xs.append(4) guarda None em ys e altera xs. xs + ys cria outra lista. Não alteres o comprimento da lista que estás a percorrer sem uma estratégia explícita; retirar um elemento pode deslocar o seguinte e fazê-lo escapar ao ciclo.

Alias contra cópia, igualdade contra identidade

b = a não copia a lista. Cria outro nome para o mesmo objeto, um alias. a == b compara conteúdos; a is b testa se os nomes referem o mesmo objeto.

notas = [12, 15]
alias = notas
copia = notas.copy()
alias.append(18)
copia[0] = 20
print(notas)
print(copia)
print(alias is notas, copia is notas)
print([1, 2] == [1, 2])

append altera a lista partilhada por notas e alias, enquanto a alteração em copia atinge outra lista. Dois objetos distintos podem ter conteúdo igual.

A identidade ajuda a seguir a partilha, mas um cálculo que só depende dos valores não deve depender dela.

Listas de listas e cópia superficial

a.copy() e a[:] criam uma cópia superficial. Copiam o recipiente, mantendo referências aos elementos. Se os elementos forem listas, continuam partilhados.

matriz = [[1, 2], [3, 4]]
copia = matriz.copy()
copia[0][0] = 9
print(matriz)
print(copia)

As duas primeiras saídas contêm o 9 porque a primeira linha é partilhada. Distingue as duas operações sobre a cópia: copia[0] = [9, 9] substituiria a referência guardada na cópia e deixaria a matriz intacta, enquanto copia[0][0] = 9 altera a linha partilhada e aparece nas duas listas. Para copiar cada linha sem usar ainda compreensões, constrói a lista nova com um ciclo:

independente = []
for linha in matriz:
    independente.append(linha.copy())

Cada iteração acrescenta a cópia de uma linha. Se executarmos depois independente[0][0] = 7, a matriz original mantém [[9, 2], [3, 4]] e a nova fica [[7, 2], [3, 4]]. Os elementos das linhas são inteiros, por isso a alteração já é independente. Para estruturas mais profundas, copiar um só nível adicional pode não chegar. A forma equivalente com compreensão será explicada em compreensões e geradores.

O esquema mostra o estado após copia[0][0] = 9: cada caixa é um objeto e cada seta é uma referência a esse objeto. As listas exteriores são distintas, mas as referências nas posições 0 e 1 de ambas chegam às mesmas listas interiores.

Por isso, alterar um elemento da primeira linha através de copia também muda o que vemos através de matriz.

Evita [[0] * 3] * 2 para criar duas linhas independentes. A repetição exterior repete a referência à mesma linha. Quando precisares de uma linha nova em cada posição, cria cada linha dentro de um ciclo; a versão com compreensão aparece na lição própria.

matriz = []
for i in range(2):
    matriz.append([0] * 3)
matriz[0][0] = 5
print(matriz)

Percorrer e combinar sequências

enumerate(xs) produz pares com índice e valor. zip(xs, ys) combina elementos na mesma posição e, por defeito, termina na sequência mais curta. Se o contrato exige comprimentos iguais, verifica-o antes de combinar.

O produto interno de dois vetores com o mesmo comprimento é a soma dos produtos correspondentes. Para [2, 3] e [4, 5], calculamos $2\times4+3\times5=23$. Para dois vetores vazios, a soma é zero.

def produto_interno(u, v):
    if len(u) != len(v):
        raise ValueError("comprimentos diferentes")
    soma = 0
    for a, b in zip(u, v):
        soma += a * b
    return soma

print(produto_interno([2, 3], [4, 5]))

O resultado é 23; raise comunica uma entrada inválida e o tratamento dessa exceção está explicado na última lição do percurso.

Ordenar sem confundir os resultados

sorted(xs) devolve uma lista nova e deixa xs intacta. xs.sort() ordena a lista existente e devolve None. reverse=True pede ordem decrescente. Para ordenar registos por um campo, usa key; a lição de programação funcional explica como passar essa função.