Coleções em Python: Tuplas

Fala, meus consagrados! Tudo beleza com vocês?

Começamos os estudos sobre as coleções na linguagem Python: quais são suas principais características e uso. Tudo com exemplos e questões de concursos.

Já iniciamos com o artigo sobre listas. Agora, entenderemos como usar as tuplas.

Então, simbora comigo!

Visão geral

São quatro as coleções em Python:

• Lista;
• Tupla;
• Set; e
• Dicionário.

Na tabela 1, temos as principais características dessas coleções.

Tabela 1: principais características das coleções em Python.

Observação: a partir da versão Python 3.7, os dicionários são ordenados.

Exemplos:

# Lista []
linguagens = ["Python", "Java", "PHP", "C"]

# Tupla ()
linguagens = ("Python", "Java", "PHP", "C")

# Set {}
linguagens = {"Python", "Java", "PHP", "C"}

# Dicionário {}
optimus = {"id": 1, "nome": "Optimus Prime"}

Tuplas

São coleções:

• Ordenadas;
• Imutáveis;
• Indexadas; e
• Que permitem membro repetidos.

As tuplas são escritas com parênteses ( ).

Com uma série de exemplos, vamos entender o uso de tuplas. Após isso, iremos resolver várias questões que citam essa coleção.

Primeiro ponto é sabermos como criar tuplas em Python. Podemos criar com o construtor tuple(), podendo já passar elementos como parâmetros, ou já informando os elementos envoltos em colchetes.

Como exemplos, criaremos duas tuplas com quatro elementos (quatro linguagens de programação):

linguagens1 = tuple(("Python", "Java", "PHP", "C"))
print(linguagens1) # Será impresso ('Python', 'Java', 'PHP', 'C')

linguagens2 = ("Python", "Java", "PHP", "C")
print(linguagens2) # Será impresso ('Python', 'Java', 'PHP', 'C')

Uma tupla pode ser criada a partir de outra, ainda usando o construtor tuple(), passando a tupla original como parâmetro:

# Tupla original.
linguagens1 = ("Python", "Java", "PHP", "C")
print(linguagens1) # Será impresso ('Python', 'Java', 'PHP', 'C')

# Tupla criada a partir de outra.
linguagens2 = tuple(linguagens1)
print(linguagens2) # Será impresso ('Python', 'Java', 'PHP', 'C')

Observação: para a criação de uma tupla apenas com um elemento, é necessário colocar uma vírgula após o elemento único. Do contrário, o interpretador Python vai executar como uma string:

# Criando uma tupla de um elemento.
linguagem = ("Python",)
print(linguagem)        # Será impresso ('Python',)
print(type(linguagem))  # Será impresso <class 'tuple'>

# Não é uma tupla.
linguagem = ("Python")
print(linguagem)        # Será impresso Python
print(type(linguagem))  # Será impresso <class 'str'>

Para imprimir uma tupla, podemos usar a função print():

linguagens = ("Python", "Java", "PHP", "C")
print(linguagens) # Será impresso ('Python', 'Java', 'PHP', 'C')

Para acessar um elemento da tupla, utiliza-se a indexação numérica (tupla[n]), informando qual a posição da tupla (n):

linguagens = ("Python", "Java", "PHP", "C")

# Imprimindo o terceiro elemento "PHP".
print(linguagens[2]) # Será impresso PHP

Observação: em Python, o primeiro elemento de uma tupla começa na posição 0.

Podemos também acessar um intervalo de elementos (tupla[n:m]), informando o índice inicial (n) e o índice final de uma tupla (m – não incluído):

linguagens = ("Python", "Java", "PHP", "C")

# Imprimindo os elementos da posição 0 até a posição 1.
print(linguagens[0:2]) # Será impresso ('Python', 'Java')

Observação: no exemplo acima, lemos da seguinte forma: traga os elementos da posição 0 (primeiro índice informado) até a posição 1 (posição anterior ao segundo índice informado). Por isso que o elemento PHP (índice 2) não é impresso.

Agora acessaremos cada elemento utilizando uma estrutura de repetição for:

linguagens = ("Python", "Java", "PHP", "C")

for x in linguagens:
    print(x)

O que será impresso é:

Python
Java
PHP
C

O operador in também pode ser usado para verificar se um elemento está na tupla:

linguagens = ("Python", "Java", "PHP", "C")

if "Python" in linguagens:
    print("Python está na tupla das linguagens de programação") # Será impresso Python está na tupla das linguagens de programação

Nesse caso, será impressa a frase porque o elemento “Python” está na tupla.

Os operadores not in são usados para verificar se um elemento não está na tupla:

linguagens = ("Python", "Java", "PHP", "C")

if "C#" not in linguagens:
    print("C# não está na tupla das linguagens de programação") # Será impresso C# não está na tupla das linguagens de programação

Nesse caso, será impressa a frase porque o elemento “C#” não está na tupla.

Para retornar o tamanho de uma tupla (quantidade de elementos), utiliza-se a função len():

