Tutorial de tuplas em Python

Tuplas versus listas

Como você deve ter notado, tuplas são muito parecidas com listas. Na prática, dá para dizer que são listas imutáveis, o que significa que, depois que uma tupla é criada, você não pode excluir nem alterar os valores dos itens armazenados nela. Também não é possível adicionar novos valores. Veja:

numbers_tuple = (1,2,3,4,5)
numbers_list = [1,2,3,4,5]

# Tentar adicionar um número à tupla
numbers_tuple.append(6)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-26-e47776d745ce> in <module>()
      3 
      4 # Append a number to the tuple
----> 5 numbers_tuple.append(6)


AttributeError: 'tuple' object has no attribute 'append'

Isso gera um erro porque você não pode remover nem adicionar itens a uma tupla — mas pode fazer isso com uma lista.

# Adicionar números à lista
numbers_list.append(6)
numbers_list.append(7)
numbers_list.append(8)

# Remover um número da lista
numbers_list.remove(7)
print(numbers_list)

[1, 2, 3, 4, 5, 6, 8]

Mas por que usar tuplas se elas são imutáveis?

Além de fornecerem acesso "somente leitura" aos dados, elas também são mais rápidas do que listas. Considere os trechos a seguir:

import timeit
timeit.timeit('x=(1,2,3,4,5,6,7,8,9)', number=100000)

0.0018976779974764213

timeit.timeit('x=[1,2,3,4,5,6,7,8,9]', number=100000)

0.019868606992531568

O que "imutável" realmente significa no contexto de tuplas?

De acordo com a documentação oficial do Python, imutável é "um objeto com um valor fixo"; mas "valor" é um termo meio vago — o termo mais preciso para tuplas seria "id". "id" é a identidade do local de um objeto na memória.

Vamos olhar mais a fundo:

# Tupla 'n_tuple' com uma lista como um de seus itens.
n_tuple = (1, 1, [3,4])

# Itens com o mesmo valor têm o mesmo id.
id(n_tuple[0]) == id(n_tuple[1])

True

# Itens com valores diferentes têm ids diferentes.
id(n_tuple[0]) == id(n_tuple[2])

False

id(n_tuple[0])

4297148528

id(n_tuple[2])

4359711048

n_tuple.append(5)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-40-3cd258e024ff> in <module>()
----> 1 n_tuple.append(5)


AttributeError: 'tuple' object has no attribute 'append'

Não podemos adicionar itens a uma tupla, por isso o erro acima. É por isso que a tupla é considerada imutável. Mas você sempre pode fazer isto:

n_tuple[2].append(5)
n_tuple

(1, 1, [3, 4, 5])

Ou seja, você conseguiu de fato alterar a tupla original. Como ela ainda é chamada de imutável então?

Porque o id da lista dentro da tupla continua o mesmo, mesmo depois de você ter adicionado o 5 a ela.

id(n_tuple[2])

4359711048

Resumindo o que você aprendeu até aqui:

Algumas tuplas (que contêm apenas objetos imutáveis: strings etc.) são imutáveis e outras tuplas (que contêm um ou mais objetos mutáveis: listas etc.) podem sofrer mudanças. No entanto, isso costuma gerar debate entre Pythonistas, e você vai precisar de mais base teórica para entender completamente. Este artigo aprofunda o tema. Por agora, vamos dizer que tuplas são imutáveis em geral.

• Você não pode adicionar elementos a uma tupla, por causa de sua propriedade de imutabilidade. Não existe método append() nem extend() para tuplas,
• Você não pode remover elementos de uma tupla, também por serem imutáveis. Tuplas não têm métodos remove() ou pop(),
• Você pode localizar elementos em uma tupla, já que isso não altera a tupla,
• Você também pode usar o operador in para verificar se um elemento existe na tupla.

Então, se você está definindo um conjunto constante de valores e tudo o que vai fazer é percorrê-los, use uma tupla em vez de uma lista. Ela será mais rápida do que trabalhar com listas e também mais segura, já que as tuplas funcionam como dados com "proteção contra escrita".

Se quiser saber mais sobre listas em Python, confira este tutorial!

Operações comuns com tuplas

O Python oferece várias maneiras de manipular tuplas. Vamos ver as mais importantes com exemplos.

Fatiamento (slicing) de tuplas

O primeiro valor de uma tupla tem índice 0. Assim como nas listas em Python, você pode usar os valores de índice com colchetes [] para acessar itens em uma tupla:

numbers = (0,1,2,3,4,5)
numbers[0]

0

Você também pode usar indexação negativa com tuplas:

numbers[-1]

5

Enquanto a indexação serve para obter itens individuais, o fatiamento permite obter um subconjunto de itens. Quando você informa um intervalo que quer extrair, isso é chamado de range slicing. O formato geral é:

