Coleções em Python: Tuplas

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!

Rogério Araújo


15 de Fevereiro 5 min. de leitura

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.

Característica

Lista

Tupla

Set

Dicionário

Ordenada

Sim

Sim

Não

Sim

Mutável

Sim

Não

Sim

Sim

Indexada

Sim

Sim

Não

Sim

Permite membros repetidos

Sim

Sim

Não

Não


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.

Item

Descrição

tuple()

Cria uma nova tupla

print()

Imprime o valor de uma variável ou expressão

tupla[n]

Acessa um elemento específico de uma tupla

tupla[n:m]

Acessar um intervalo de elementos de uma tupla da posição n até a posição m – 1

for x in tupla

Acessa cada elemento de uma tupla

if elemento in tupla

Verifica se um elemento está em uma tupla

if elemento not in tupla

Verifica se um elemento não está em uma tupla

len(tupla)

Retorna o tamanho de uma tupla (quantidade de elementos)

+

Concatena tuplas


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.

t

t2

t3

n

e

(1, 3, 4)

(3, 4, 5)

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

0

0

1

3

3

7

4

10

3

14

4

19

5


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

Quer conquistar a sua aprovação em concursos públicos?

Prepare-se com quem mais entende do assunto!

Comece a estudar no Gran Cursos

Depoimentos relacionados

Em busca de estabilidade e conforto para a família, Isabella Modesto estudou por três anos para conquistar uma vaga para…

Natural de Aracaju, a professora Érika Ramos decidiu ingressar na conquista pelo cargo público por 2 principais razões: a busca…

Persistência e dedicação sempre foram palavras que permearam a vida de Elisa da Silva Gomes Lana, natural de Costa Verde…

Daniele Laís saiu de seu emprego no SENAC DF aproveitando um momento de mudança no seu cargo, hoje extinto, e…

Evelyn Rodrigues é natural de Brasília/DF, mas hoje mora em Aracaju/SE, onde realizou e foi aprovada no Concurso Prefeitura Barra…

Qual é o seu grande objetivo de vida? Para Raul Marcelo da Silva o foco estava em ingressar na carreira…

Natural da cidade de Poço Verde/ SE, Aialla Suelem Andrade de Souza escolheu a carreira pública não só pela estabilidade…

Dedicando-se ao estudos por cerca de 3 anos, José Roberto Ferreira conquistou não apenas a aprovação no Concurso BRB para…

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *