Tuplas CHRISTOPHER FREIRE SOUZA EWERTON AMORIM DE OLIVEIRA LUCAS HENRIQUE SILVA

Tuplas são inalteráveis Uma tupla é uma sequência de valores. Os valores podem ser de qualquer tipo. Os índices de uma tupla são inteiros. Em muitos aspectos, tuplas são muito parecidas com listas. Mas uma diferença importante é que tuplas são imutáveis. Sintaticamente, uma tupla é uma sequência de números separados por vírgulas. Embora não seja necessário, é comum escrever uma tupla entre parênteses: Para criar uma tupla com um único elemento você pode colocar uma vírgula no final: >>> t = 'a', 'b', 'c', 'd', 'e' >>> t = ('a', 'b', 'c', 'd', 'e') >>> t1 = 'a', >>> type(t1) <class 'tuple'>

Tuplas são inalteráveis Um valor entre parênteses não é uma tupla. Outra maneira de se criar uma tupla é com a função tuple(). Se não houver valores como argumento, ela cria uma tupla vazia: Se o argumento passado for uma sequência (string, lista ou tupla), o resultado é uma tupla com os elementos da sequência. >>> t2 = ('a') >>> type(t2) <class 'str'> >>> t = tuple() >>> t () >>> t = tuple('lupins') >>> t ('l', 'u', 'p', 'i', 'n', 's')

Tuplas são inalteráveis Muitos operadores de listas também funcionam em tuplas, como índices e o operador dois pontos entre colchetes: Mas se você tentar modificar um dos elementos de uma tupla, você obtém um erro. >>> t = ('a', 'b', 'c', 'd', 'e') >>> t[0] 'a‘ >>> t[1:3] ('b', 'c') >>> t[0] = 'A' TypeError: object doesn't support item assignment

Tuplas são inalteráveis Porque tuplas são inalteráveis, você não pode modificar elementos, mas você pode colocar uma tupla em outra: Os operadores relacionais funcionam em tuplas e em outras sequências. O Python começa comparando os primeiros elementos, se eles são iguais, compara os segundos e assim em diante até encontrar um diferente. >>> t = ('A',) + t[1:] >>> t ('A', 'b', 'c', 'd', 'e') >>> (0, 1, 2) < (0, 3, 4) True >>> (0, 1, 2000000) < (0, 3, 4)

Atribuição de tuplas Para trocar valores de variáveis, é comum utilizar a seguinte atribuição: Esta solução é pesada. A atribuição de tuplas é mais elegante: Preste atenção que a quantidade de variáveis à esquerda deve ser a mesma quantidade de variáveis à direita do sinal de igualdade. >>> temp = a >>> a = b >>> b = temp >>> a, b = b, a >>> a, b = 1, 2, 3 ValueError: too many values to unpack

Atribuição de tuplas Mais genericamente, o lado direito pode ser uma sequência qualquer. Por exemplo, para quebrar um endereço de e-mail em usuário e domínio, você pode escrever o seguinte: O valor de retorno do método .split() é uma lista de dois elementos. O primeiro é atribuído à usuário e o segundo à domínio. >>> email = 'monty@python.org' >>> usuário, domínio = email.split('@') >>> uname 'monty' >>> domain 'python.org'

Tuplas como valor de retorno A função divmod() recebe dois valores e retorna uma tupla de dois valores, o quociente e o resto. Você pode guardar os resultados como uma tupla: Ou utilizar a atribuição de tuplas e guardar os elementos separadamente: Aqui está um exemplo de uma função que retorna uma tupla: >>> t = divmod(7, 3) >>> t (2, 1) >>> quoc, resto = divmod(7, 3) >>> quoc 2 >>> resto 1 def min_max(t): return min(t), max(t)

Tuplas de tamanho variável como argumentos Funções podem receber um número variável de argumentos. Um nome de parâmetro que começa com * recolhe os argumentos em uma tupla. Por exemplo, imprime_todos() recebe qualquer número de argumento e os imprime: O parâmetro que recolhe pode ter qualquer nome que você queira, mas args é convencional. Veja como a função funciona: def imprime_todos(*args): print(args) >>> imprime_todos(1, 2.0, '3') (1, 2.0, '3')