linguagens = ("Python", "Java", "PHP", "C")
print(len(linguagens)) # Será impresso 4

Por serem imutáveis, não é possível alterar o valor de um elemento de uma tupla:

linguagens = ("Python", "Java", "PHP", "C")

# Erro ao alterar um item no final de uma tupla.
linguagens[2] = "C#"

Haverá o seguinte erro ao tentar executar o código acima:

Traceback (most recent call last):
  File "./prog.py", line 4, in <module>
TypeError: 'tuple' object does not support item assignment

Ainda por ser imutável, não podemos adicionar elementos às tuplas.  Nem utilizando o método append() nem o método insert().

Há uma alternativa para alterar um elemento e adicionar um novo:

• Criamos a tupla original;
• Criamos uma lista a partir da tupla;
• Alteramos elementos ou adicionamos novos na lista; e
• Criamos uma tupla a partir da lista alterada.

Vamos ao código:

# Criando a tupla original.
linguagens = ("Python", "Java", "PHP", "C")

# Criando uma lista, com o construrtor list() passando a tupla como parâmetro.
aux = list(linguagens)

# Alterando o elemento de posição 2 da lista.
aux[2] = "C#"

# Inserindo um elemento no final da lista.
aux.append("JavaScript")

# Inserindo um elemento na posição 1.
aux.insert(1, "C++")

# Criando uma tupla, com o construrtor tuple() passando a lista como parâmetro.
linguagens = tuple(aux)
print(linguagens) # Será impresso ('Python', 'C++', 'Java', 'C#', 'C', 'Javascript')

O mesmo raciocínio vale para remoção de elementos: não há como remover, pois as tuplas são imutáveis. Não podemos aplicar os métodos remove() e pop().

A palavra-chave del não pode ser usada para remover um elemento específico de uma tupla, porém podemos usar del para eliminar todos os elementos de uma tupla:

linguagens = ("Python", "Java", "PHP", "C")

# Deletando a tupla inteira.
del linguagens
print(linguagens)

Como a tupla foi deleta, então haverá um erro na linha print(linguagens):

Traceback (most recent call last):
  File "./prog.py", line 5, in <module>
NameError: name 'linguagens' is not defined

Outra diferença com as listas, as tuplas não aceitam os métodos clear() e copy().

Finalizando, podemos juntar duas tuplas em uma, usando o operador +:

tupla1 = ("a", "b" , "c", 1)
tupla2 = (1, 2, 3)

tupla3 = tupla1 + tupla2
print(tupla3) # Será impresso ('a', 'b', 'c', 1, 1, 2, 3)

Observação: vejam que a tupla3 possui elementos repetidos (1, 1), pois as tuplas em Python aceitam isso.

Tabela 1: revisão das funções, métodos, operadores e palavras-chave usada neste artigo.

Questões de concursos

[1] [IF Sul Rio-Grandense 2019 IF Sul Rio-Grandense – Analista de Tecnologia da Informação] Em relação às características da linguagem Python, é correto afirmar que (Marque CERTO ou ERRADO)

[D] apresenta a tupla, que é um tipo mutável.

Comentários:

As tuplas em Python são imutáveis.

Gabarito: ERRADO.

[2] [COMPERVE 2016 UFRN – Técnico de Tecnologia da Informação] Analise o trecho de código Python a seguir, escrito para a versão 2.6.

t=(1,3,4)
t2=(3,4,5)
t3=t+t2
n=0
for e in t3:
    if (e>2):
        n+=e
print(n)

Após a execução do código Python, o valor da variável n impresso na tela é

[A] 12

[B] 13

[C] 19

[D] 20

Comentários:

Questão boa sobre concatenação de tuplas.

Organizando o código:

t = (1, 3, 4)
t2 = (3, 4, 5)

t3 = t + t2
print(t3)

n = 0

for e in t3:
    if (e > 2):
        n += e

print(n)

O resultado da execução é:

(1, 3, 4, 3, 4, 5)
19

Temos duas tuplas iniciais: t e t2. A tupla t3 é o resultado da concatenação dessas duas tuplas: (1, 3, 4, 3, 4, 5).

A variável n é usada como uma totalizadora e ela começa com o valor 0.

Temos uma estrutura de repetição for para percorrer os valores da tupla t3. Dentro dessa estrutura, temos uma estrutura de condição if: se o valor do elemento da tupla for maior que 2, então a variável n receberá ela mesma mais o valor do elemento.

Gabarito: letra C.

Referências

• PensePython2e – Tradução do livro Pense em Python (2ª ed.), de Allen B. Downey. Disponível em: https://penseallen.github.io/PensePython2e/
• Python. Disponível em: https://www.python.org/
• Python e Orientação a Objetos. Disponível em: https://www.caelum.com.br/apostila-python-orientacao-a-objetos
• Python Reference (The Right Way). Disponível em: https://python-reference.readthedocs.io/en/latest/
• Python Tutorial. Disponível em: htps://www.w3schools.com/python/

Então é isso!
[]’s e até a próxima!
_________________________
Professor Rogerão Araújo