Python · Lección 09 de 27

Tuplas

Las tuplas son la versión inmutable de las listas. Una vez creadas, no podés modificar sus elementos. Esa restricción, lejos de ser una limitación, es su mayor fortaleza: garantizan que ciertos datos no cambien accidentalmente.

60–80 min Prerrequisitos: 08 Listas

Concepto teórico

¿Qué es una tupla?

Una tupla es una colección ordenada e inmutable de elementos. Se crea con paréntesis () o simplemente separando valores con comas. La diferencia fundamental con las listas es que, una vez creada, no podés agregar, eliminar ni modificar sus elementos. Si intentás hacerlo, Python lanza un TypeError.

coordenadas = (34.6037, 58.3816)       # tupla con paréntesis
punto = 34.6037, 58.3816                # también válido (sin paréntesis)
singleton = (42,)                        # tupla de UN elemento (la coma es obligatoria)
no_es_tupla = (42)                       # esto es solo el int 42 entre paréntesis
vacia = ()                               # tupla vacía

Trampa clásica: la tupla de un elemento. (42) NO es una tupla — es el número 42 entre paréntesis (como en matemáticas). Para una tupla de un elemento necesitás la coma: (42,). Esto confunde al 100% de los principiantes al menos una vez.

¿Por qué usar algo que no se puede modificar?

La inmutabilidad parece una limitación, pero en realidad te da tres ventajas enormes:

Seguridad: si tenés datos que NO deben cambiar (coordenadas geográficas, constantes de configuración, un registro de base de datos), la tupla garantiza que nadie los modifique por error. Una lista puede ser mutada por cualquier función que la reciba como argumento.
Rendimiento: las tuplas son más rápidas que las listas porque Python las optimiza internamente. Para datos estáticos, siempre preferí tuplas.
Hashability: las tuplas pueden usarse como claves de diccionario y como elementos de sets. Las listas no, precisamente porque son mutables. Esto es fundamental para ciertos patrones de datos.

Analogía bancaria: pensá en una tupla como un comprobante de transferencia: tiene fecha, monto, origen y destino. Una vez emitido, no se puede alterar — solo podés emitir uno nuevo. Una lista sería como un presupuesto en borrador: lo modificás, agregás ítems, borrás otros, hasta que quede listo.

Packing y unpacking

Packing es cuando Python empaqueta varios valores en una tupla automáticamente:

datos = "García", 35, "Buenos Aires" → Python crea la tupla ("García", 35, "Buenos Aires")

Unpacking es lo contrario: extraer los valores de una tupla a variables individuales:

nombre, edad, ciudad = datos → nombre = "García", edad = 35, ciudad = "Buenos Aires"

El unpacking es increíblemente versátil:

Parcial con *: primero, *resto = (1, 2, 3, 4, 5) → primero = 1, resto = [2, 3, 4, 5]
Ignorar con _: nombre, _, ciudad = datos → la edad se descarta
Swap de variables: a, b = b, a es en realidad packing + unpacking de tuplas
Retorno múltiple de funciones: return total, promedio devuelve una tupla que podés desempaquetar

Dato clave: cuando una función devuelve return a, b, en realidad devuelve (a, b) — una tupla. Cuando hacés x, y = funcion(), estás desempaquetando esa tupla. Este patrón es ubicuo en Python profesional.

namedtuple: tuplas con nombres

Las tuplas normales acceden a elementos por posición (datos[0], datos[1]), lo cual es poco legible. namedtuple del módulo collections te permite dar nombres a cada posición, combinando la inmutabilidad de las tuplas con la legibilidad de los diccionarios:

from collections import namedtuple

Cliente = namedtuple("Cliente", ["nombre", "edad", "score"])
c = Cliente("García", 35, 720)
print(c.nombre)  # "García" — acceso por nombre, mucho más claro que c[0]
print(c.score)   # 720

En análisis de datos: las tuplas aparecen por todos lados. Un DataFrame.shape devuelve una tupla (filas, columnas). DataFrame.iterrows() devuelve tuplas (índice, fila). .groupby().agg() con multi-index devuelve tuplas como claves. Si dominás tuplas, pandas se entiende mejor.

Cuándo usar tupla vs lista

Usá tupla cuando…	Usá lista cuando…
Los datos no deben cambiar	Necesitás agregar/eliminar elementos
Representás un "registro" fijo (nombre, edad, score)	Representás una colección que crece/decrece
Necesitás usarla como clave de diccionario	Necesitás ordenar in-place
Devolvés múltiples valores de una función	Procesás datos iterativamente
Querés rendimiento en datos estáticos	El tamaño varía durante ejecución