[Índice inicial (incluído):Índice final (excluído):Incremento]

Aqui, Incremento é um parâmetro opcional; por padrão, o incremento é 1.

# O item no índice 4 é excluído
numbers[1:4]

(1, 2, 3)

# Retorna todos os itens da tupla
numbers[:]

(0, 1, 2, 3, 4, 5)

# Incremento = 2
numbers[::2]

(0, 2, 4)

Dica: você também pode usar um incremento negativo para inverter a tupla.

numbers[::-1]

(5, 4, 3, 2, 1, 0)

Adição (concatenação) de tuplas

Você pode combinar tuplas para formar uma nova tupla. A operação de adição simplesmente faz a concatenação.

x = (1,2,3,4)
y = (5,6,7,8)

# Combinando duas tuplas para formar uma nova
z = x + y 

print(z)

(1, 2, 3, 4, 5, 6, 7, 8)

y = [5,6,7,8]
z = x + y
print(z)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-55-d352c6414a4c> in <module>()
      1 y = [5,6,7,8]
----> 2 z = x + y
      3 print(z)


TypeError: can only concatenate tuple (not "list") to tuple

Você só pode somar ou combinar tipos de dados iguais. Assim, combinar uma tupla com uma lista gera erro.

Multiplicação de tuplas

A multiplicação simplesmente repete a tupla.

x = (1,2,3,4)
z = x*2
print(z)

(1, 2, 3, 4, 1, 2, 3, 4)

Funções úteis com tuplas

Diferente das listas em Python, tuplas não têm métodos como append(), remove(), extend(), insert() e pop() por serem imutáveis. Porém, há várias outras funções embutidas para trabalhar com tuplas:

count() e len()

count() retorna o número de ocorrências de um item em uma tupla.

a = [1,2,3,4,5,5]
a.count(5)

2

Com a função len(), você obtém o comprimento da tupla:

a = (1,2,3,4,5)
print(len(a))

5

any()

Você pode usar any() para saber se algum elemento de uma tupla é considerado verdadeiro (truthy). Se for o caso, o retorno é True; caso contrário, False.

a = (1,)
print(any(a))

True

Repare na , na declaração da tupla a acima. Se você não coloca a vírgula ao inicializar um único item em uma tupla, o Python supõe que você apenas adicionou um parêntese extra (o que é inofensivo), mas o tipo de dado não será tupla. Então, lembre-se de adicionar a vírgula ao declarar uma tupla de um único item.

Voltando à função any(): em um contexto booleano, o valor específico do item é irrelevante. Uma tupla vazia é falsa; qualquer tupla com pelo menos um item é verdadeira.

b = ()
print(any(b))

False

Essa função pode ser útil quando você usa uma tupla em alguma parte do seu programa e quer garantir que ela esteja populada.

tuple()

Use tuple() para converter um tipo de dado em tupla. No exemplo abaixo, você converte uma lista do Python em uma tupla.

a_list = [1,2,3,4,5]
b_tuple = tuple(a_list)
print(type(b_tuple))

<class 'tuple'>

min() e max()

Enquanto max() retorna o maior elemento da tupla, min() retorna o menor. Veja o exemplo:

print(max(a))
print(min(a))

5
A

Você também pode usar isso com tuplas que contêm strings.

# A string 'Apple' é automaticamente convertida em uma sequência de caracteres.
a = ('Apple') 
print(max(a))

p

sum()

Com essa função, você retorna a soma total dos itens em uma tupla. Só pode ser usada com valores numéricos.

sum(a)

28

sorted()

Para obter os elementos em ordem crescente, use sorted(), como no exemplo a seguir:

a = (6,7,4,2,1,5,3)
sorted(a)

[1, 2, 3, 4, 5, 6, 7]

Vale notar que o tipo de retorno é uma lista, não uma tupla. A sequência na tupla original 'a' não é alterada e o tipo de 'a' continua sendo tupla.

Bônus: atribuindo vários valores

Algo muito útil que você pode fazer com tuplas é usá-las para atribuir vários valores de uma só vez. Olha só:

a = (1,2,3)
(one,two,three) = a
print(one)

1

a é uma tupla de três elementos e (one,two,three) é uma tupla de três variáveis. Atribuir (one,two,three) à tupla a faz com que cada valor de a seja atribuído, na ordem, às variáveis one, two e three. Isso é prático quando você precisa distribuir uma sequência de valores armazenados em uma tupla.

Parabéns!

Você chegou ao fim deste tutorial sobre tuplas! No caminho, você aprendeu o que são tuplas em Python, como inicializá-las, quais são as operações mais comuns para manipulá-las e quais funções embutidas mais importantes você deve conhecer para extrair mais insights dessas estruturas de dados. De bônus, você também viu que é possível atribuir vários valores de uma vez usando tuplas.