Tuplas em Python

O que é uma tupla em Python?

Tuplas podem ser vistas como coleções de campos, com um significado que depende da ordem em que esses campos aparecem.

A descrição acima é um pouco abstrata, então, como de costume, é melhor tentarmos entendê-la por meio de um exemplo.

Imagine que você precise armazenar dados de latitude e longitude de várias cidades. Algumas das opções para armazenar esses dados são:

1. Criar duas variáveis, uma para armazenar o valor da latitude e outra para armazenar o valor da longitude.
2. Criar uma lista de tamanho dois, onde o primeiro índice é a latitude e o segundo é a longitude.

Um problema comum às duas opções acima é que a latitude e longitude de uma cidade não mudam, e ambas opções que listamos permitem que esses dados sejam alterados.

Idealmente, gostaríamos de atribuir os valores de latitude e longitude de uma cidade e ter certeza de que esses valores não serão alterados. Tuplas oferecem a solução perfeita nesse caso.

A seguir, explicaremos como criar a manipular tuplas em Python.

Como criar uma tupla em Python

A sintaxe de criação de tuplas é (…​, …​, …​), ou …​, …​, conforme mostrado nos exemplos abaixo.

# Exemplo de criação de tuplas.

tupla_vazia = () # Também é possível fazer tupla_vazia = tuple()
print("Tupla vazia: ", tupla_vazia)

coordenada_xy = (10, 20)
print("Exemplo de tupla: ", coordenada_xy)

print("Tipo de uma tupla: ", type(coordenada))

latlon_bh = (-19.8157, -43.9542)
print("Outro exemplo de criação de tupla: ", latlon_bh)

    Tupla vazia:  ()
    Exemplo de tupla:  (10, 20)
    Tipo de uma tupla:  <class 'tuple'>
    Outro exemplo de criação de tupla:  (-19.8157, -43.9542)

Extraindo elementos de uma tupla

No exemplo acima, criamos uma coordenada para armazenar pontos das dimensões x e y. Podemos fazer o caminho inverso e extrair elementos individuais (“desempacotar”) uma tupla:

coordenada_xy = (10, 20)
x, y = coordenada_xy
print("x =", x)
print("y =", y)

    x = 10
    y = 20

Como dissemos, tuplas não podem ser modificadas. Veja o que acontece quando tentamos modificar uma tupla:

coordenada_xy[0] = 15

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

    TypeError                                 Traceback (most recent call last)

    <ipython-input-216-94c38671ad7b> in <module>()
    ----> 1 coordenada_xy[0] = 15


    TypeError: 'tuple' object does not support item assignment

Um uso interessante de tuplas é a troca dos valores de duas variáveis. Essa operação é comumente conhecida como swap. Vejamos um exemplo:

x = 10
y = 20

# Swap errado.
print("x e y antes do swap: ", x, y)

x = y
y = x

print("x e y depois do swap (errado): ", x, y)

    x e y antes do swap:  10 20
    x e y depois do swap (errado):  20 20

Você consegue identificar o problema no código acima?

Vejamos agora formas corretas de fazer o swap do conteúdo de duas variáveis.

x = 10
y = 20

# Swap tradicional.
print("x e y antes do swap: ", x, y)

temp = x
x = y
y = temp

print("x e y depois do swap: ", x, y)

x = 10
y = 20

# Swap com tuplas.
print("x e y antes do swap: ", x, y)

x, y = y, x

print("x e y depois do swap: ", x, y)

    x e y antes do swap (tradicional):  10 20
    x e y depois do swap (tradicional):  20 10
    x e y antes do swap (usando tuplas):  10 20
    x e y depois do swap (usando tuplas):  20 10

Named tuples em Python

Tuplas são um recurso conveniente, mas o acesso a elementos específicos de uma tupla pode se tornar confuso se a tupla possuir muitos elementos. Python possui um recurso chamado “named tuples” para ajudar nesses casos. Basicamente, named tuples nos permitem associar nomes a cada um dos elementos (índices) de uma tupla.

Named tuples são criadas usando a função namedtuple do módulo collections. Isso quer dizer que precisamos importar a função namedtuple do módulo collections para utilizar esse recurso.

Vamos explorar um exemplo prático usando a representação de um ponto geométrico:

from collections import namedtuple

# Definindo a named tuple 'Ponto' com os atributos 'x' e 'y'
Ponto = namedtuple('Ponto', ['x', 'y'])

# Criando uma instância da named tuple
coordenada = Ponto(x=10, y=20)

# Acessando os atributos pelo nome
print(f"x: {coordenada.x}, y: {coordanada.y}")

x: 10, y: 20

Neste exemplo, Ponto é uma named tuple com atributos x e y. Ao criar uma instância da named tuple, os valores são atribuídos aos atributos correspondentes e podem ser acessados de forma clara e legível usando a notação de ponto (coordenada.x, por exemplo).

As named tuples são imutáveis, o que significa que seus valores não podem ser alterados após a criação da tupla, garantindo consistência e evitando alterações acidentais.

Named tuples são uma alternativa elegante quando se deseja atribuir significado aos elementos de uma tupla sem a complexidade de definir uma classe completa. A definição de classes será abordada em capítulos posteriores.

Exercícios

1. Use a sintaxe de swap que vimos nesta seção para escrever uma função que recebe como entrada uma lista de números e inverte os elementos dela.

def inverte_lista(nums):
    i = 0, j = len(nums) - 1
    while i < j:
        nums[i], nums[j] = nums[j], nums[i]
        i += 1
        j -= 1

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

[5, 4, 3, 2, 1]

2. Escreva uma função que recebe dois números, x e y, e retorna uma tupla contento o quociente e o resto da divisão de x por y.

def quociente_resto(x, y):
    quociente = x // y
    resto = x % y
    return (quociente, resto)

quociente_resto(9, 4)

(2, 1)