En Python, una tupla es una colección ordenada e inmutable de elementos, lo que significa que:
Mantiene el orden en el que se definen sus elementos.
No se puede modificar (ni añadir, ni eliminar, ni cambiar elementos) una vez creada.
Puede contener datos de diferentes tipos (números, cadenas, listas, otras tuplas, etc.).
Se define usando paréntesis () o sin ellos, separando los elementos por comas.
Ordenada → los elementos tienen posiciones (índices).
Inmutable → no se puede cambiar después de crearla.
Indexable y recorrible → se puede acceder a sus elementos con índices o con bucles.
Admite duplicados → puede tener valores repetidos.
🧩Ejemplo 1: Tupla simple de números
numeros = (10, 20, 30, 40)
print(numeros)
print("Primer elemento:", numeros[0])
📤 Salida:
(10, 20, 30, 40)
Primer elemento: 10
🧩Ejemplo 2: Tupla con tipos diferentes
persona = ("Ana", 25, 1.68, True)
print(persona)
📤 Salida:
('Ana', 25, 1.68, True)
🧩Ejemplo 3: Desempaquetado de tupla
coordenadas = (5, 8)
x, y = coordenadas
print("x =", x)
print("y =", y)
📤 Salida:
x = 5
y = 8
🧩Ejemplo 4: Tupla anidada (dentro de otra)
datos = ("Juan", (7, 8, 9), "Aprobado")
print(datos)
print("Notas:", datos[1])
print("Primera nota:", datos[1][0])
📤 Salida:
('Juan', (7, 8, 9), 'Aprobado')
Notas: (7, 8, 9)
Primera nota: 7
Enunciado:
Enunciado:
Enunciado:
Enunciado:
Enunciado:
Enunciado:
Importe venta #1:
Importe venta #2:
...
Importe venta #6:
Debes usar una f-String, que permite escribir un texto insertando valores de variables que se ponen entre llaves.
Linea de python desordenada
range i in ventas = input(f"Importe venta # {i+1 tuple(float(}: ")) for (6))
Enunciado:
Ayudas:
enumerate(tupla) devuelve pares (índice, carácter) para recorrer la tupla con sus posiciones.
hay que crear una lista de posiciones donde aparece el caracter: posiciones = tuple( [i for i, c in enumerate(tupla) if c == caracter]), donde caracter es el elemento a buscar
Ejemplo de ejecución:
Entrada del usuario:
Introduce una palabra: programacion
Introduce el carácter a buscar: a
Salida:
Tupla de caracteres: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'a', 'c', 'i', 'o', 'n')
El carácter 'a' aparece en las posiciones: (5, 7)
Enunciado:
utiliza las funciones sorted, min, max
Ejemplo de ejecución:
Entrada del usuario:
Precio #1: 12.5
Precio #2: 8.99
Precio #3: 15
Precio #4: 20.5
Precio #5: 9.75
Salida:
Tupla original: (12.5, 8.99, 15.0, 20.5, 9.75)
Ordenados: (8.99, 9.75, 12.5, 15.0, 20.5)
Más barato: 8.99
Más caro: 20.5
Enunciado:
La salida se da con tres decimales: variable:.3f
Calcula la distancia del punto al origen (0, 0) usando el Teorema de Pitágoras:
Ejemplo de ejecución:
Entrada del usuario:
x: 3
y: 4
Salida:
Punto: (3.0, 4.0)
x: 3.0 y: 4.0
Distancia al origen: 5.000
Enunciado:
En una misma línea crea la tupla solicitando los valores
Usa [:3] para obtener en una tupla los tres primeros valores
Ejemplo de ejecución:
Entrada del usuario:
Importe venta #1: 150
Importe venta #2: 200.5
Importe venta #3: 99.99
Importe venta #4: 180
Importe venta #5: 300
Importe venta #6: 250.5
Salida:
Ventas: (150.0, 200.5, 99.99, 180.0, 300.0, 250.5)
Top 3: (300.0, 250.5, 200.5)
Enunciado:
Crea la tupla que llamaremos nums usando tuple; f-string y range . Todo en una única línea
Se debe crear una tupla pares_menores_50 en una sola línea haciendo un recorrido por la tupla solicitada usando for .... in nums if condiciones
Ejemplo de ejecución:
Entrada del usuario:
Número #1: 12
Número #2: 7
Número #3: 45
Número #4: 80
Número #5: 22
Número #6: 49
Número #7: 16
Número #8: 55
Número #9: 2
Número #10: 99
Salida:
Números: (12, 7, 45, 80, 22, 49, 16, 55, 2, 99)
Pares < 50: (12, 22, 16, 2)
Se crea una lista vacía donde se almacenarán temporalmente los contactos.
Se usa una lista porque las tuplas son inmutables y no permiten agregar elementos directamente.
for i in range(3):
→ se repite 3 veces para ingresar 3 contactos.
input(f"Nombre contacto #{i+1}: ")
→ solicita el nombre.
El f indica una f-string que muestra dinámicamente el número de contacto.
.strip()
→ elimina espacios en blanco antes y después del texto (por si el usuario los escribe por error).
telefono = input(...)
→ pide el número de teléfono asociado.
contactos.append((nombre, telefono))
→ agrega una tupla (nombre, teléfono) a la lista.
---------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------
print("Agenda:", agenda)
Muestra toda la agenda por consola.
---------------------------------------------------------------------------------------------------------------------
objetivo = input("Buscar teléfono de (nombre): ").strip()
Pide el nombre a buscar.
.strip() quita espacios accidentales.
---------------------------------------------------------------------------------------------------------------------
encontrados = tuple(tel for nom, tel in agenda if nom.lower() == objetivo.lower())
for nom, tel in agenda
→ recorre cada tupla dentro de agenda, separando nombre y teléfono.
if nom.lower() == objetivo.lower()
→ compara los nombres en minúsculas para ignorar diferencias de mayúsculas/minúsculas.
(Ejemplo: “Ana” == “ana” será verdadero).
tuple(...)
→ crea una tupla con los teléfonos de los contactos cuyo nombre coincide.
---------------------------------------------------------------------------------------------------------------------
if encontrados:
print("Teléfonos encontrados:", encontrados)
else:
print("No se encontró ese nombre.")
En Python, una tupla vacía () se evalúa como False, mientras que una con elementos es True.
Si hay coincidencias → imprime los teléfonos encontrados.
Si no hay → muestra un mensaje de error.
Ejemplo de ejecución:
Entrada del usuario:
Nombre contacto #1: Ana
Teléfono contacto #1: 111-222
Nombre contacto #2: Luis
Teléfono contacto #2: 333-444
Nombre contacto #3: Marta
Teléfono contacto #3: 555-666
Agenda: (('Ana', '111-222'), ('Luis', '333-444'), ('Marta', '555-666'))
Buscar teléfono de (nombre): ana
Salida:
Teléfonos encontrados: ('111-222',)
Enunciado:
Crea una lista vacía llamada carrito para ir guardando los productos
Utiliza un bucle for para ir añadiendo los productos al carrito
Convierte la lista carrito a tupla inmutable
Usa una comprensión para extraer solo las cantidades cant de cada producto.
total_unidades = sum(cant for _, _, cant in carrito)
_ indica que se ignoran los otros campos (nombre, precio).
Formatea el importe total con 2 decimales (.2f).
Ejemplo de ejecución:
Entrada del usuario:
¿Cuántos productos vas a añadir? 3
Producto #1 (nombre): Manzanas
Precio (€): 1.2
Cantidad: 4
Producto #2 (nombre): Pan
Precio (€): 1.5
Cantidad: 2
Producto #3 (nombre): Leche
Precio (€): 1.1
Cantidad: 3
Salida:
Carrito: (('Manzanas', 1.2, 4), ('Pan', 1.5, 2), ('Leche', 1.1, 3))
Unidades totales: 9
Importe total: 11.10 €
Enunciado:
Crea una lista vacía llamada alumnos para almacenar temporalmente los alumnos y sus notas.
En un bucle pide el nombre del alumno mostrando el número de registro (uso de f-string). Elimina con strip los espacios antes y después del texto. Convierte la nota en número decimal. Añade una tupla con el nombre y la nota a la lista (append)
Convierte la lista mutable alumnos en una tupla inmutable.
crea una tupla llamada ranking que ordene los elementos de la tupla (sorted), usar key=lambda t: t[1] , que le indicará a sorted que use la nota (segundo elemento) de cada tupla como criterio de orden (t es la tupla con los dos elementos, t[1] es la nota) - ver ejemplo de código más abajo.
Para invertir el orden de mayor a menor se ha de usar reverse=true en el comando de creación de la tupla anterior.
Mostrar los resultados. La lista completa y los tres primeros elementos, para lo que se debe usar [:3]
estudiantes = [{'nombre': 'Ana', 'edad': 25}, {'nombre': 'Juan', 'edad': 30}]
ordenados_por_edad = sorted(estudiantes, key=lambda estudiante: estudiante['edad'])
print(ordenados_por_edad)
# Salida: [{'nombre': 'Ana', 'edad': 25}, {'nombre': 'Juan', 'edad': 30}]
key: (Opcional) Una función que toma un solo argumento y se usa para especificar un criterio de ordenación.
Ejemplo de ejecución:
Entrada del usuario:
Número de alumnos: 5
Alumno #1 (nombre): Ana
Nota: 8.5
Alumno #2 (nombre): Luis
Nota: 9.2
Alumno #3 (nombre): Marta
Nota: 7.8
Alumno #4 (nombre): Pedro
Nota: 9.8
Alumno #5 (nombre): Carla
Nota: 6.5
Salida:
Ranking (desc): (('Pedro', 9.8), ('Luis', 9.2), ('Ana', 8.5), ('Marta', 7.8), ('Carla', 6.5))
Top 3: (('Pedro', 9.8), ('Luis', 9.2), ('Ana', 8.5))
Enunciado:
Crea una lista vacía donde se guardarán las tuplas (nombre, stock).
Repite con un for tantas veces como número de artículos se hayan introducido:
solicta número de artículos eliminando espacios extras (strip)
solicita número de unidades en stock
añade una tupla con el par anterior a la lista (lista.append....)
Convierte la lista en una tupla de tuplas (no modificable):
Muestra el inventario completo
Recorre inventario y selecciona solo los artículos cuyo segundo valor sea menor que 5 (...tuple(.... for ... in inventario if ....[1]<5))
Imprime los artículos con stock bajos
Genera una nueva tupla con reposición: Se usa una comprensión de tupla con una expresión condicional dentro:
Si el stock es menor que 5, se añade 10 unidades → (nom, stk + 10).
Si no, se deja igual → (nom, stk).
Imprime el inventario actualizado
Ejemplo de ejecución:
Entrada del usuario:
Número de artículos: 3
Artículo #1 (nombre): Lapicero
Stock: 3
Artículo #2 (nombre): Cuaderno
Stock: 12
Artículo #3 (nombre): Borrador
Stock: 2
Salida:
Inventario: (('Lapicero', 3), ('Cuaderno', 12), ('Borrador', 2))
Stock bajo: (('Lapicero', 3), ('Borrador', 2))
Inventario tras reposición: (('Lapicero', 13), ('Cuaderno', 12), ('Borrador', 12))
Enunciado:
Ejemplo de ejecución:
Entrada del usuario:
Asignatura #1: Matemáticas
Asignatura #2: Inglés
Asignatura #3: Historia
Asignatura #4: Física
Asignatura #5: Matemáticas
Salida:
Horario: ('Matemáticas', 'Inglés', 'Historia', 'Física', 'Matemáticas')
¡Atención! Hay asignaturas duplicadas: {'Matemáticas'}
Entrada del usuario:
Consulta índice de asignatura: Historia
Salida:
Índice: 2