Tuples

Tuples são sequências imutáveis de objetos. Por imutáveis entende-se que, uma vez criado um tuple, não podemos alterá-lo.

Os tuples são criados definindo uma sequência de objetos, separados por vírgulas, dentro de parenteses curvos:

#criação de um tuple:
t = (2, 4, 6, 8)

Um tuple com um unico elemento deve ter virgula no fim:

t = (7)    #Não é um tuple, é um numero inteiro
t = (7,)   #É um tuple

Um tuple vazio é criado definindo parenteses curvos sem objetos no interior:

#criação de um tuple vazio:
t = ()

Como referido, tuples são sequências imutáveis de objetos. No entanto, um tuple pode conter objetos mutáveis, como listas, por exemplo, e estes podem ser acedidos e modificados:

#criação de um tuple, com uma lista como um dos seus elementos:
t = (3, "ola", [10, 20, 30], 4)
#altera a lista, na posição 2 do tuple:
t[2].append(40)
print(t)

O output do código acima será:

(3, 'ola', [10, 20, 30, 40], 4)

Tamanho de um tuple

O tamanho de um tuple é o numero dos seus elementos e pode ser obtido com a função len():

tuple1 = (123, "abc", 456, "def")

print(len(tuple1))  #Ouput:  4

Acesso aos elementos de um tuple

Acedemos aos elementos de um tuple, através dos respectivos índices. Num tuple, a numeração dos índices começa no número 0, sendo este o índice do 1º elemento.

O acesso a um elemento de um tuple, é feito usando o seu índice dentro de parenteses retos:

t = ("Lisboa", 100, "Setúbal", 50, "Faro", 70)
print(t[0])  #acede ao 1º elemento ("Lisboa")
print(t[1])  #acede ao 2º elemento (100)

Podemos aceder a um elemento de um tuple, a partir do fim, usando para isso o índice -1 para o último elemento, -2 para o penúltimo, etc..:

t = ("Lisboa", 100, "Setúbal", 50, "Faro", 70)
print(t[-1])  #acede ao último elemento (70)
print(t[-2])  #acede ao penúltimo elemento ("Faro")

Fatiamento (slicing)

Como se viu na secção anterior, podemos aceder a um conjunto de elementos de um tuple definindo uma gama de índices, entre um índice de início e um de fim, exclusive. Este tipo de operações chama-se slicing.

Considere-se o seguinte tuple:

t = (10, 20, 30, 40, 50)

Slicing	Resultado	Descrição
t[1:4]	(20, 30, 40)	Acede aos elementos entre o índice 1 e o índice 4, exclusive
t[2:]	(30, 40, 50)	Acede a todos os elementos a partir do índice 2
t[:3]	(10, 20, 30)	Acede aos elementos a partir do ínicio até ao índice 3, exclusive

Podemos aceder a um intervalo elementos especificando um intervalo de índices entre um início e um fim, exclusive:

t = ("Lisboa", 100, "Setúbal", 50, "Faro", 70)
print(t[1:3])  #acede aos elementos entre o 2º elemento e o 4º, exclusive.

O output do código acima será:

(100, 'Setúbal')

Alteração e eliminação de elementos de um tuple

Dado o facto de os tuples serem sequências imutáveis de objetos, não podemos modificar ou eliminar qualquer dos seus elementos.

Desempacotamento

O desempacotamento de tuples em Python é o processo de atribuir os valores de um tuple (ou outra sequência) diretamente a variáveis individuais, de forma simples e legível. Por exemplo:

t = (10, 20, 30)
a, b, c = t
# a = 10, b = 20, c = 30

Cada variável à esquerda recebe o valor correspondente do tuple na mesma posição.

Se a quantidade de variáveis não corresponder ao número de elementos da tupla, ocorre o erro:
“valores demais para desempacotar” (ou “too many values to unpack”):

t = (1, 2, 3)
a, b = t  # ERRO: valores demais para desempacotar

Se não quisermos usar todos os valores, podemos usar o underscore (_) para ignorar variáveis:

t = (1, 2, 3)

x, _, _ = t
print(x)     #Saida: 1

Também é possível usar o operador * para capturar múltiplos valores restantes:

a, *resto = (1, 2, 3, 4)
# a = 1, resto = [2, 3, 4]

O desempacotamento é muito útil em loops, especialmente ao percorrer listas de tuplas:

lista = [(1, 2, 3), (4, 5, 6)]
for x, y, z in lista:
    print(x, y, z)

Operações com tuples

As operações com tuples são as operações básicas que se usam com sequências, e são as seguintes:

Operação	Output	Descrição
(10, 20, 30) + (40, 50, 60)	(10, 20, 30, 40, 50, 60)	Concatenação
(‘viva’) * 4	(‘viva’, ‘viva’, ‘viva’, ‘viva’)	Repetição
40 in (30, 40, 50)	True	Pertença
for x in (10,20,30) : print(x)	10 20 30	Iteração

Funções com tuples

O Python possui as seguintes funções com tuples:

max()

A função max() retorna o elemento de um tuple com o maior valor:

tup = (465, 578, 253, 957)
print(max(tup))   #Output: 957

min()

A função min() retorna o elemento de um tuple com o menor valor:

tup = (465, 578, 253, 957)
print(min(tup))   #Output: 253