1. 1 - programación y manejo de funciones en Python avanzadas
2. 2 - Funciones con argumentos variables (*args)
3. 3 - Funciones con argumentos variables (*kwargs)
4. 4 - Funciones lambda
5. 5 - Funciones lambda como argumento
6. 6 - Funciones como argumento en las funciones lambda
7. 7 - Funciones lambda con argumentos variables

programación y manejo de funciones en Python avanzadas

Lo cierto que este contenido no estaba pensado en hacerles, pero es cierto que el mundo de las funciones en Python es mucho más amplio de lo que parece. Y es que tenemos varios tipos de funciones que podemos usar para hacer cosas más complejas, desde la función lambda que es una función anónima que se define en una sola línea, hasta las funciones con argumentos variables que además son muy utilizados en Django.

Funciones con argumentos variables (*args)

Tenemos ciertas ocasiones que sabemos que necesitamos definir la variable con argumentos, pero no sabemos exactamente cuantos argumentos son los que nuestro código o usuario nos va a indicar.

def suma(a: int, b: int) -> int:
    return a + b

Pongamos por ejemplo una suma, normalmente en los ejemplos seleccionamos a y b para la función de suma, pero ¿qué pasa si el usuario o el código necesita n sumandos pero no sabemos cuantos son?. En este caso Python tiene una solución muy práctica.

def suma(*arg):
    resultado=0 # Empezamos con un resultado que sea igual a 0
    for i in arg: # Recorremos todos los argumentos
        resultado+=i # Sumamos todos los argumentos
    return resultado

print(suma(1,2,3,4,5))
print(suma(1,2,3,4,5,6,7,8,9,10))

Como podemos ver en el código que hemos realizado anteriormente lo que hacemos es recorrer los distintos arugumentos que poddamos tener, dede 1 hasta n sumandos y devolvemos el resultado. De esta manera no nos limitamos a dos sumandos, podemos tener tantos sumandos como queramos.

Funciones con argumentos variables (*kwargs)

Pero tenemos más opciones, en las que el usuario o el código nos va a indicar que argumentos queremos que tenga la función. La mayor diferencia que vamos a encontrar es que en este caso es que el argumento/s son variables que van a tener un nombre y un valor, es decir, un diccionario.

def suma(**kwargs):
    resultado=0 # Empezamos con un resultado que sea igual a 0
    for i in kwargs: # Recorremos todos los argumentos
        resultado+=kwargs[i] # Sumamos todos los argumentos
    return resultado

print(suma(a=1,b=2,c=3,d=4,e=5))
print(suma(a=1,b=2,c=3,d=4,e=5,f=6,g=7,h=8,i=9,j=10))

Así que en este caso vemos cómo hemos introducido una clave y un valor en los datos que le enviamos a la función.

Ahora que conocemos los argumentos de las funciones *args y **kwargs podemos utilizarlos los dos juntos en una misma función e incluso con argumentos que no sean variables o tengan un dato asignado.

def suma(a: int, b: int, *args, **kwargs) -> int:
    resultado = a + b
    print(f"El resultado de la suma de a={a} y b={b} es igual a {resultado}")
    for i in args:
        resultado += i
    for clave,valor in kwargs.items():
        print(f"Los valores de **kwargs son: {clave} = {valor}")
    return f"El resultado de *args es: {resultado}"

print(suma(1,2,3,4,5))
print(suma(1,2,3,4,5,6,7,8,9,10))
print(suma(1,2,4,c=2,d=5))

# El resultado de la suma de a=1 y b=2 es igual a 3
# Los valores de **kwargs son: c = 2
# Los valores de **kwargs son: d = 5
# El resultado de *args es: 7

Tenemos que tener en cuenta el orden de los argumentos, es decir, los argumentos variables deben ir al final de la función.

1. Argumentos normales
2. *args
3. **kwargs

Funciones lambda

Las funciones lambda son funciones anónimas que se definen en una sola línea y el código que suelen ejecutar es bastante simple. En realidad la explicación que nos da Python en la documentación oficial es que las funciones lambda son simples y una versión acortada que puedes usar si te da pereza escribir una función normal.

Usando el ejemplo de las funciones anteriores, para la suma una función lambda sería la siguiente:

suma=lambda a,b: a+b
print(suma(1,2))

Funciones lambda como argumento

La función lambda también puede ser el argumento de una función con lo que podemos realizar operaciones más complejas.

def operacion(a: int, b: int, operacion: callable) -> int:
    return operacion(a, b)

print(operacion(2, 3, lambda x, y: x + y))
print(operacion(2, 3, lambda x, y: x - y))
print(operacion(2, 3, lambda x, y: x * y))
print(operacion(2, 3, lambda x, y: x / y))

Funciones como argumento en las funciones lambda

Tenemos también el caso contrario, donde tenemos una función lambda que recibe una función como argumento. En este caso la función lambda es la que se encarga de realizar la operación y la función que recibe es la que se encarga de realizar la operación.

def suma(a: int, b: int) -> int:
    return a + b

suma=lambda a,b: suma(a,b)
print(suma(1,2))
# Nos devolverá 3 como resultado de la suma de 1 y 2

Funciones lambda con argumentos variables

También podemos usar argumentos variables en las funciones lambda, porque como hemos dicho, las funciones lambdas son funciones anónimas que se definen en una sola línea y el código que suelen ejecutar es bastante simple, así que como tal no nos limitamos a dos argumentos.

suma=lambda *args: sum(args)
print(suma(1,2,3,4,5))
# Nos devolverá 15 como resultado de la suma de 1, 2, 3, 4 y 5

O bien tenemos la posibilidad de usar argumentos variables con clave y valor **kwargs.

suma=lambda **kwargs: sum(kwargs.values())
print(suma(a=1,b=2,c=3,d=4,e=5))
# Nos devolverá 15 como resultado de la suma de 1, 2, 3, 4 y 5