Tuples in Python

Tuples are immutable collections in Python - once created, they cannot be modified. They’re faster than lists and are used for data that shouldn’t change. Tuples are defined with parentheses ().

The key difference between tuples and lists: tuples cannot be modified after creation.

Creating Tuples

Basic Creation

# Form 1: With parentheses
coordenadas = (10, 20)
persona = ("Juan", 30, "Madrid")

# Form 2: Without parentheses (also works)
numeros = 1, 2, 3, 4, 5

# Empty tuple
vacia = ()
# or: vacia = tuple()

Single Element Tuple

For a single-element tuple, you must include a comma:

# Correct - this is a tuple
una_tupla = (42,)  # ✅

# Incorrect - this is just a number in parentheses
no_es_tupla = (42)  # ❌

Convert from List

lista = [1, 2, 3]
tupla_desde_lista = tuple(lista)
print(tupla_desde_lista)  # (1, 2, 3)

Accessing Elements

Accessing tuple elements works exactly like lists:

frutas = ("manzana", "banana", "cereza", "durazno")

# Access by index
print(frutas[0])   # manzana
print(frutas[-1])  # durazno (last element)

# Slicing
print(frutas[1:3])   # ('banana', 'cereza')
print(frutas[:2])    # ('manzana', 'banana')
print(frutas[2:])    # ('cereza', 'durazno')

Immutability

Tuples cannot be modified after creation:

colores = ("rojo", "verde", "azul")

# ❌ Cannot modify elements
# colores[0] = "amarillo"  # TypeError

# ❌ Cannot add elements
# colores.append("negro")  # AttributeError

# ❌ Cannot delete elements
# del colores[0]  # TypeError

Immutability makes tuples safer for data that shouldn’t change and allows them to be used as dictionary keys.

Basic Operations

Concatenation and Repetition

t1 = (1, 2, 3)
t2 = (4, 5, 6)

# Concatenate tuples (creates a NEW tuple)
t3 = t1 + t2
print(t3)  # (1, 2, 3, 4, 5, 6)

# Repeat tuples
t4 = t1 * 3
print(t4)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)

# Length
print(len(t1))  # 3

Check Existence

numeros = (10, 20, 30, 40, 50)

if 30 in numeros:
    print("30 está en la tupla")

if 100 not in numeros:
    print("100 NO está en la tupla")

Tuple Methods

Tuples have only two methods (due to immutability):

count() - Count Occurrences

valores = (1, 2, 3, 2, 4, 2, 5)
print(valores.count(2))  # 3

Counts how many times a value appears in the tuple.

index() - Find Position

valores = (1, 2, 3, 2, 4, 2, 5)
print(valores.index(4))  # 4

# Raises ValueError if not found
# print(valores.index(10))  # ❌ ValueError

Returns the index of the first occurrence of a value.

Tuple Unpacking

One of the most powerful features of tuples is unpacking:

Basic Unpacking

# Assign tuple values to variables
coordenadas = (100, 200)
x, y = coordenadas
print(x)  # 100
print(y)  # 200

# With more elements
persona = ("Ana", 25, "Ingeniera")
nombre, edad, profesion = persona
print(f"{nombre} tiene {edad} años")

Unpacking with * (Rest Operator)

numeros = (1, 2, 3, 4, 5)

# Capture first, second, and rest
primero, segundo, *resto = numeros
print(primero)  # 1
print(segundo)  # 2
print(resto)    # [3, 4, 5] - becomes a list!

# Capture first, middle, and last
primero, *medio, ultimo = numeros
print(medio)  # [2, 3, 4]

When using * in unpacking, the captured elements become a list, not a tuple.

Iterating Over Tuples

Simple Iteration

dias = ("lunes", "martes", "miércoles", "jueves", "viernes")

# Iterate over elements
for dia in dias:
    print(dia)

Iteration with Index

# Use enumerate() to get both index and value
for indice, dia in enumerate(dias):
    print(f"{indice}: {dia}")

Nested Tuples

Tuples can contain other tuples:

# Tuples within tuples
matriz = (
    (1, 2, 3),
    (4, 5, 6),
    (7, 8, 9)
)

print(matriz[0])      # (1, 2, 3)
print(matriz[1][2])   # 6

Comparing Tuples

Tuples are compared element by element, from left to right:

