3.2.-Est.Datos: Tuplas
3.2. Tuplas¶
Idea principal
Una tupla es una secuencia ordenada e inmutable. Permite agrupar varios valores, acceder a ellos por posición, recorrerlos y desempaquetarlos sin que el programa pueda cambiar las referencias que contiene la tupla.
En el tema anterior vimos que una lista es una colección ordenada y mutable. En
muchos programas también necesitamos representar datos que deben conservar su
estructura durante toda la operación: las coordenadas de un punto, una fecha,
los componentes de un color RGB o los valores que devuelve una función. Para
estos casos, Python ofrece la clase tuple.
Las tuplas no son simplemente «listas con menos métodos». Su inmutabilidad expresa una decisión del diseño: el conjunto de elementos y su orden forman un valor que no debe modificarse accidentalmente. En este tema aprenderás a crear tuplas, elegir entre listas y tuplas, consultar sus elementos y aprovechar el desempaquetado en programas reales.
Este contenido se relaciona con el RA 6 del módulo de Programación,
«Escribe programas que manipulen información seleccionando y utilizando tipos
avanzados de datos». Se trabaja especialmente el CE 6.e, porque hay que
reconocer las características y ventajas de cada colección. También se aplican
los recorridos de colecciones del CE 6.d, las operaciones agregadas del
CE 6.j y, al utilizar collections.namedtuple, el reconocimiento de
librerías de tipos avanzados del CE 6.b. La comparación con listas conecta
con el CE 6.c, aunque el foco de este tema son las tuplas.
| Código | Descripción |
|---|---|
| RA 6 | Escribe programas que manipulen información seleccionando y utilizando tipos avanzados de datos. |
| CE 6.b | Se han reconocido las librerías de clases relacionadas con tipos de datos avanzados. |
| CE 6.c | Se han utilizado listas para almacenar y procesar información. |
| CE 6.d | Se han utilizado iteradores para recorrer los elementos de las listas. |
| CE 6.e | Se han reconocido las características y ventajas de cada una de las colecciones de datos disponibles. |
| CE 6.j | Se han utilizado operaciones agregadas para el manejo de información almacenada en colecciones. |
Qué deberías saber al terminar
Al acabar este tema deberías poder:
- crear tuplas vacías, de uno o varios elementos y a partir de iterables;
- explicar la diferencia entre una tupla y una lista y elegir la colección que corresponde a cada problema;
- acceder a posiciones, rebanadas y elementos anidados de una tupla;
- recorrer, buscar, contar y resumir sus elementos;
- distinguir entre inmutar una tupla, reasignar una variable y modificar un objeto mutable contenido en ella;
- utilizar el desempaquetado normal y extendido en asignaciones, bucles y retornos de funciones;
- usar tuplas como claves de diccionario cuando todos sus elementos sean hashables y reconocer cuándo conviene un registro con nombre.
Mapa del tema
En este documento seguiremos una secuencia de dificultad creciente:
- conocer la estructura y sus formas de creación;
- consultar, recorrer y comparar tuplas;
- entender la inmutabilidad y las operaciones que crean nuevas tuplas;
- aplicar el desempaquetado, los métodos y las operaciones agregadas;
- elegir tuplas para claves, registros y pequeños casos prácticos.
1. Qué es una tupla¶
La clase tuple es un contenedor y, al mismo tiempo, una secuencia. Una tupla
mantiene el orden de inserción, admite valores repetidos y puede contener
elementos de distintos tipos. También puede contener otras colecciones u
objetos.
Tupla
Una tupla es una secuencia ordenada, indexada e inmutable. Es ordenada porque conserva la posición de sus elementos, indexada porque cada posición se puede consultar con un índice entero e inmutable porque no se pueden sustituir, añadir ni eliminar las referencias que contiene una vez creada.
Por ejemplo, estas tuplas conservan tanto el orden como los tipos de sus elementos:
numeros = (1, 2, 3, 4, 5)
datos = (3, "Python", 7.2, True)
registro = ("Ana", ["Python", "Kotlin"], "DAW")
print(numeros[0]) # 1
print(datos[-1]) # True
La inmutabilidad afecta a la tupla como contenedor. Más adelante veremos que
un objeto mutable, como la lista de registro, puede cambiar internamente.
1.1. Crear tuplas¶
La forma más habitual consiste en separar los elementos con comas. Los paréntesis hacen más visible la intención y ayudan a evitar ambigüedades, pero la coma es el elemento sintáctico que crea la tupla.
# Tupla vacía
vacia_1 = ()
vacia_2 = tuple()
# Tupla con varios elementos
vocales = ("a", "e", "i", "o", "u")
# Los paréntesis son opcionales en un contexto no ambiguo
coordenadas = 41.3874, 2.1686
Para crear una tupla de un solo elemento es imprescindible escribir una coma:
una_tupla = (5,)
no_es_tupla = (5)
print(type(una_tupla)) # <class 'tuple'>
print(type(no_es_tupla)) # <class 'int'>
La coma es obligatoria en la tupla unitaria
(5) solo agrupa la expresión numérica y produce el entero 5. En
cambio, (5,) contiene un elemento y produce una tupla. Este detalle es
especialmente importante al concatenar o pasar una tupla como argumento.
La función tuple(iterable) construye una tupla con los elementos de un objeto
iterable, en el mismo orden. Una cadena se recorre carácter a carácter y un
diccionario aporta sus claves:
desde_lista = tuple([1, 2, 3])
desde_cadena = tuple("sol")
desde_rango = tuple(range(3))
desde_diccionario = tuple({"nombre": "Ana", "edad": 20})
print(desde_lista) # (1, 2, 3)
print(desde_cadena) # ('s', 'o', 'l')
print(desde_rango) # (0, 1, 2)
print(desde_diccionario) # ('nombre', 'edad')
1.2. Tuple packing y desempaquetado¶
Cuando varios valores separados por comas se agrupan en una sola tupla se habla de tuple packing o empaquetado de tuplas:
El proceso inverso es el desempaquetado: varias variables reciben los elementos de una secuencia. Se desarrolla con detalle en la sección 5.
Al llamar a una función hay que distinguir los argumentos separados por comas de una tupla pasada como un único argumento:
def mostrar_punto(punto):
print(punto)
mostrar_punto(10, 20) # TypeError: se han pasado dos argumentos
mostrar_punto((10, 20)) # Un único argumento, que es una tupla
2. Tuplas y listas: elegir la estructura adecuada¶
Las dos estructuras son secuencias ordenadas y admiten duplicados. La diferencia decisiva es la mutabilidad:
| Característica | list |
tuple |
|---|---|---|
| Conserva el orden | Sí | Sí |
| Permite duplicados | Sí | Sí |
| Se puede cambiar después de crearla | Sí | No |
| Acceso por índice | Sí | Sí |
| Métodos de modificación | append, remove, sort... |
No dispone de ellos |
| Uso habitual | Colección que crece o cambia | Registro o conjunto fijo de valores |
Elige una lista cuando necesites añadir, quitar, sustituir u ordenar
elementos durante la ejecución. Elige una tupla cuando el número, el orden
y el significado de los elementos formen un valor estable, como (año, mes,
día) o (x, y).
lista_tareas = ["leer", "practicar"]
lista_tareas.append("repasar")
fecha = (2026, 11, 17)
# fecha.append(18) # AttributeError: una tupla no tiene append()
flowchart LR
A{"¿La colección debe cambiar?"}
A -->|"Sí"| B["Usa list<br/>append, remove, sort"]
A -->|"No"| C["Usa tuple<br/>registro ordenado"]
B --> D["Lista de tareas"]
C --> E["Coordenada o configuración"]
Una tupla suele ocupar menos memoria que una lista equivalente porque no tiene que reservar la misma capacidad para crecer. También puede ofrecer ventajas de rendimiento en algunas operaciones. No obstante, estas diferencias dependen de la operación y de los datos: la razón principal para elegir una tupla es expresar que sus elementos no deben cambiar, no realizar una promesa de velocidad.
Inmutabilidad no significa que todo sea constante
Una tupla no permite sustituir sus referencias, pero puede contener un objeto mutable. Si la colección interna cambia, observarás un nuevo estado al consultar la tupla. Por eso, la inmutabilidad de una tupla es superficial respecto de los objetos que contiene.
Se puede convertir una colección de un tipo a otro:
tareas = ["leer", "practicar"]
tareas_fijas = tuple(tareas)
coordenadas = (10, 20)
coordenadas_editables = list(coordenadas)
coordenadas_editables.append(30)
Convertir a una lista permite editar una copia de los elementos de primer nivel; convertir de nuevo a tupla expresa que el resultado ya no debe cambiar.
3. Acceder y recorrer una tupla¶
3.1. Índices positivos y negativos¶
Los índices empiezan en cero. En una tupla de cinco elementos, las posiciones
válidas son 0, 1, 2, 3 y 4:
vocales = ("a", "e", "i", "o", "u")
print(vocales[0]) # a, primer elemento
print(vocales[2]) # i, tercer elemento
print(vocales[4]) # u, último elemento
Los índices negativos cuentan desde el final. -1 es el último elemento y -2
el penúltimo:
Un índice que no existe produce IndexError. El índice debe ser un entero o una
rebanada; usar un número decimal produce TypeError:
datos = (10, 20, 30)
# datos[3] # IndexError: tuple index out of range
# datos[1.0] # TypeError: los índices deben ser enteros o slices
El último índice es len(datos) - 1, no len(datos). Para acceder al último
elemento de forma directa puede usarse datos[-1], después de comprobar que la
tupla no está vacía.
3.2. Rebanadas o slicing¶
La sintaxis general es tupla[inicio:fin:paso]. El inicio se incluye y el fin
se excluye:
letras = ("a", "b", "c", "d", "e", "f")
print(letras[1:4]) # ('b', 'c', 'd')
print(letras[:3]) # ('a', 'b', 'c')
print(letras[3:]) # ('d', 'e', 'f')
print(letras[:]) # ('a', 'b', 'c', 'd', 'e', 'f')
print(letras[::2]) # ('a', 'c', 'e')
print(letras[::-1]) # ('f', 'e', 'd', 'c', 'b', 'a')
Una rebanada crea otra tupla y deja intacta la original. Al igual que ocurre con las listas, la copia es superficial: si los elementos son objetos mutables, las dos tuplas pueden compartir esos objetos internos.
3.3. Longitud, pertenencia y recorridos¶
len() devuelve el número de elementos. Los operadores in y not in
comprueban si un valor está presente:
colores = ("azul", "blanco", "negro")
print(len(colores)) # 3
print("azul" in colores) # True
print("verde" not in colores) # True
La forma habitual de recorrer una tupla es usar for directamente sobre ella:
Si se necesita también la posición, enumerate() proporciona parejas que se
pueden desempaquetar:
Recorrer directamente los elementos suele ser más claro que construir índices
con range(len(tupla)). El índice solo es necesario si el algoritmo trabaja
realmente con posiciones.
4. Inmutabilidad y operaciones sobre tuplas¶
4.1. Qué no se puede modificar¶
Una tupla no permite asignar un valor a una posición, añadir elementos ni
eliminar elementos con del:
coordenadas = (10, 20)
# coordenadas[0] = 99 # TypeError
# coordenadas.append(30) # AttributeError
# del coordenadas[0] # TypeError
La variable, sin embargo, sí puede reasignarse para que apunte a otra tupla:
Esta diferencia es importante:
- mutar significa cambiar el objeto existente y una tupla no lo permite;
- reasignar significa asociar el nombre a otro objeto y sí está permitido;
- crear una nueva tupla permite obtener un resultado distinto conservando la tupla original.
4.2. Concatenar y repetir¶
Los operadores + y * no modifican una tupla. Crean otra:
inicio = (1, 2)
final = (3, 4)
completa = inicio + final
repetida = ("Python", "es") * 2
print(completa) # (1, 2, 3, 4)
print(repetida) # ('Python', 'es', 'Python', 'es')
print(inicio) # (1, 2), la original no cambia
Para añadir un único elemento, hay que construir una tupla unitaria:
Olvidar la coma en (13,) provoca un intento de sumar una tupla y un entero,
que produce TypeError.
4.3. Tuplas que contienen objetos mutables¶
La tupla no puede cambiar qué objeto ocupa cada posición, pero un objeto mutable que esté dentro sí puede modificarse:
configuracion = ("desarrollo", ["Python", "pytest"])
# configuracion[1] = ["Python", "pytest", "ruff"] # TypeError
configuracion[1].append("ruff")
print(configuracion)
# ('desarrollo', ['Python', 'pytest', 'ruff'])
La referencia de la posición 1 sigue apuntando a la misma lista; lo que ha
cambiado es el contenido de esa lista. Si se necesita una inmutabilidad
profunda, los elementos internos también deben ser inmutables, por ejemplo,
otra tupla en lugar de una lista.
4.4. Comparar y ordenar tuplas¶
Las tuplas se comparan elemento a elemento. La igualdad exige que tengan los mismos elementos en el mismo orden:
Los operadores <, <=, > y >= aplican una comparación lexicográfica:
primero comparan el primer elemento; solo si coincide pasan al siguiente.
print((1, 2) < (1, 3)) # True
print((1, 2) < (1, 2, 3)) # True
print(("Ana", 30) < ("Luis", 20)) # True
Esto permite ordenar registros por varios campos cuando los tipos se pueden comparar:
alumnos = [(2, "Luis"), (1, "Ana"), (3, "Marta")]
ordenados = sorted(alumnos)
print(ordenados) # [(1, 'Ana'), (2, 'Luis'), (3, 'Marta')]
sorted() devuelve una lista nueva. Si se necesita conservar el tipo
tupla, se puede convertir el resultado:
5. Desempaquetado de tuplas¶
5.1. Desempaquetado básico¶
El desempaquetado asigna cada elemento de una secuencia a una variable. El número de variables debe coincidir con el número de elementos:
Si faltan o sobran variables, Python produce ValueError:
# primero, segundo = (1, 2, 3) # demasiados valores
# primero, segundo, tercero = (1, 2) # faltan valores
El desempaquetado también permite intercambiar dos variables sin una variable temporal:
En la parte derecha, alto, ancho se empaqueta temporalmente en una tupla y,
después, se desempaqueta en la parte izquierda.
5.2. Desempaquetado extendido con *¶
El operador * permite recoger varios elementos en una única variable. Esa
variable recibe una lista, no una tupla:
También puede aparecer en el centro. Solo se permite una variable con * en
cada asignación:
primero, *intermedios, ultimo = numeros
print(primero) # 1
print(intermedios) # [2, 3, 4]
print(ultimo) # 5
El nombre _ se utiliza por convención cuando un elemento no se va a usar:
5.3. Desempaquetado en bucles y retornos¶
Es frecuente recorrer una colección de tuplas y desempaquetar cada elemento:
dict.items() proporciona parejas clave-valor que también se pueden
desempaquetar:
persona = {"nombre": "Ana", "edad": 20}
for clave, valor in persona.items():
print(f"{clave}: {valor}")
zip() combina varios iterables y produce parejas o grupos de elementos que se
pueden desempaquetar. Por defecto termina cuando se agota el iterable más corto:
nombres = ("Ana", "Luis", "Marta")
edades = (20, 21, 19)
for nombre, edad in zip(nombres, edades):
print(f"{nombre}: {edad} años")
Una función puede devolver varios valores separados por comas. En realidad, Python los empaqueta en una tupla:
def dividir(dividendo, divisor):
return dividendo // divisor, dividendo % divisor
cociente, resto = dividir(10, 3)
print(cociente) # 3
print(resto) # 1
Este patrón es útil cuando el resultado tiene un número pequeño y estable de
partes con significado claro. Si el registro crece o sus campos necesitan
nombres más expresivos, puede ser mejor un diccionario, un namedtuple o una
clase.
6. Métodos y funciones útiles¶
Las tuplas tienen pocos métodos porque no pueden modificarse. Esta limitación
es intencionada: no existen append(), remove() o sort() para una tupla.
6.1. count() e index()¶
count(elemento) cuenta las apariciones de un valor. index(elemento) devuelve
la posición de su primera aparición:
index() admite opcionalmente una posición inicial y otra final. Si no
encuentra el elemento, produce ValueError:
print(notas.index(5, 2)) # 2, busca desde el índice 2
if 4 in notas:
print(notas.index(4))
else:
print("La nota 4 no aparece")
Usa in cuando solo necesites saber si existe un elemento y index() cuando
necesites además su posición.
| Método | Para qué sirve | Resultado |
|---|---|---|
count(elemento) |
Cuenta las apariciones del elemento. | Un entero, también 0. |
index(elemento[, inicio[, fin]]) |
Busca la primera posición en un intervalo. | Un índice o ValueError. |
6.2. Funciones incorporadas¶
Muchas funciones que trabajan con listas también trabajan con tuplas porque aceptan objetos iterables:
notas = (5, 7, 8, 10)
print(len(notas)) # 4
print(min(notas)) # 5
print(max(notas)) # 10
print(sum(notas)) # 30
print(sum(notas) / len(notas)) # 7.5
print(all(nota >= 5 for nota in notas)) # True
print(any(nota == 10 for nota in notas)) # True
min(), max() y sum() necesitan datos compatibles y min() o max() no
se pueden aplicar a una tupla vacía sin tratar antes ese caso:
tuple() también sirve para construir una tupla a partir de un iterable. No es
un método de una tupla, sino el constructor de la clase.
7. Tuplas como claves y registros con nombre¶
7.1. Hashabilidad y claves compuestas¶
Un objeto hashable tiene un valor de hash estable durante su vida y puede usarse como clave de un diccionario o como elemento de un conjunto. Las tuplas son hashables solo cuando todos sus elementos también lo son.
Por eso una tupla de números o cadenas puede representar una clave compuesta:
tablero = {
(0, 0): "origen",
(0, 1): "pieza blanca",
(1, 0): "pieza negra",
}
print(tablero[(0, 1)]) # pieza blanca
colores_rgb = {
(255, 0, 0): "rojo",
(0, 255, 0): "verde",
(0, 0, 255): "azul",
}
Una lista no puede ser clave porque es mutable. Tampoco puede usarse como clave una tupla que contenga una lista:
clave_valida = ("DAW", 3)
clave_no_valida = ("DAW", [3])
tablero[clave_valida] = "casilla"
# tablero[clave_no_valida] = "casilla" # TypeError: unhashable type: 'list'
La inmutabilidad de la tupla exterior no basta: hay que comprobar todos los niveles de la estructura.
7.2. namedtuple para registros sencillos¶
Una tupla normal es eficiente, pero persona[0] no indica qué representa ese
valor. collections.namedtuple crea una clase de tupla con campos nombrados:
from collections import namedtuple
Persona = namedtuple("Persona", ["nombre", "edad", "ciudad"])
ana = Persona("Ana", 20, "Cádiz")
print(ana.nombre) # Ana
print(ana.edad) # 20
print(ana[2]) # Cádiz
Persona sigue siendo una tupla: conserva el orden, se puede desempaquetar y
no permite asignar un nuevo valor a un campo:
El método _replace() crea otra instancia con un cambio, y _asdict() ofrece
una representación en forma de diccionario:
actualizada = ana._replace(edad=21)
print(actualizada) # Persona(nombre='Ana', edad=21, ciudad='Cádiz')
print(ana._asdict()) # {'nombre': 'Ana', 'edad': 20, 'ciudad': 'Cádiz'}
Para registros más complejos, con comportamiento propio o datos que cambian,
conviene valorar un diccionario, dataclass o una clase convencional. La
tupla con nombre es adecuada cuando hay pocos campos fijos y se quiere
mantener la semántica de secuencia.
8. Aplicación práctica: coordenadas y resultados calculados¶
Las coordenadas son un ejemplo natural de tupla: el par (x, y) representa un
valor completo y no conviene modificar una coordenada por accidente.
from math import sqrt
def distancia_al_origen(punto):
"""Devuelve la distancia de (x, y) al origen."""
x, y = punto
return sqrt(x**2 + y**2)
puntos = ((0, 0), (3, 4), (5, 12))
for punto in puntos:
distancia = distancia_al_origen(punto)
print(f"{punto}: {distancia}")
El desempaquetado hace explícito qué significa cada posición. Además, las tuplas pueden utilizarse para indexar resultados por coordenada:
temperaturas = {
(2026, 11, 17): 18.5,
(2026, 11, 18): 19.0,
}
fecha_consulta = (2026, 11, 17)
print(temperaturas[fecha_consulta]) # 18.5
Otro caso habitual es devolver varias medidas desde una función:
def resumen(numeros):
if not numeros:
return None
return min(numeros), max(numeros), sum(numeros) / len(numeros)
minimo, maximo, media = resumen((4, 7, 10, 9))
print(f"Mínimo: {minimo}; máximo: {maximo}; media: {media}")
En los dos casos, la tupla comunica que el número y el orden de los datos forman parte del contrato. Si el resultado necesitara campos opcionales, etiquetas dinámicas o modificaciones frecuentes, habría que reconsiderar la estructura.
9. Buenas prácticas¶
Para trabajar con tuplas con criterio, conviene aplicar estas recomendaciones:
- Elige por significado, no solo por rendimiento: usa una tupla cuando el conjunto de valores deba permanecer estable y una lista cuando deba cambiar.
- Escribe la coma en las tuplas unitarias:
(valor,)evita confundir una tupla con una expresión entre paréntesis. - Usa paréntesis cuando mejoren la lectura: aunque la coma sea suficiente,
(x, y)comunica con claridad que se trata de una tupla. - Desempaqueta con nombres descriptivos:
año, mes, día = fechaexplica mejor el dato quefecha[0],fecha[1]yfecha[2]. - Protege las operaciones que pueden fallar: comprueba
if tuplaantes de acceder a[-1], y usainantes deindex()cuando el valor pueda faltar. - Recuerda qué devuelve cada función:
sorted(tupla)devuelve una lista y el desempaquetado extendido guarda el resto en una lista. - Comprueba la hashabilidad completa: una tupla solo puede ser clave si no contiene listas, diccionarios ni otros objetos mutables no hashables.
- Usa
namedtuplecon moderación: es útil para registros pequeños y estables; una clase o undataclassexpresa mejor un modelo complejo. - Consulta la documentación: no es necesario memorizar todos los métodos; sí hay que entender el valor devuelto y las excepciones posibles.
10. Errores frecuentes¶
| Error frecuente | Por qué ocurre | Cómo evitarlo |
|---|---|---|
Escribir (5) pensando que es una tupla de un elemento. |
Los paréntesis agrupan la expresión; la coma es la que crea la tupla. | Usar (5,) y comprobar el resultado con type(). |
Intentar tupla[0] = valor. |
Las tuplas son inmutables y no admiten asignación por índice. | Crear una tupla nueva o convertirla temporalmente en lista. |
| Confundir reasignar con mutar. | nombre = otra_tupla cambia la referencia de la variable, no el objeto anterior. |
Distinguir la variable del objeto al razonar sobre el código. |
| Olvidar la coma al añadir un elemento. | tupla + (valor) intenta sumar una tupla y un valor simple. |
Escribir tupla + (valor,). |
| Desempaquetar con un número incorrecto de variables. | La asignación básica exige una variable por elemento. | Igualar las cantidades o usar una única variable con *. |
Pensar que *resto produce una tupla. |
El desempaquetado extendido recoge los elementos en una lista. | Consultar type(resto) o convertir con tuple(resto) si hace falta. |
Usar index() sin comprobar la pertenencia. |
index() lanza ValueError si no encuentra el valor. |
Usar in antes o controlar la excepción. |
Acceder a tupla[-1] cuando está vacía. |
Una tupla vacía no tiene posiciones. | Comprobar if tupla antes del acceso. |
| Ordenar una tupla y esperar otra tupla. | sorted() devuelve una lista nueva. |
Aplicar tuple(sorted(tupla)) si el tipo debe conservarse. |
| Usar una tupla con una lista como clave. | La lista interna es mutable y hace que la tupla no sea hashable. | Sustituir la lista por una tupla u otra estructura inmutable. |
| Suponer que una tupla hace inmutables sus objetos internos. | La inmutabilidad exterior no se propaga automáticamente. | Usar elementos internos inmutables cuando se necesite inmutabilidad profunda. |
11. Resumen¶
En este tema has aprendido que:
- una tupla es una secuencia ordenada, indexada e inmutable que admite duplicados y elementos de distintos tipos;
- la coma crea la tupla, los paréntesis mejoran la claridad y una tupla unitaria
necesita
(elemento,); tuple(iterable)construye una tupla a partir de otro iterable;- los índices, las rebanadas,
len(),in,foryenumerate()permiten consultar y recorrer sus elementos; +y*crean nuevas tuplas, pero no modifican las originales;- una tupla puede contener objetos mutables, por lo que su inmutabilidad no es necesariamente profunda;
count()eindex()son sus métodos principales, y las funcionesmin(),max(),sum(),all()yany()permiten procesar sus valores;- el desempaquetado mejora la legibilidad en asignaciones, bucles y retornos de funciones;
- una tupla solo es hashable si todos sus elementos lo son, y por eso puede servir como clave compuesta de un diccionario;
namedtupleaporta nombres a registros pequeños sin perder la inmutabilidad de la tupla.
Idea clave
Una tupla no es una lista limitada: es una forma de declarar que varios valores ordenados forman un conjunto estable. Elegirla cuando el dato no debe cambiar, desempaquetarlo con nombres claros y proteger los casos vacíos permite escribir programas más expresivos y seguros, en línea con el RA 6 y, especialmente, el CE 6.e.
12. Para seguir practicando¶
- Resuelve la Práctica 3.1: Listas y tuplas y justifica en cada ejercicio si los datos deben representarse con una lista o con una tupla.
- Reescribe el ejercicio de vectores de la práctica usando tuplas para las coordenadas y desempaquetado para calcular el producto escalar.
- Crea una función que reciba una tupla de notas y devuelva mínimo, máximo y media; prueba también la tupla vacía.
- Representa un tablero mediante un diccionario cuyas claves sean coordenadas
(fila, columna)y explica por qué una lista no puede ser clave. - Experimenta con la presentación PR-U3.2 · Tuplas
y comprueba en el intérprete los ejemplos de desempaquetado y
namedtuple.
Bibliografía y fuentes¶
- Tipos de secuencia:
list,tupleyrange, documentación oficial de Python. - Tuplas y secuencias, tutorial oficial de Python.
- Clase
tuple, documentación oficial de Python. collections.namedtuple, documentación oficial de Python.- Glosario oficial: objeto hashable.
- Python para todos.
- Aprende con Alf.
- Página de Juan José Lozano Gómez sobre Python.
Presentación¶
Puedes repasar las ideas principales en la presentación de la unidad: