Funciones avanzadas} dek="En el Libro 1 aprendiste a definir y llamar funciones. Ahora aprenderás a tratarlas como cualquier otro valor: guardarlas en variables, pasarlas como argumentos y construir con ellas." />

En el Libro 1, las funciones eran bloques de código con nombre que llamabas cuando los necesitabas. Eso ya es poderoso. Pero Python va más lejos: las funciones son objetos de primera clase, lo que significa que puedes hacer con ellas exactamente lo mismo que con cualquier otro valor — guardarlas en variables, meterlas en listas, pasarlas como argumentos a otras funciones, devolverlas desde funciones.

Ese cambio de perspectiva — de "las funciones son comandos" a "las funciones son valores" — abre una forma completamente nueva de programar.

Funciones como valores

Empieza por lo más simple: una función es un valor. Puedes asignarla a una variable y llamarla a través de ese nuevo nombre:

`} /> {`Hola, Ana! `}

Y si puedes guardarlas en variables, también puedes meterlas en listas o diccionarios y llamarlas dinámicamente:

13 Si una función puede ser un valor, también puede ser un argumento. Una función que recibe otra función como parámetro se llama función de orden superior. sorted, map y filter son ejemplos que ya vienen en Python — los veremos más adelante en este módulo.

Funciones lambda

Una lambda es una función anónima de una sola expresión. Útil cuando necesitas una función pequeña en el momento — sin la ceremonia de un def completo:

La sintaxis completa: lambda parámetros: expresión. El resultado de la expresión es el valor devuelto.

{`7 impar`} La regla práctica: usa lambda solo cuando la función es tan sencilla que ponerle nombre haría el código más difícil de leer, no más fácil. El caso más común es pasarla como argumento a otra función (sorted, map…) sin necesidad de reutilizarla. Si la vas a usar más de una vez, o si tiene más de una línea de lógica, usa def.

El uso más común: el parámetro `key` de `sorted`

sorted acepta un parámetro key: una función que transforma cada elemento antes de compararlo. Combinado con lambda, es muy expresivo:

{`['Lu', 'Ana', 'Sofía', 'Alejandro'] Ana 25 Pedro 28 Luis 30`}

*args: número variable de argumentos

A veces no sabes de antemano cuántos argumentos recibirá tu función. *args permite capturarlos todos en una tupla:

total = 0 for n in numeros: total += n return total print(sumar_todo(1, 2, 3)) # 6 print(sumar_todo(10, 20, 30, 40)) # 100 print(sumar_todo()) # 0`} /> {` 6 100 0`}

El nombre args es solo una convención — puedes usar cualquier nombre. Lo que hace especial al parámetro es el asterisco delante.

Combinar parámetros normales con `*args`

Puedes mezclar parámetros normales con *args, pero los normales deben ir primero:

{`Hola, Ana! Hola, Luis! Hola, Pedro! Buenos días, Sofía!`}

El operador `*` para desempaquetar

El asterisco también funciona al llamar a una función: desempaqueta una lista o tupla como argumentos individuales:

{`6 3`}

**kwargs: argumentos por nombre variables

Si *args captura argumentos posicionales extra en una tupla, **kwargs captura argumentos por nombre extra en un diccionario:

for clave, valor in info.items(): print(f" {clave}: {valor}") mostrar_datos(nombre="Ana", edad=25, ciudad="Madrid")`} /> {` nombre: Ana edad: 25 ciudad: Madrid`}

De nuevo, el nombre kwargs es solo convención. El doble asterisco es lo que importa.

El orden canónico de los parámetros

Si usas los cuatro tipos de parámetros a la vez, van en este orden concreto:

{`1 (2, 3) False {'extra': 'hola', 'otro': 99}`}

// orden de los parámetros


          def f(posicionales, *args, solo_keyword, **kwargs)

Parámetros posicionales normales
*args — captura el resto de posicionales
Parámetros que solo se pueden pasar por nombre (van después del *)
**kwargs — captura el resto de los keyword

El uso más común de **kwargs no es tanto en tus propias funciones como al reenviar argumentos a otra función sin enumerarlos todos. Verás patrones como def mi_print(**kwargs): print(**kwargs) constantemente en librerías. También es la base de cómo funcionan los decoradores, que verás en el Libro 3.

Closures: funciones que recuerdan

Una closure (clausura) es una función definida dentro de otra función que "recuerda" las variables del entorno donde fue creada, incluso después de que la función exterior haya terminado.

Empieza con un ejemplo sencillo:

{`Hola, Ana! Buenos días, Luis! Hola, Pedro!`}

Fíjate: crear_saludador ya terminó cuando llamamos hola("Ana"), pero la función interna saludar todavía recuerda que saludo vale "Hola". Eso es una closure: la función lleva consigo el entorno donde nació.

Un caso de uso real: fábricas de funciones

{`10 15 50 [2, 4, 6, 8, 10]`} map(funcion, iterable) aplica funcion a cada elemento del iterable y devuelve un iterador con los resultados. Es la alternativa funcional al patrón "lista vacía + bucle + append". Lo envolvemos en list() para obtener una lista concreta.

`map` y `filter`: programación funcional básica

Python trae dos funciones de orden superior muy usadas que aplican una función a una colección:

{`[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] [2, 4, 6, 8, 10] [4, 16, 36, 64, 100]`} En el Módulo 7 del Libro 2 verás las comprensiones de lista, que hacen lo mismo de forma más legible en Python moderno: map y filter siguen siendo útiles al combinar funciones ya definidas con nombre, sin necesidad de lambda. 0 numeros = [-3, -1, 0, 2, 5, -2, 8] positivos = [n for n in numeros if es_positivo(n)] print("Positivos:", positivos) # Prueba con tu propia función cuadrados = aplicar_a_todos(lambda x: x**2, positivos) print("Cuadrados:", cuadrados)`} />

Ejercicios

Cinco ejercicios que cubren cada concepto del módulo. El último los combina todos.

Lambda + sorted: la combinación más frecuente del módulo.

Tu primera función con *args de utilidad real.

Hola

' # # etiqueta("a", "Click aquí", href="https://...", target="_blank") # → 'Click aquí' `, hint: 'Construye los atributos con un for sobre atributos.items(): f\'{k}="{v}"\'. Únelos con " ".join(...). Si hay atributos, pon un espacio antes de ellos en la etiqueta de apertura.', solution: { code: `def etiqueta(tag, contenido, **atributos): attrs = "" if atributos: partes = [f'{k}="{v}"' for k, v in atributos.items()] attrs = " " + " ".join(partes) return f"<{tag}{attrs}>{contenido}" print(etiqueta("p", "Hola")) print(etiqueta("a", "Click aquí", href="https://python.org", target="_blank")) print(etiqueta("input", "", type="text", placeholder="Escribe aquí"))`, explanation: '**kwargs (aquí llamado "atributos") captura todos los argumentos por nombre extra como un diccionario. Luego los iteramos con .items() para construir la cadena de atributos. Este patrón es exactamente cómo funcionan los constructores de interfaces en muchas librerías.', }, }} >

**kwargs en un caso de uso del mundo real.

Closures en acción: una fábrica de funciones validadoras.

El reto final junta *args, lambdas y funciones como valores en un patrón profesional.

Resumen del módulo

// lo importante en una página

Las funciones son objetos de primera clase: se guardan en variables, listas, dicts, y se pasan como argumentos.
lambda params: expr — función anónima de una línea. Ideal para sorted(key=...), map, filter.
*args captura argumentos posicionales extra como tupla.
**kwargs captura argumentos por nombre extra como diccionario.
Orden canónico: def f(normal, *args, solo_kw, **kwargs).
El operador * al llamar desempaqueta una lista como argumentos: f(*lista).
Closure: función interna que recuerda variables del entorno donde fue creada, aunque ese entorno ya no exista.
map(f, iter) — aplica f a cada elemento.
filter(f, iter) — conserva los elementos donde f devuelve True.

Tratar las funciones como valores cambia la forma en que piensas los problemas. En el próximo módulo ese cambio se vuelve todavía más profundo: aprenderás a crear tus propios tipos de datos con clases y objetos.