Tema 11. Funciones Lambda

Explicación y conceptos básicos de las Funciones Lambda en Python 3.

Funciones lambda

Son un tipo especial de funciones de Python que tienen la sintaxis siguiente

lambda parámetros: expresión

• Son útiles para ejecutar funciones en una sola línea

• Pueden tomar cualquier número de argumentos

• Tienen una limitación: solamente pueden contener una expresión

Veamos algunos ejemplos

Ejemplo 1

Función que dado un número, le suma 10 puntos más:

plus10 = lambda x: x + 10
plus10(5)

#RESPUESTA
15

Ejemplo 2

Función que calcula el producto de dos números:

prod = lambda x, y: x * y
prod(5, 10)

#RESPUESTA
50

Ejemplo 3

Función que dados 3 números, calcula el discriminante de la ecuación de segundo grado.

Recordemos que dada una ecuación de segundo grado de la forma $ax^2 + bx + c = 0$

el discriminante es $\triangle = b^2-4ac$

y dependiendo de su signo, nos indica cuantas soluciones reales va a tener la ecuación:

• Si Δ > 0, entonces hay dos soluciones diferentes.

• Si Δ = 0, entonces hay dos soluciones que son iguales.

• Si Δ < 0, entonces no hay solución.

discriminante = lambda a, b, c: b ** 2 - 4 * a * c
discriminante(1, 2, 1) # Se corresponde a la ecuación x^2 + 2x + 1 = 0, cuya única solución es x = -1

#RESPUESTA
0

EJERCICIO 1:

Vamos a crear una función lambda que devuelva una tupla donde en la primera posición esté el número introducido por parámetro; en la segunda, su doble; y, en la tercera, su cuadrado.

ejercicio1 = lambda a: (a, a * 2, a ** 2)
ejercicio1(2)

#RESPUESTA
(2, 4, 4)

La función filter()

• Aplica una función a todos los elementos de un objeto iterable

• Devuelve un objeto generador, de ahí que usemos la función list() para convertirlo a lista

• Como output, devuelve los elementos para los cuales el aplicar la función ha devuelto True

Con la ayuda de las funciones lambda, apliquemos filter() para quedarnos con los números múltiplos de 7 de la siguiente lista llamada nums

nums = [49, 57, 62, 147, 2101, 22]
list(filter(lambda x: (x % 7 == 0), nums))

#RESPUESTA
[49, 147]

La función proporcionada a filter() no tiene por qué ser lambda, sino que puede ser una ya existente, o bien una creada por nosotros mismos.

Con las siguientes líneas de código vamos a obtener todas las palabras cuya tercera letra sea s haciendo uso de filter() y la función creada third_letter_is_s():

def third_letter_is_s(word):
  return word[2] == "s"

words = ["castaña", "astronomía", "masa", "bolígrafo", "mando", "tostada"]
list(filter(third_letter_is_s, words))

#RESPUESTA
['castaña', 'masa', 'tostada']

IMPORTANTE la función que se utilice debe tener un parámetro de entrada que sea el que se utilice para recorrer el bucle. Al utilizar filter, no damos valor a este parámetro ya que se lo dá la propia función filter con el objeto iterable que entra como segundo parámetro a filter.

EJERCICIO 2:

Dada una lista numérica, vamos a filtrarla y quedarnos con los números positivos. El resultado lo mostraremos en una lista.

nums = [2, -2, 5, -5, 7, -7]
list(filter(lambda x: x > 0, nums))

#RESPUESTA
[2, 5, 7]

La función reduce()

• Aplica continuamente una misma función a los elementos de un objeto iterable

  1. Aplica la función a los primeros dos elementos

  2. Aplica la función al resultado del paso anterior y el tercer elemento

  3. Aplica la función al resultado del paso anterior y el cuarto elemento

  4. Sigue así hasta que solo queda un elemento

• Devuelve el valor resultante

Con la ayuda de las funciones lambda, apliquemos reduce() para calcular el producto de todos los elementos de una lista

from functools import reduce

nums = [1, 2, 3, 4, 5, 6]
reduce(lambda x, y: x * y, nums)

#RESPUESTA
720

De nuevo, la función proporcionada a reduce() no tiene por qué ser lambda, sino que puede ser una ya existente o bien, una creada por nosotros mismos.

Con las siguientes líneas de código, vamos a obtener el máximo de una lista dada, haciendo uso de reduce() y la función creada bigger_than():

def bigger_than(a, b):
  if a > b:
    return a
  return b

bigger_than(14, 7)

#RESPUESTA
14

nums = [-10, 5, 7, -3, 16, -30, 2, 33]
reduce(bigger_than, nums)

#RESPUESTA
33

EJERCICIO 3:

Dada una lista de palabras, vamos a quedarnos con la palabra con más "a".

from functools import reduce