Regla práctica: si te preguntás "¿necesito modificar esto después?", la respuesta determina tu elección. Si la respuesta es no → tupla. Si es sí → lista. Ante la duda, empezá con tupla y cambiá a lista solo si necesitás mutabilidad.

Ejemplos explicados paso a paso

Ejemplo 1: Crear tuplas y verificar inmutabilidad

Creamos tuplas de distintas formas y demostramos que no se pueden modificar.

ejemplo_01_crear.pyPython

# Formas de crear tuplas
con_parentesis = (1, 2, 3)
sin_parentesis = 4, 5, 6    # el paréntesis es opcional
singleton = (42,)            # tupla de 1 elemento — ¡la coma!
vacia = ()
desde_lista = tuple([10, 20, 30])

print(f"Con paréntesis: {con_parentesis} — tipo: {type(con_parentesis).__name__}")
print(f"Sin paréntesis: {sin_parentesis} — tipo: {type(sin_parentesis).__name__}")
print(f"Singleton: {singleton} — tipo: {type(singleton).__name__}")
print(f"(42) sin coma: {(42)} — tipo: {type((42)).__name__}")  # int, NO tupla!
print(f"Desde lista: {desde_lista}")

# Las tuplas son INMUTABLES
print(f"\nPodés LEER: {con_parentesis[0]}, {con_parentesis[-1]}")
print(f"Slicing: {con_parentesis[1:]}")

# Pero NO modificar:
try:
    con_parentesis[0] = 99
except TypeError as e:
    print(f"\n❌ Error al modificar: {e}")
    print("Las tuplas son inmutables — no se pueden cambiar")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Packing, unpacking y swap

El unpacking de tuplas es una de las herramientas más elegantes de Python. La usás constantemente sin darte cuenta.

ejemplo_02_unpacking.pyPython

# Packing automático
datos = "García", 35, "Buenos Aires", 720
print(f"Packing: {datos} — tipo: {type(datos).__name__}")

# Unpacking a variables
nombre, edad, ciudad, score = datos
print(f"\nUnpacking: {nombre}, {edad} años, {ciudad}, score {score}")

# Unpacking parcial con *
numeros = (100, 200, 300, 400, 500)
primero, *medio, ultimo = numeros
print(f"\nPrimero: {primero}, Medio: {medio}, Último: {ultimo}")

# Ignorar valores con _
registro = ("López", 42, "Córdoba", 680, 250000)
nombre, _, ciudad, _, ingreso = registro
print(f"Solo nombre, ciudad, ingreso: {nombre}, {ciudad}, ${ingreso:,}")

# Swap (intercambio) — esto es packing + unpacking
a = "dólares"
b = "pesos"
print(f"\nAntes: a={a}, b={b}")
a, b = b, a  # internamente: temp = (b, a); a, b = temp
print(f"Después: a={a}, b={b}")

# Devolver múltiples valores de una función
def analizar_cartera(saldos):
    return min(saldos), max(saldos), sum(saldos) / len(saldos)