Tuplas de tamanho variável como argumentos O complemento de recolher é espalhar. Se você tem uma sequência de valores e você tem que passa-los à uma função como múltiplos argumentos, você pode utilizar o operador *. Por exemplo, divmod() pega exatamente dois argumentos e não funciona com uma tupla. Mas se você espalhar a tupla, isto funciona: >>> t = (7, 3) >>> divmod(t) TypeError: divmod expected 2 arguments, got 1 >>> divmod(*t) (2, 1)

Tuplas de tamanho variável como argumentos Muitas das funções que já vem no Python recebem qualquer quantidade de argumentos: Mas sum() não: Como um exercício, crie uma função soma_todos() que recebe qualquer quantidade de argumentos e retorna sua soma. >>> max(1, 2, 3) 3 >>> sum(1, 2, 3) TypeError: sum expected at most 2 arguments, got 3

Listas e Tuplas A função zip recebe 2 ou mais sequências e retorna uma lista de tuplas, onde cada uma contém um elemento de cada sequência. Veja o exemplo: >>> s = 'abc' >>> t = [0, 1, 2] >>> for pair in zip(s, t): . . . print(pair) . . . ('a', 0) ('b', 1) ('c', 2)

Listas e Tuplas Se você quer utilizar operadores e métodos de listas, você pode utilizar um objeto zip para criar uma lista. Se as sequências não são do mesmo tamanho, o resultado tem o tamanho do menor: Você pode utilizar uma atribuição de tupla em um loop for: >>> list(zip(s, t)) [('a', 0), ('b', 1), ('c', 2)] >>> list(zip('Anne', 'Elk')) [('A', 'E'), ('n', 'l'), ('n', 'k')] t = [('a', 0), ('b', 1), ('c', 2)] for letra, numero in t: print(numero, letra)

Listas e Tuplas Assim como na função enumerate: for indice, elemento in enumerate('abc'): print(indice, elemento)

Dicionários e tuplas Dicionários têm um método chamado .items() que retorna uma lista de tuplas, onde cada tupla é um par chave-valor do dicionário: O resultado é um objeto dict_itens, você pode utilizar em um loop for da seguinte forma: Como era de se esperar de dicionários, não está ordenado. >>> d = {'a':0, 'b':1, 'c':2} >>> t = d.items() >>> t dict_items([('c', 2), ('a', 0), ('b', 1)]) >>> for key, value in d.items(): ... print(key, value) ... c 2 a 0 b 1

Tuplas como chaves de dicionários É comum utilizar tuplas como chaves de dicionários (primeiramente porque não podemos utilizar listas). Por exemplo, uma agenda telefônica pode mapear do par primeiro-ultimo nome aos números de telefone. A expressão entre colchetes é uma tupla. Nós podemos utilizar a atribuição de listas para percorrer as chaves: >>> agenda[‘Nome’,’Sobrenome’] = 82988154752 for nome, sobrenome in agenda: print(nome, sobrenome, directory[nome, sobrenome])

Sequências de sequências Listas são mais comuns que tuplas, principalmente porque elas são mutáveis (inalteráveis). Mas existem alguns casos onde você pode preferir utilizar tuplas: Em alguns contextos, como no comando de retorno, é sintaticamente mais simples criar uma tupla que uma lista. Se você usa uma sequência como uma chave de dicionário, você tem que utilizar um valor inalterável, como uma tupla ou string. Se você passar uma sequência como um argumento a uma função, usar tuplas reduz o potencial de comportamento inesperado devido ao serrilhamento.

Depurando código Listas, dicionários e tuplas são exemplos de estruturas de dados. Vimos que é possível fazer composições destas estruturas. Estas composições são muito úteis, mas é bom ter cuidado com os tipos de dados que se espera nas composições para não ter comportamentos inesperados. Isso pode ser chamado de erro de formação ou erro de composição, ou seja, erros causados quando uma estrutura de dados tem tipo, tamanho ou estrutura errados. Para ajudar a identificar esses erros é importante depurar o código, como pelo uso do Python Tutor.