Tuplos

Temos vindo a falar de vários tipos de objectos. Por exemplo, em tempos recentes, falámos de dicionários. Se eu tiver um dicionário posso perguntar pelos seus itens, isto é, pelos seus pares (chave, valor). A listagem seguinte ilustra essa possibilidade.

>>> dicio_idades ={'Ernesto': 56,'Ana':36,'Pedro':20}
>>> dicio_idades.items()
[('Pedro', 20), ('Ernesto', 56), ('Ana', 36)]
>>>

Mas o que está dentro da lista? Os pares (chave,valor) numa notação diferente do visto até aqui. Esses novos objectos chamam-se tuplos. Os tuplos são colecções ordenadas de referências para objectos. São ainda, heterogéneas e imutáveis. São semelhantes às cadeias de caracteres, embora heterogéneas, e são semelhantes às listas, embora imutáveis. A tabela seguinte mostra as características dos objectos já referidos.

Perante estas características é natural que encontremos muitas das operações que já nos são familiares. Vejamos isso através de uma sessão simples.

>>> t1 = (1,'eu',50.3,'ah!ah!')
>>> t1
(1, 'eu', 50.299999999999997, 'ah!ah!')
>>> type(t1)
>>> t2 = tuple()
>>> t2
()
>>> t3 = (4,)
>>> t3
(4,)
>>> t4 = (4)
>>> t4
4
>>> 4 * t3
(4, 4, 4, 4)
>>> 4 * t4
16
>>> t1[2]
50.299999999999997
>>> t1[1:3]
('eu', 50.299999999999997)
>>> t5 = (1, (2,3), 4)
>>> t5[1][1]
3
>>> len(t1)
4
>>> t1 + t3
(1, 'eu', 50.299999999999997, 'ah!ah!', 4)
>>> 'eu' in t1
True
>>> t1.index('eu')
1
>>> t1.count('eu')
1
>>> l1 = [1,2,3]
>>> l2 = ['a','b','c']
>>> zip(l1,l2)
[(1, 'a'), (2, 'b'), (3, 'c')]
>>> tuple (zip(l1,l2))
((1, 'a'), (2, 'b'), (3, 'c'))
>>> t6 = (23,13,44,7,22,3)
>>> sorted(t6)
[3, 7, 13, 22, 23, 44]
>>> t6
(23, 13, 44, 7, 22, 3)
>>> tuple(sorted(t6))
(3, 7, 13, 22, 23, 44)
>>> t6
(23, 13, 44, 7, 22, 3)
>>>

Vemos que existem tuplos vazios (linhas 6 e 7). Um tuplo só com um elemento obriga a colocar uma vírgula par não se confundir com uma expressão (linhas 8 a 17). As operações usuais de fatiamento são ilustradas nas linhas 18 a 24. Temos também o comprimento (linha 25), concatenação (linha 27) e teste de pertença (linha 29). As linhas 31 e 33 ilustram duas operações simples, na realidade métodos, que não alteram o objecto. A linha 37 mostra uma operação de zip: transformar duas listas de igual comprimento numa lista de pares ordenados. A operação tuplo(objecto) permite transformar certos objectos em tuplos. Podemos ordená-los (sorted), embora o objecto, porque imutável se mantenha inalterado. Caso queiramos que fique com a nova ordem temos que criar um novo objecto associando-o a um nome (eventualmente o mesmo!) (linha 42).

Podemos perguntar do porquê da existência de tuplos. Afinal eles podem ser substituídos por listas. Uma razão simples deriva do facto do criador da linguagem Guido Van Rossum ser um matemático de formação e por isso, para ele, um tuplo é uma associação de objectos enquanto uma lista é uma estrutura de dados. Mas há razões mais fortes para usar tuplos. A principal é que os tuplos sendo imutáveis não nos causam as preocupações das listas quando se trata modificações não desejadas. Acresce que podem ser usados como chaves de dicionários.