def a_comparer(a, b):
    if a.count("a") > b.count("a"):
        return a
    else:
        return b

words = ["albondiga", "espejo", "alama", "antimanifestaciones", "supercalifragilisticoespialidoso", "aaaa", "a"]

reduce(a_comparer, words)

#RESPUESTA
'aaaa'

La función map()

• Aplica una misma función a todos los elementos de un objeto iterable

• Devuelve un objeto generador, de ahí que usemos la función list() para convertirlo a lista

• Como output, devuelve el resultado de aplicar la función a cada elemento

Con la ayuda de las funciones lambda, apliquemos map() para calcular las longitudes de las siguientes palabras

words = ["zapato", "amigo", "yoyo", "barco", "xilófono", "césped"]
list(map(lambda w: len(w), words))

#RESPUESTA
[6, 5, 4, 5, 8, 6]

Sin embargo, para este caso en concreto no haría falta usar funciones lambda, pues podríamos hacer directamente

list(map(len, words))

#RESPUESTA
[6, 5, 4, 5, 8, 6]

EJERCICIO 4:

Vamos a convertir una lista de grados Celsius a grados Fahrenheit. El resultado lo mostraremos como una lista.

degrees = [22.5, 35, -5.2]

list(map(lambda x: x * (9 / 5) + 32, degrees))

#RESPUESTA
[72.5, 95.0, 22.64]

La función sorted()

• Ordena los elementos del objeto iterable que indiquemos de acuerdo a la función que pasemos por parámetro

• Como output, devuelve una permutación del objeto iterable ordenado según la función indicada

Con la ayuda de las funciones lambda, apliquemos sorted() para ordenar la lista words en función de las longitudes de las palabras en orden descendente.

words = ["zapato", "amigo", "yoyo", "barco", "xilófono", "césped"]
sorted(words, key = lambda x: len(x), reverse = True)

#RESPUESTA
['xilófono', 'zapato', 'césped', 'amigo', 'barco', 'yoyo']

De nuevo, podríamos en este caso evitar el uso de las funciones lambda haciendo uso del siguiente código:

sorted(words, key = len, reverse = True)

#RESPUESTA
['xilófono', 'zapato', 'césped', 'amigo', 'barco', 'yoyo']

Observación. Si quisiésemos ordenar en orden ascendente, simplemente tendríamos que indicar reverse = False, que al ser el valor por defecto, bastaría con omitir dicho parámetro.

Observación. Si el tipo de objeto a ser ordenado es un string y no indicamos parámetro key, entonces se ordenan por defecto: orden alfabético ascendente.

sorted(words, key = len)

#RESPUESTA
['yoyo', 'amigo', 'barco', 'zapato', 'césped', 'xilófono']

sorted(words)

#RESPUESTA
['amigo', 'barco', 'césped', 'xilófono', 'yoyo', 'zapato']

EJERCICIO 5:

Vamos a ordenar una lista de palabras por el número de apariciones de la letra indicada por el usuario. El orden será descendente.

words = ["zapato", "amigo", "yoyo", "barco", "xilófono", "césped"]
letter = input("Introduzca una letra: ")

sorted(words, key = lambda x: x.count(letter), reverse = True)

#RESPUESTA
Introduzca una letra: a
['zapato', 'amigo', 'barco', 'yoyo', 'xilófono', 'césped']

REPASO

#EJERCICIO 1: Crea una función lambda que dado un número entero multiplique por su anterior y su siguiente. Por ejemplo,
#si proporcionamos n = 3, nos tendrá que devolver 2 · 3 · 4 = 24.

ejercicio1 = lambda n: (n - 1) * n * (n + 1)
ejercicio1(3)

#RESPUESTA
24

#EJERCICIO 2: Crea una función lambda que dados dos números devuelva si el primero es mayor.

ejercicio2 = lambda a, b: a > b
ejercicio2(3, 2)

#RESPUESTA
True

#EJERCICIO 3: Dada una lista de palabras, quédate con filter() con las que tengan más vocales que consonantes. 
# Necesitarás una función que devuelva si una palabra tiene más vocales que consonantes

def more_vocals(word):
    """
    Función que indica si la palabra tiene 
    más vocales que consonantes.

    Args:
        word (str): palabra a comprobar.
    Return:
        True si tiene más vocales que cons.
        False si tiene más consonantes.
    """
    vowels = 0
    cons = 0

    for i in word.lower():
        if i == "a" or i == "e"  or i == "i" or i == "o" or i == "u":
            vowels += 1
        elif i == " " or i == "1" or i == "2" or i == "3" or i == "4" or i == "5" or i == "6" or i == "7" or i == "8" or i == "9" or i == "0":
            continue
        else:
            cons += 1

    if vowels > cons:
        return True
    else:
        return False