minimo, maximo, promedio = analizar_cartera([150000, 320000, 45000])
print(f"\nMin: ${minimo:,}, Max: ${maximo:,}, Prom: ${promedio:,.0f}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Tuplas como registros de datos

Las tuplas son perfectas para representar registros fijos donde cada posición tiene un significado.

ejemplo_03_registros.pyPython

# Base de datos simplificada: lista de tuplas
# Cada tupla = (nombre, ciudad, score, saldo)
clientes = [
    ("García", "Buenos Aires", 720, 150000),
    ("López", "Córdoba", 680, 320000),
    ("Martínez", "Rosario", 590, 45000),
    ("Pérez", "Buenos Aires", 810, 890000),
    ("Fernández", "Mendoza", 645, 72000),
]

# Recorrer con unpacking
print("=== Cartera de clientes ===")
for nombre, ciudad, score, saldo in clientes:
    estado = "✅" if score >= 650 else "❌"
    print(f"  {estado} {nombre:<12} {ciudad:<15} Score:{score} ${saldo:>10,}")

# Filtrar: clientes de Buenos Aires
bsas = [c for c in clientes if c[1] == "Buenos Aires"]
print(f"\nClientes en BsAs: {len(bsas)}")
for nombre, _, _, saldo in bsas:
    print(f"  {nombre}: ${saldo:,}")

# Ordenar por score (descendente) — sorted devuelve nueva lista
por_score = sorted(clientes, key=lambda c: c[2], reverse=True)
print(f"\nRanking por score:")
for i, (nombre, _, score, _) in enumerate(por_score, 1):
    print(f"  {i}. {nombre}: {score}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: namedtuple — tuplas legibles

Cuando cliente[2] no te dice nada, cliente.score se explica solo.

ejemplo_04_namedtuple.pyPython

from collections import namedtuple

# Definir la estructura
Cliente = namedtuple("Cliente", ["nombre", "edad", "ciudad", "score", "saldo"])

# Crear instancias
c1 = Cliente("García", 35, "Buenos Aires", 720, 150000)
c2 = Cliente("López", 42, "Córdoba", 680, 320000)
c3 = Cliente(nombre="Pérez", edad=28, ciudad="Rosario", score=810, saldo=890000)

# Acceso por nombre (mucho más claro que [0], [1], etc.)
print(f"Nombre: {c1.nombre}")
print(f"Score: {c1.score}")
print(f"Saldo: ${c1.saldo:,}")

# Sigue siendo tupla — inmutable y desempaquetable
print(f"\nTipo: {type(c1).__name__}")
print(f"Es tupla: {isinstance(c1, tuple)}")
nombre, _, _, score, _ = c1
print(f"Unpacking: {nombre}, score {score}")

# Lista de namedtuples — procesamiento elegante
cartera = [c1, c2, c3]
total = sum(c.saldo for c in cartera)
print(f"\nTotal cartera: ${total:,}")

# Top por score
mejor = max(cartera, key=lambda c: c.score)
print(f"Mejor score: {mejor.nombre} ({mejor.score})")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Tuplas como claves de diccionario y en operaciones

Algo que las listas NO pueden hacer: ser claves de diccionario. Las tuplas sí, porque son inmutables (hashables).

ejemplo_05_claves.pyPython

# Tuplas como claves de diccionario
# Útil para mapear pares de valores a un resultado
tasas_por_segmento = {
    ("Premium", "Buenos Aires"): 0.035,
    ("Premium", "Interior"): 0.040,
    ("Estándar", "Buenos Aires"): 0.055,
    ("Estándar", "Interior"): 0.060,
}

segmento = "Premium"
zona = "Buenos Aires"
tasa = tasas_por_segmento[(segmento, zona)]
print(f"Tasa para {segmento} en {zona}: {tasa:.1%}")

# Matriz de distancias (par de ciudades → km)
distancias = {
    ("Buenos Aires", "Córdoba"): 695,
    ("Buenos Aires", "Rosario"): 300,
    ("Córdoba", "Rosario"): 400,
    ("Buenos Aires", "Mendoza"): 1050,
}

ruta = ("Buenos Aires", "Córdoba")
print(f"\n{ruta[0]} → {ruta[1]}: {distancias[ruta]} km")

# Operaciones con tuplas
t1 = (1, 2, 3)
t2 = (4, 5, 6)
print(f"\nConcatenación: {t1 + t2}")
print(f"Repetición: {t1 * 3}")
print(f"Pertenencia: {2 in t1}")
print(f"Largo: {len(t1)}")
print(f"Min/Max: {min(t1)}, {max(t1)}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Operación	Sintaxis	Resultado
Crear	`(1, 2, 3)` o `1, 2, 3`	Tupla
Singleton	`(42,)` ← coma obligatoria	Tupla de 1 elem
Desde lista	`tuple([1,2,3])`	`(1, 2, 3)`
Acceso	`t[0]`, `t[-1]`	Elemento
Slicing	`t[1:3]`	Nueva tupla
Unpacking	`a, b, c = t`	Variables
Parcial	`a, *rest = t`	var + lista
Concatenar	`t1 + t2`	Nueva tupla
Repetir	`t * 3`	Nueva tupla
Pertenencia	`x in t`	`True/False`
Contar	`t.count(x)`	`int`
Buscar	`t.index(x)`	`int`

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Crear y acceder

Creá una tupla moneda con los valores ("Peso argentino", "ARS", 1). Imprimí cada elemento por nombre descriptivo. Debe incluir ARS.

ejercicio_01.pyDebe incluir "ARS"

moneda = ("Peso argentino", "ARS", 1)

# Imprimí nombre, código y valor:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Singleton y verificación de tipo

Creá una tupla de un solo elemento (42,) y otra sin coma (42). Imprimí el tipo de cada una para demostrar la diferencia. Debe incluir int.

ejercicio_02.pyDebe incluir "int"

# Demostrá la diferencia:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Unpacking básico

Dada persona = ("Fernández", 30, "Mendoza"), desempaquetá en nombre, edad, ciudad e imprimí con f-string. Debe incluir Mendoza.

ejercicio_03.pyDebe incluir "Mendoza"

persona = ("Fernández", 30, "Mendoza")

# Desempaquetá e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Función con retorno múltiple

Creá una función estadisticas(numeros) que devuelva una tupla con (minimo, maximo, promedio). Probala con [45000, 72000, 38000, 91000]. Debe incluir 61500.

ejercicio_04.pyDebe incluir "61500"

def estadisticas(numeros):
    # Devolvé (min, max, promedio):
    pass

datos = [45000, 72000, 38000, 91000]
mi, ma, pr = estadisticas(datos)
print(f"Min: {mi}, Max: {ma}, Promedio: {pr}")

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Unpacking parcial con *

Dada ranking = ("Pérez", "García", "López", "Martínez", "Sosa"), usá unpacking para extraer el primero, el último, y el resto en una variable medio. Imprimí los tres. Debe incluir Pérez.

ejercicio_05.pyDebe incluir "Sosa"

ranking = ("Pérez", "García", "López", "Martínez", "Sosa")

# Desempaquetá primero, *medio, ultimo:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Ordenar lista de tuplas

Dada esta lista de tuplas (nombre, saldo), ordenalas por saldo descendente e imprimí el ranking. Debe incluir 890000.

ejercicio_06.pyDebe incluir "890000"

clientes = [
    ("García", 150000),
    ("López", 320000),
    ("Pérez", 890000),
    ("Sosa", 45000),
]

# Ordená por saldo descendente e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Tuplas como claves de diccionario

Creá un diccionario precios donde las claves sean tuplas (producto, tamaño) y los valores sean precios. Consultá el precio de ("Café", "Grande"). Debe incluir 2800.

ejercicio_07.pyDebe incluir "2800"

# Creá el diccionario con tuplas como claves:
precios = {
    # (producto, tamaño): precio
}

# Consultá ("Café", "Grande"):

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: namedtuple para datos de clientes

Creá un namedtuple llamado Cuenta con campos titular, tipo, saldo. Creá 3 cuentas y calculá el saldo total. Debe incluir Total:.

ejercicio_08.pyDebe incluir "Total:"

from collections import namedtuple

# Definí Cuenta, creá 3 instancias y sumá saldos:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Enumerate con unpacking

Dada una lista de tuplas operaciones = [("Compra", 15000), ("Venta", 8000), ("Compra", 22000), ("Venta", 5000)], recorrela con enumerate y unpacking para imprimir cada operación numerada. Calculá el balance final (compras positivas, ventas negativas). Debe incluir Balance: 24000.

ejercicio_09.pyDebe incluir "Balance: 24000"

operaciones = [("Compra", 15000), ("Venta", 8000), ("Compra", 22000), ("Venta", 5000)]

# Recorré con enumerate + unpacking y calculá balance:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Sistema de cotizaciones de monedas

Tenés cotizaciones como tuplas (moneda, compra, venta). Creá una lista con al menos 4 cotizaciones (USD oficial, USD MEP, EUR, BRL). Convertí USD 1000 a pesos con la cotización de venta del dólar MEP. Imprimí una tabla formateada con todas las cotizaciones y la brecha porcentual compra-venta. Debe incluir Brecha.

ejercicio_10_desafio.pyDebe incluir "Brecha"

# Cotizaciones: (moneda, compra, venta)
cotizaciones = [
    # Completá con al menos 4 monedas
]

# Tabla formateada + conversión USD 1000 a pesos:

Hacé clic en ▶ Ejecutar

Resumen y conexión

Las tuplas son colecciones ordenadas e inmutables. Se crean con () o solo comas.
Una tupla de un elemento necesita coma: (42,), no (42).
Packing (a, b = 1, 2) y unpacking (x, y = tupla) son herramientas fundamentales.
Las funciones que devuelven return a, b están devolviendo tuplas.
Las tuplas pueden ser claves de diccionario (las listas no).
namedtuple combina la inmutabilidad de las tuplas con la legibilidad del acceso por nombre.
Usá tupla para datos fijos, lista para datos que cambian.

En la siguiente lección (10 · Diccionarios) vas a aprender la estructura de datos más importante para análisis: pares clave-valor que te permiten representar registros completos de datos.

Recursos: Python docs — Tuples · collections.namedtuple

Hecho con ❤️ por Rodri Gonzalez