print((1, 2, 3) < (1, 2, 4))   # True
print((1, 2) < (1, 2, 0))      # True (shorter is less)
print(("a", "b") < ("a", "c")) # True

Tuples vs Lists

Advantages of Tuples

Faster than lists
Protect data (immutable)
Can be used as dictionary keys (lists cannot)
Use less memory

# Tuples as dictionary keys
diccionario_con_tuplas = {
    (0, 0): "origen",
    (1, 0): "punto A",
    (0, 1): "punto B"
}
print(diccionario_con_tuplas[(0, 0)])  # origen

# Lists cannot be dictionary keys:
# diccionario = {[1, 2]: "valor"}  # ❌ TypeError: unhashable type: 'list'

When to Use Tuples

Use tuples for:1. Coordinates

punto_3d = (10, 20, 30)

2. Data that shouldn’t change

fecha_nacimiento = (15, 8, 1990)  # día, mes, año

3. Returning multiple values from functions

def calcular_estadisticas(numeros):
    return min(numeros), max(numeros), sum(numeros) / len(numeros)

minimo, maximo, promedio = calcular_estadisticas([1, 2, 3, 4, 5])

4. Dictionary keys

ubicaciones = {
    (40.7128, -74.0060): "Nueva York",
    (51.5074, -0.1278): "Londres"
}

Named Tuples

For more readable code, use namedtuple from the collections module:

from collections import namedtuple

# Create a tuple class with named fields
Punto = namedtuple('Punto', ['x', 'y'])
p = Punto(10, 20)

print(p.x)      # 10 - access by name
print(p[0])     # 10 - access by index (also works)
print(p)        # Punto(x=10, y=20)

# More readable code
Persona = namedtuple('Persona', ['nombre', 'edad', 'ciudad'])
juan = Persona('Juan', 30, 'Madrid')
print(f"{juan.nombre} vive en {juan.ciudad}")

Conversions

# Tuple to list
mi_tupla = (1, 2, 3)
mi_lista = list(mi_tupla)
print(mi_lista)  # [1, 2, 3]

# List to tuple
mi_lista = [4, 5, 6]
mi_tupla = tuple(mi_lista)
print(mi_tupla)  # (4, 5, 6)

# String to tuple
texto = "Python"
tupla_letras = tuple(texto)
print(tupla_letras)  # ('P', 'y', 't', 'h', 'o', 'n')

Key Takeaways

Tuples are immutable - cannot be modified after creation
Tuples are faster and use less memory than lists
Use tuples for fixed data that shouldn’t change
Tuples can be dictionary keys, lists cannot
Tuple unpacking is a powerful feature for working with multiple values
Use namedtuple for more readable code when tuples have many fields

Collections

Iteration

Tuples

Tuples in Python

Creating Tuples

Basic Creation

Single Element Tuple

Convert from List

Accessing Elements

Immutability

Basic Operations

Concatenation and Repetition

Check Existence

Tuple Methods

Tuple Unpacking

Basic Unpacking

Unpacking with * (Rest Operator)

Iterating Over Tuples

Simple Iteration

Iteration with Index

Nested Tuples

Comparing Tuples

Tuples vs Lists

Named Tuples

Conversions

Key Takeaways

Build docs developers (and LLMs) love

Collections

Iteration

Documentation Index

​Tuples in Python

​Creating Tuples

​Basic Creation

​Single Element Tuple

​Convert from List

​Accessing Elements

​Immutability

​Basic Operations

​Concatenation and Repetition

​Check Existence

​Tuple Methods

​Tuple Unpacking

​Basic Unpacking

​Unpacking with * (Rest Operator)

​Iterating Over Tuples

​Simple Iteration

​Iteration with Index

​Nested Tuples

​Comparing Tuples

​Tuples vs Lists

​Named Tuples

​Conversions

​Key Takeaways

Build docs developers (and LLMs) love

Tuples in Python

Creating Tuples

Basic Creation

Single Element Tuple

Convert from List

Accessing Elements

Immutability

Basic Operations

Concatenation and Repetition

Check Existence

Tuple Methods

Tuple Unpacking

Basic Unpacking

Unpacking with * (Rest Operator)

Iterating Over Tuples

Simple Iteration

Iteration with Index

Nested Tuples

Comparing Tuples

Tuples vs Lists

Named Tuples

Conversions

Key Takeaways