words = ["playa", "alijo", "macarron"]
list(filter(more_vocals, words))

#RESPUESTA
['alijo']

#EJERCICIO 4: Dada una lista de números enteros, quédate con filter() con los que tengan más de 5 divisores. 
#Necesitarás una función que devuelva el número de divisores de un número dado.

def divisors(x):
    """
    Función que cuenta cuantos divisores
    tiene un número

    Args:
        x (int): Numero entero positivo
    Return:
        counter (int): contador de divisores.
    """
    counter = 0
    for divisor in range(1, x + 1):
        if x % divisor == 0:
            counter += 1
    return counter

nums = [1994, 234, 56, 8999, 567]
list(filter(lambda num: divisors(num) > 5, nums))

#RESPUESTA
[234, 56, 567]

#EJERCICIO 5: Dada una lista de palabras, quédate con reduce() con la palabra más larga. Necesitarás una función que
#compare dos palabras y devuelva la que tenga mayor longitud.

from functools import reduce

def larger_word(a, b):
    """
    Función que devuelve la palabra más larga.

    Args:
        a (str): palabra 1
        b (str): palabra 2
    Return:
        a o b en función de cual sea más larga.
    """

    if len(a) > len(b):
        return a
    else:
        return b #Si son iguales devuelve la nueva palabra

words = ["zapato", "amigo", "yoyo", "barco", "xilófono", "césped"]
reduce(larger_word, words)

#RESPUESTA
'xilófono'

#EJERCICIO 6: Dada una lista de palabras, calcula el número de vocales de cada una con map().

def vowel_counter(word):
    """
    Función que cuenta vocales.

    Args:
        word (string)
    Return:
        counter (int)
    """
    counter = 0
    for i in word:
         if i == "a" or i == "e"  or i == "i" or i == "o" or i == "u":
             counter += 1
    return counter

words = ["zapato", "amigo", "yoyo", "barco", "xilófono", "césped"]
list(map(vowel_counter, words))

#RESPUESTA
[3, 3, 2, 2, 3, 1]

#EJERCICIO 7: Dada una lista de palabras, quédate con reduce() y map() con la palabra con más consonantes. Necesitarás
# una función que cuente el número de consonantes de una palabra y otra que dados dos números, devuelva el
# mayor.

from functools import reduce

def cons_counter(word):
    """
    Función que cuenta consonantes.

    Args:
        word (string)
    Return:
        counter (int)
    """
    counter = 0
    for i in word:
        if i == "a" or i == "e"  or i == "i" or i == "o" or i == "u" or i == " " or i == "1" or i == "2" or i == "3" or i == "4" or i == "5" or i == "6" or i == "7" or i == "8" or i == "9" or i == "0":
            continue
        else:
            counter += 1
    return counter

def larger(x, y):
    """
    Función que devuelve el número más grande.

    Args:
        x (int): resultado de cons_counter
        y (int): resultado de cons_counter
    
    Return:
        x o y en función de cual es más grande.
    """
    if x > y:
        return x
    else:
        return y

words = ["zapato", "amigo", "yoyo", "barco", "xilófono", "céspedes"]
#Buscamos el elemento de words que cumple:
#en la lista de cuantas consonantes buscamos el index del elemento con más consonantes.
words[list(map(cons_counter, words)).index(reduce(larger, list(map(cons_counter, words))))]

#RESPUESTA
'céspedd'

#EJERCICIO 8: Dada una lista de números enteros, calcula el número anterior con map().

nums = [1994, 234, 56, 8999, 567]
list(map(lambda num: num - 1, nums))

#RESPUESTA
[1993, 233, 55, 8998, 566]

#EJERCICIO 9: Dada una lista de números reales, ordénalos con sorted() por valor absoluto de menor a mayor.

nums = [1994, 234, 56, 8999, 567, -79012, -925, -57]

sorted(nums, key = lambda num: abs(num), reverse = False)

#RESPUESTA
[56, -57, 234, 567, -925, 1994, 8999, -79012]

#EJERCICIO 10: Dada una lista de palabras, ordénalos con sorted() por número de consonates de mayor a menor.

def cons_counter(word):
    """
    Función que cuenta consonantes.

    Args:
        word (string)
    Return:
        counter (int)
    """
    counter = 0
    for i in word:
        if i == "a" or i == "e"  or i == "i" or i == "o" or i == "u" or i == " " or i == "1" or i == "2" or i == "3" or i == "4" or i == "5" or i == "6" or i == "7" or i == "8" or i == "9" or i == "0":
            continue
        else:
            counter += 1
    return counter

words = ["zapato", "amigo", "yoyo", "barco", "xilófono", "césped"]
sorted(words, key = cons_counter, reverse = True)

#RESPUESTA
['xilófono', 'césped', 'zapato', 'barco', 'amigo', 'yoyo']