Tuplas de um único elemento em Python

09 de setembro de 2024

Tuplas de um único elemento

Aviso: Este post foi traduzido para o português usando um modelo de tradução automática. Por favor, me avise se encontrar algum erro.

Se em Python queremos criar uma lista de um único elemento simplesmente escrevemos o elemento entre colchetes, por exemplo:

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		list = [1]
type(list)
	
	Copied

>_ Output

			
				list

No entanto, com as tuplas não podemos escrever um elemento entre parênteses

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = (1)
type(tupla)
	
	Copied

>_ Output

int

Como vemos, Python o interpreta como um inteiro, não como uma tupla. Para resolver isso, adiciona-se uma vírgula após o elemento, por exemplo:

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = (1,)
type(tupla)
	
	Copied

>_ Output

			
				tuple

E para que isso serve? Quando temos uma função que devolve vários parâmetros, na verdade o que está devolvendo é uma tupla. Então pode acontecer de termos um código que chama uma função, verifica o comprimento da tupla que ela devolve e processa cada elemento da tupla. Vamos ver um exemplo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def return_tuple():
    return 1, 2, 3
def process_tuple():
    tuple = return_tuple()
    for i in tuple:
        print(i)
process_tuple()
	
	Copied

>_ Output

Mas o que acontece neste exemplo se a função não devolver uma tupla? Obteremos um erro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def return_int():
    return 1
def process_tuple():
    tuple = return_int()
    for i in tuple:
        print(i)
process_tuple()
	
	Copied

>_ Output

			
				---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[5], line 9
      6     for i in tuple:
      7         print(i)
----> 9 process_tuple()
Cell In[5], line 6, in process_tuple()
      4 def process_tuple():
      5     tuple = return_int()
----> 6     for i in tuple:
      7         print(i)
TypeError: 'int' object is not iterable

Obtemos um erro porque Python tenta iterar através do que a função retorna, mas como retorna um inteiro, não pode iterar através dele. Temos duas maneiras de resolver isso, uma é que a função que processa verifique se uma tupla foi retornada e, nesse caso, a processe, outra é que a função que retorna valores sempre retorne uma tupla, mesmo que seja de um único elemento.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def return_int():
    return 1,
def process_tuple():
    tuple = return_int()
    for i in tuple:
        print(i)
process_tuple()
	
	Copied

>_ Output

Como vemos, na função return_int foi colocada uma , no final do return, então está devolvendo uma tupla de um único elemento, por isso a função process_tuple não dará erro.

Perguntas frequentes

Por que aparece "TypeError: 'int' object is not iterable" ao fazer for i in tuple: sobre o valor retornado por uma função?

Isso ocorre quando uma função como def return_int(): return 1 retorna um único valor: em Python, return 1 produz um int, não uma tupla, então o laço for i in tuple: não consegue iterar sobre ele. A solução é forçar a função a retornar uma tupla de um único elemento adicionando uma vírgula ao final: return 1, (equivalente a return (1,)), o que muda type(tupla) de int para tuple e faz o laço funcionar novamente.

Como faço para que uma função sempre retorne uma tupla, mesmo quando tem apenas um valor a retornar?

Basta adicionar uma vírgula depois do valor no return, por exemplo return 1, em vez de return 1. Isso é útil quando outra função processa o resultado com um laço genérico (for i in tuple: print(i)) que sempre espera uma tupla, como no padrão return 1, 2, 3 de return_tuple(): assim o código que consome o valor não precisa verificar se recebeu um inteiro ou uma tupla.

Continuar lendo

Como declarar tools confiáveis para OpenAI, Anthropic e Google

Guia prático para criar tools que um LLM consiga descobrir, adaptar para qualquer provedor de LLMs, executar com segurança e proteger com testes.

Gymnasia: arquitetura de um agente de IA que roda no celular

Como o agente de IA do Gymnasia foi construído: um coach conversacional BYOK com tools locais e um estimador de refeiçõe...

Deep Research com LangGraph (3/3): agente Writer e relatório final

Terceira e última parte da série Deep Research com LangGraph. Implemente o agente Writer que redige o relatório final a ...

Últimos posts -->

Você viu esses projetos?

Gymnasia

LangGraph Deep Researcher

Tau

Ver todos os projetos -->

>_ Disponível para projetos

Tem um projeto com IA?

Vamos conversar.

maximofn@gmail.com

Especialista em Machine Learning e Inteligência Artificial. Desenvolvo soluções com IA generativa, agentes inteligentes e modelos personalizados.

Escreva-me LinkedIn

Quer assistir alguma palestra?

Agentes do Amanhã: Descifrando os Mistérios da Planificação, UX e Memória

Agentes de IA, impulsionados por LLMs, prometem transformar aplicações. Mas eles são meros executores hoje ou futuros colaboradores inteligentes? Para...

Crie sua própria inteligência Apple

Aprenda a criar um sistema de IA para executar eficientemente em um dispositivo

Últimas palestras -->

Quer melhorar com essas dicas?

Boas práticas criando agentes com Claude Code

Palestra técnica: skills, subagentes, slash commands e MCPs no Claude Code

o1 prompt engineering

Criar prompts melhores para o1 seguindo um exemplo

Memory profiler

Ver o uso de memória de um script

Últimos tips -->

Use isso localmente

Os espaços do Hugging Face nos permitem executar modelos com demos muito simples, mas e se a demo quebrar? Ou se o usuário a deletar? Por isso, criei contêineres docker com alguns espaços interessantes, para poder usá-los localmente, aconteça o que acontecer. Na verdade, se você clicar em qualquer botão de visualização de projeto, ele pode levá-lo a um espaço que não funciona.