En la lección anterior, nuestras funciones recibían datos de la forma más simple: un valor por posición para cada parámetro. Suficiente para empezar, pero corto para Papyrus: el cálculo del precio final depende de si el cliente es socio o no, y no queremos dos funciones casi idénticas (precio_normal() y precio_socio()) cuando la lógica es la misma con un matiz. Python ofrece un sistema de argumentos extraordinariamente flexible: argumentos por posición y por nombre, valores por defecto, cantidades variables con *args y **kwargs, y desempaquetado en la llamada. En esta lección lo recorremos entero, construimos la función estrella de la tienda — precio_final(base, socio=False, iva=IVA_LIBROS) — y saldamos la deuda que arrastramos desde el módulo 2: entender de verdad cómo funciona zip().

1. Argumentos posicionales y argumentos con nombre (keyword)
2. Valores por defecto: precio_final() para socios y no socios
3. La trampa de los valores por defecto mutables
4. *args: cantidad variable de posicionales
5. **kwargs: cantidad variable de argumentos con nombre
6. El orden de los parámetros en la definición
7. Desempaquetado con * y ** en la llamada
8. Devolver varios valores (tuplas, presentación breve)
9. Deuda saldada: zip() a fondo

Hasta ahora hemos emparejado argumentos con parámetros por posición: el primero con el primero, el segundo con el segundo. Python también permite emparejarlos por nombre (argumentos keyword):

Reglas y criterio:

• En una llamada mixta, los posicionales van siempre antes que los keyword.
• Los argumentos con nombre hacen la llamada autoexplicativa: precio_final(12.50, True) obliga a mirar la definición para saber qué es ese True; precio_final(12.50, socio=True) se lee sola. Ya usaste esta idea en el módulo 2 con enumerate(catalogo, start=1) y en el módulo 1 con print(..., sep=", ", end=""): start, sep y end son argumentos keyword.
• Regla práctica: por posición los datos obvios y obligatorios; por nombre las opciones y banderas.

Un parámetro puede declarar un valor que se usa si la llamada no lo proporciona. Es el mecanismo perfecto para la función de precios de Papyrus:

Desglose:

• base no tiene valor por defecto: es obligatorio. Olvidarlo produce TypeError: precio_final() missing 1 required positional argument: 'base'.
• socio=False y iva=IVA_LIBROS son opcionales: la llamada corta precio_final(12.50) cubre el caso más frecuente (cliente no socio, IVA de libros) y los casos especiales se piden explícitamente.
• El orden de operaciones respeta la convención de la tienda desde el módulo 1: primero el descuento, después el IVA. Los precios de socio del catálogo salen clavados: 12.35, 9.83 y 15.71 € para La Odisea, Hamlet y El Quijote.

Un matiz que sorprende: los valores por defecto se evalúan una sola vez, cuando Python lee el def. iva=IVA_LIBROS toma el valor que IVA_LIBROS tenga en ese momento (0.04) y lo congela; si más tarde reasignaras la constante, el defecto no cambiaría. Con constantes e inmutables esto es inofensivo... pero conduce directamente a la trampa más famosa de Python.

Como el defecto se evalúa una única vez, usar un objeto mutable (una lista, por ejemplo) como valor por defecto significa que todas las llamadas comparten el mismo objeto:

El segundo pedido "hereda" el primero porque la lista por defecto es la misma en ambas llamadas: se creó al leer el def y ahí sigue, acumulando. El idioma correcto usa None como centinela:

A veces no sabes cuántos valores llegarán. Un parámetro con * delante recoge todos los argumentos posicionales sobrantes:

• Dentro de la función, importes es una tupla con cero o más valores, y se recorre con for como cualquier secuencia.
• El nombre args es pura convención (aquí importes es más expresivo); lo que importa es el *.
• Ya conocías esto sin saberlo: print("a", "b", "c") acepta cualquier cantidad de argumentos gracias a este mecanismo.

El doble asterisco recoge los argumentos keyword sobrantes en un diccionario (pares nombre-valor; los diccionarios se estudian a fondo en el módulo 4, aquí solo necesitas la idea):

Cada libro de Papyrus puede tener datos distintos (editorial, edición, idioma...) sin cambiar la firma de la función. datos.items() recorre los pares nombre-valor; de nuevo, el nombre kwargs (keyword arguments) es solo convención.

Cuando combines varias categorías, el orden en el def es fijo:

Saltarse el orden (def f(socio=False, base)) es SyntaxError: parameter without a default follows parameter with a default. En la práctica, la mayoría de tus funciones usarán solo las dos primeras categorías — *args/**kwargs son para casos genuinamente variables, no un comodín para no pensar la firma.

Los asteriscos también funcionan en sentido inverso: reparten una secuencia o un diccionario entre los parámetros de la llamada:

• *secuencia en una llamada desempaqueta sus elementos como argumentos posicionales.
• **diccionario desempaqueta pares nombre-valor como argumentos keyword (las claves deben coincidir con nombres de parámetros).
• Mnemotecnia: en el def, los asteriscos empaquetan (muchos argumentos → una variable); en la llamada, desempaquetan (una variable → muchos argumentos).

return puede entregar varios valores separados por comas; técnicamente devuelve una tupla (secuencia inmutable que veremos a fondo en el módulo 4), y lo habitual es desempaquetarla al recibirla — el mismo mecanismo de la asignación múltiple del módulo 1:

Con esto nos basta por ahora; las tuplas tendrán su propia lección (04-02).

En el módulo 2 usamos zip() de pasada; ha llegado el momento de entenderla. Papyrus guarda sus datos en tres listas paralelas — el elemento i de cada una describe el mismo libro:

zip() recibe varias secuencias y va produciendo tuplas con los elementos emparejados por posición: primero ("La Odisea", 12.50, 4), luego ("Hamlet", 9.95, 6), etc. Es como la cremallera (zipper) de una chaqueta: une un diente de cada lado en cada paso.

Compárala con el patrón de índices que usábamos hasta ahora:

Detalles importantes:

• zip() es perezosa: no construye una lista de tuplas en memoria, las va entregando a medida que el for las pide. Si quieres verlas todas de golpe: list(zip(catalogo, precios)) → [('La Odisea', 12.5), ('Hamlet', 9.95), ('El Quijote', 15.9)]. Consecuencia práctica: un zip() ya recorrido queda agotado; crea uno nuevo para recorrerlo otra vez.
• Que se detenga en la secuencia más corta es cómodo pero peligroso: si a catalogo le añades "Fausto" y olvidas añadir su precio, el for simplemente ignorará el libro sin avisar. Desde Python 3.10, zip(catalogo, precios, strict=True) lanza un error si las longitudes no coinciden — fíjate: strict es un argumento keyword, como los que acabas de aprender.
• zip() también combina de maravilla con las funciones de esta lección:

Estas listas paralelas empiezan a ser frágiles (tres listas que mantener sincronizadas a mano); en el módulo 4 conocerás estructuras que agrupan los datos de cada libro en un solo lugar. Hasta entonces, zip() es el pegamento oficial de Papyrus.

• Posicional después de keyword en la llamada (precio_final(socio=True, 12.50)): SyntaxError. Primero las posiciones, luego los nombres.
• Repetir un argumento (precio_final(12.50, base=12.50)): TypeError: got multiple values for argument 'base'. El valor llegó por posición y por nombre a la vez.
• [] o {} como valor por defecto: la trampa estrella. Usa None y crea el objeto dentro. Los linters (como los que sugiere VS Code) lo marcan; hazles caso.
• Pasar banderas por posición (precio_final(12.50, True)): funciona, pero dentro de un mes nadie recordará qué era True. Escribe socio=True.
• Confundir * en el def con * en la llamada: en la definición empaqueta; en la llamada desempaqueta. Si dudas, pregúntate de qué lado del paréntesis estás.
• Abusar de *args/**kwargs: una firma explícita documenta y valida sola. Reserva los asteriscos para funciones genuinamente variádicas (como total_compra).
• Olvidar que zip() calla con longitudes distintas: en datos que deben ir emparejados sí o sí, usa strict=True (Python ≥ 3.10).
• Consejo: al diseñar una firma, ordena de más a menos importante y pon defectos a todo lo que tenga un valor "normal". La llamada típica debería ser la más corta.

Escribe ticket(cliente, *importes, socio=False) que imprima una línea Ticket de <cliente>, después cada importe pasado por precio_final(importe, socio=socio) (uno por línea, formato :>6.2f), y al final Total: X.XX € con la suma de los precios finales. Pruébala con ticket("Luis", 12.50, 9.95, 15.90, socio=True) — el total debe ser 37.89 € — y con ticket("Marta", 21.00).

Ana escribió esta función para apuntar reposiciones pendientes y algo va mal:

Ejecuta apuntar_reposicion("Fausto") y luego apuntar_reposicion("Hamlet"), observa el problema, explica por qué ocurre y corrígela con el patrón del centinela None.

Con catalogo, precios y stocks (más "Fausto", 21.00, 0 añadidos: usa catalogo + ["Fausto"], etc., para no modificar las originales), imprime con un solo bucle sobre zip() una tabla título | precio normal | precio socio | estado, donde el estado sea agotado si el stock es 0 y disponible en caso contrario. Usa precio_final() para ambos precios.

Ejercicio 1:

Como socio va después de *importes, solo puede pasarse por nombre — Python jamás lo confundirá con un importe más. Es un truco de diseño muy usado.

Ejercicio 2: La segunda llamada devuelve ['Fausto', 'Hamlet']: ambas comparten la misma lista por defecto, creada una sola vez al leer el def. Corrección:

Ahora cada llamada sin lista recibe una lista recién creada, y quien tenga ya una lista propia puede pasarla: apuntar_reposicion("Hamlet", pendientes=mi_lista).

Ejercicio 3:

Cada variable del for recibe su elemento emparejado por zip(); el ternario del módulo 2 resuelve el estado en una línea. Salida: Fausto aparece con 21.84 € / 20.75 € y agotado.

Las funciones de Papyrus ya hablan un lenguaje rico: argumentos posicionales para lo esencial, keyword para las opciones (socio=True), valores por defecto para el caso común — esquivando la trampa de los mutables —, *args/**kwargs para lo variable y desempaquetado con */** en las llamadas. Además, zip() ha dejado de ser magia: es la cremallera que recorre en paralelo las listas de la tienda, y precio_final(base, socio=False, iva=IVA_LIBROS) queda establecida como la función oficial de precios. En la próxima lección conoceremos una forma abreviada de escribir funciones diminutas y anónimas — las lambdas — y las pondremos a trabajar donde de verdad brillan: como criterio de sorted(), min() y max() para, por fin, ordenar el catálogo de Papyrus por precio.