Pular para o conteúdo

Tupla

Definição

Uma tupla é uma coleção ordenada (a posição dos itens não muda) e imutável. Permite membros duplicados.

  • Uma tupla sem itens repetidos. Note que a tupla abaixo tem uma string, um número real, um inteiro e uma lista.
x = ("teste", 12.3, 1, [1,2,3])
  • Uma tupla com itens repetidos.
x = ("teste", 12.3, "teste")
  • Uma tupla vazia.
x = ()
  • Para criar uma tupla com apenas um elemento, é preciso adicionar uma vírgula após o único elemento. No exemplo abaixo, x é uma tupla, enquanto y é uma string.
x = ("teste",)
y = ("teste")
  • É possível atribuir os elementos de uma tupla para variáveis distintas de forma automática. No exemplo abaixo, temos uma tupla com 4 elementos. Cada elemento é assinalado para uma variável diferente.
x = ("teste", 12.3, 1, [1,2,3])
(a, b, c, d) = x
print("a = ", a, ",", type(a))
print("b = ", b, ",", type(b))
print("c = ", c, ",", type(c))
print("d = ", d, ",", type(d))

Note, na resposta abaixo, que as variáveis criadas são de diferentes tipos.

a =  teste , <class 'str'>
b =  12.3 , <class 'float'>
c =  1 , <class 'int'>
d =  [1, 2, 3] , <class 'list'>

Índices

Pode-se acessar os itens de uma tupla usando índices que começam com o valor zero. No exemplo abaixo, a tupla x tem 4 elementos: um número inteiro, uma string, uma lista e um número real.

x = (1, 'abc', [4,5,6], 2.3)
print('x = ', x, ', type(x) = ', type(x))
print('x[0] =', x[0], ', type(x[0]) = ', type(x[0]))
print('x[1] =', x[1], ', type(x[1]) = ', type(x[1]))
print('x[2] =', x[2], ', type(x[2]) = ', type(x[2]))
print('x[3] =', x[3], ', type(x[3]) = ', type(x[3]))

O programa apresenta a saída abaixo. Para acessar os elementos da lista que estão dentro da tupla, basta incluir mais um índice. Neste caso, temos x[2][0] = 4, x[2][1] = 5 e x[2][2] = 6.

x =  (1, 'abc', [4, 5, 6], 2.3) , type(x) =  <class 'tuple'>
x[0] = 1 , type(x[0]) =  <class 'int'>
x[1] = abc , type(x[1]) =  <class 'str'>
x[2] = [4, 5, 6] , type(x[2]) =  <class 'list'>
x[3] = 2.3 , type(x[3]) =  <class 'float'>

É também possível usar índices negativos. Neste caso, os índices são numerados a partir de -1 indo do item mais à direita para o item mais à esquerda da tupla. Para o exemplo acima temos x[-1] = 2.3, x[-2] = [4, 5, 6], x[-3] = ‘abc’ e x[-4] = 1.

Pode-se usar slice (fatia) para selecionar vários itens de uma tupla. Um slice usa o formato definido a seguir.

início : fim : incremento

Considerando a tupla x do exemplo acima, os comandos

print(x[0:2])
print(x[1:3])
print(x[-3:-1])

fornecem a seguinte resposta:

(1, 'abc')
('abc', [4, 5, 6])
('abc', [4, 5, 6])

Note que slice inclui o elemento com o índice indicado pelo início do slice, mas não mostra o elemento com o índice indicado pelo fim.

Métodos

  • O método count() retorna o número de vezes que um determinado valor aparece em um tupla. O programa
x = ('abc', 4, 'teste', 4, 'abc', 4)
print('Existem', x.count(4), 'valores 4')
print('Existem', x.count('abc'), 'valores "abc"')

tem como resposta:

Existem 3 valores 4
Existem 2 valores "abc"
  • Para saber o índice da tupla onde se encontra determinado valor, pode-se usar o método index(). Este método retorna apenas o índice do primeiro valor encontrado. 
x = ('abc', 4, 'teste', 4, 'abc', 4)
print('Primeiro índice para o valor 4: ', x.index(4))
print('Primeiro índice para o valor "abc": ', x.index('abc'))

A resposta é

Primeiro índice para o valor 4:  1
Primeiro índice para o valor "abc":  0

Para ver todos os índices que tem valor 4, use

i = 0
for k in x:
   if (k == 4):
   	print(i)
   i +=1

Neste caso, o programa responderá que os índices são: 1, 3 e 5.

  • O método tuple() pode ser usado para converter algum tipo de dado para uma tupla. Por exemplo,
x = '15'
y = ['a',2, 'teste']
z = 'abc'
print("x = ", x, ",", type(x), "id = ", id(x))
print("y = ", y, ",", type(y), "id = ", id(y))
print("z = ", z, ",", type(z), "id = ", id(z))
print("*****************")
x = tuple(x)
y = tuple(y)
z = tuple(z)
print("x = ", x, ",", type(x), "id = ", id(x))
print("y = ", y, ",", type(y), "id = ", id(y))
print("z = ", z, ",", type(z), "id = ", id(z))

mostra a seguinte resposta:

x =  15 , <class 'str'> id =  140308135207984
y =  ['a', 2, 'teste'] , <class 'list'> id =  140308135145664
z =  abc , <class 'str'> id =  140308136444848
*****************
x =  ('1', '5') , <class 'tuple'> id =  140308136261312
y =  ('a', 2, 'teste') , <class 'tuple'> id =  140308135128320
z =  ('a', 'b', 'c') , <class 'tuple'> id =  140308135344448

Podemos fazer algumas observações para este exemplo: a) ao usar o método tuple(), foram criadas estruturas com o mesmo nome das estruturas que existiam e as estruturas anteriores foram deletadas (possuem id diferentes); b) o método tuple() considera cada caractere da string como um elemento da tupla; c) o método não aceita converter números em tuplas, dá erro (por isso, a variável x tem a string ’15’ e não o número inteiro 15).

É possível o usar o método tuple() para criar uma tupla. Neste caso, deve-se usar dois parênteses como mostrado abaixo.

x = tuple(('a', 2, 'teste'))
print("x = ", x, ",", type(x))

O programa apresenta a seguinte reposta:

x =  ('a', 2, 'teste') , <class 'tuple'>
  • O método sum() soma os elementos de um tupla que só tem valores numéricos.
x = (12.56, 5, 0.375)
print("sum = ", sum(x))

O resultado do programa acima é 17.935.

  • O método sorted() permite ordenar os elementos de uma tupla que são do mesmo tipo (números ou strings). Por exemplo, considere 2 tuplas: a primeira tem apenas números e a segunda tem apenas strings.
x = (12, 1.2, 25, 101, 14)
print("x ordenado = ", sorted(x))

y = ('bc', 'a', 'fg')
print("y ordenado = ", sorted(y))

O resultado do programa é

x ordenado =  [1.2, 12, 14, 25, 101]
y ordenado =  ['a', 'bc', 'fg']

Operações

É possível criar novas tuplas usando as operações de adição e multiplicação. O programa 

x = (1, 'a', [4,5,6])
y = ('a', 'b', 'c')
print('x + y = ', x + y)
print('x * 2 + y = ', x * 2 + y)

tem como resposta

x + y =  (1, 'a', [4, 5, 6], 'a', 'b', 'c')
x * 2 + y =  (1, 'a', [4, 5, 6], 1, 'a', [4, 5, 6], 'a', 'b', 'c')