Single-element tuples in Python

Single-element tuples in Python Single-element tuples in Python

Single Element Tupleslink image 1

Disclaimer: This post has been translated to English using a machine translation model. Please, let me know if you find any mistakes.

If in Python we want to create a list with a single element, we simply write the element between square brackets, for example:

	
list = [1]
type(list)
Copied
	
list

However, with tuples we cannot write an element within parentheses

	
tupla = (1)
type(tupla)
Copied
	
int

As we can see, Python interprets it as an integer, not as a tuple. To solve this, a comma is added after the element, for example:

	
tupla = (1,)
type(tupla)
Copied
	
tuple

What is this for? When we have a function that returns several parameters, what it is actually returning is a tuple. So, it may happen that we have a code that calls a function, checks the length of the returned tuple, and processes each element of the tuple. Let's look at an example

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

But, what happens in this example if the function doesn't return a tuple? We would get an error

	
def return_int():
return 1
def process_tuple():
tuple = return_int()
for i in tuple:
print(i)
process_tuple()
Copied
	
---------------------------------------------------------------------------
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

We get an error because Python tries to iterate through what the function returns, but since it returns an integer it can't iterate through it. We have two ways to solve this, one is that the processing function checks if a tuple has been returned and in that case processes it, another is that the function that returns values always returns a tuple, even if it is a single element.

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

As we see, in the return_int function a , has been placed at the end of the return, so it is returning a tuple with a single element, which is why the process_tuple function will not give an error.

Continue reading

Last posts -->

Have you seen these projects?

Horeca chatbot

Horeca chatbot Horeca chatbot
Python
LangChain
PostgreSQL
PGVector
React
Kubernetes
Docker
GitHub Actions

Chatbot conversational for cooks of hotels and restaurants. A cook, kitchen manager or room service of a hotel or restaurant can talk to the chatbot to get information about recipes and menus. But it also implements agents, with which it can edit or create new recipes or menus

Subtify

Subtify Subtify
Python
Whisper
Spaces

Subtitle generator for videos in the language you want. Also, it puts a different color subtitle to each person

View all projects -->

Do you want to apply AI in your project? Contact me!

Do you want to watch any talk?

Tomorrow's Agents: Deciphering the Mysteries of Planning, UX and Memory

Tomorrow's Agents: Deciphering the Mysteries of Planning, UX and Memory

AI agents, powered by LLMs, promise to transform applications. But are they simple executors today or future intelligent collaborators? To reach their true potential, we must overcome critical barriers. This talk delves into the three puzzles that will define the next generation of agents: 1. Advanced Planning (The Brain): Today's agents often stumble on complex tasks. We'll explore how, beyond basic function calls, cognitive architectures enable robust plans, anticipation of problems, and deep reasoning. How do we make them think several steps ahead? 2. Revolutionary UX (The Soul): Interacting with an agent cannot be a source of frustration. We'll discuss how to transcend traditional chat toward human-on-the-loop interfaces—collaborative, generative, and accessible UX. How to Design Engaging Experiences? 3. Persistent Memory (The Legacy): An agent that forgets what it's learned is doomed to inefficiency. We'll look at techniques for empowering agents with meaningful memory that goes beyond their history, enabling them to learn and making each interaction smarter. With practical examples, we'll not only understand the magnitude of these challenges, but we'll also take away concrete ideas and a clear vision to help build the agents of tomorrow: smarter, more intuitive, and truly capable. Will you join us on the journey to unravel the next chapter of AI agents?

Last talks -->

Do you want to improve with these tips?

Last tips -->

Use this locally

Hugging Face spaces allow us to run models with very simple demos, but what if the demo breaks? Or if the user deletes it? That's why I've created docker containers with some interesting spaces, to be able to use them locally, whatever happens. In fact, if you click on any project view button, it may take you to a space that doesn't work.

Flow edit

Flow edit Flow edit

FLUX.1-RealismLora

FLUX.1-RealismLora FLUX.1-RealismLora
View all containers -->

Do you want to apply AI in your project? Contact me!

Do you want to train your model with these datasets?

short-jokes-dataset

Dataset with jokes in English

opus100

Dataset with translations from English to Spanish

netflix_titles

Dataset with Netflix movies and series

View more datasets -->