Saltar al contenido

Funciones de Python Lambda con EJEMPLOS

diciembre 8, 2019

¿Qué es Lambda?

Las Lambdas, también conocidas como funciones anónimas, son funciones pequeñas y restringidas que no necesitan un nombre (es decir, un identificador). Las funciones lambda fueron introducidas por primera vez en el campo de las matemáticas por Alonzo Church en la década de 1930.

Hoy en día, muchos lenguajes de programación modernos como Java, Python, C#, y C++ soportan funciones lambda para añadir funcionalidad a los lenguajes.

En este tutorial de Lambda, aprenderás:

  • ¿Qué es Lambda?
  • Lambdas en Pitón
  • Sintaxis y ejemplos
  • Uso de lambdas con Python incorporado
  • lambdas en filter()
  • lambdas en map()
  • lambdas in reduce()
  • ¿Por qué (y por qué no) usar funciones lambda?
  • Lambdas vs. funciones regulares

Lambdas en Pitón

En Python, las expresiones lambda (o formas lambda) se utilizan para construir funciones anónimas. Para ello, utilizará la palabra clave lambda (del mismo modo que utiliza def para definir las funciones normales).

Cada función anónima que definas en Python tendrá 3 partes esenciales:

  • La palabra clave lambda.
  • Los parámetros (o variables encuadernadas), y
  • La función cuerpo.

Una función lambda puede tener cualquier número de parámetros, pero el cuerpo de la función sólo puede contener una expresión .

Además, una lambda se escribe en una sola línea de código y también se puede invocar inmediatamente. Verá todo esto en acción en los próximos ejemplos.

Sintaxis y ejemplos

La sintaxis formal para escribir una función lambda es la siguiente:

lambda p1, p2: expresión >.

Aquí, p1 y p2 son los parámetros que se pasan a la función lambda. Puede añadir tantos o tan pocos parámetros como necesite.

Sin embargo, tenga en cuenta que no usamos corchetes alrededor de los parámetros como hacemos con las funciones regulares. La última parte (expresión) es cualquier expresión válida de python que funciona con los parámetros que usted proporciona a la función.

Ejemplo 1

Ahora que ya sabes de las lambdas, probémoslo con un ejemplo. Por lo tanto, abra su IDLE y escriba lo siguiente:

>

Aquí está la salida:

3

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Código Explicación

Aquí definimos una variable que contendrá el resultado devuelto por la función lambda.

1. La palabra clave lambda utilizada para definir una función anónima.

2. x e y son los parámetros que pasamos a la función lambda.

3. Este es el cuerpo de la función, que añade los 2 parámetros que pasamos. Note que es una sola expresión. No se pueden escribir varias frases en el cuerpo de una función lambda.

4. Llamamos a la función e imprimimos el valor devuelto.

Ejemplo 2

Ese fue un ejemplo básico para entender los fundamentos y la sintaxis del lambda. Ahora intentemos imprimir un lambda y veamos el resultado. Una vez más, abra su IDLE y escriba lo siguiente:

>

Ahora guarde su archivo y presione F5 para ejecutar el programa. Esta es la salida que debe obtener.

Salida:

>

¿Qué está pasando aquí? Veamos el código para entenderlo mejor.

Código Explicación

  1. Aquí definimos una cadena que pasarás como parámetro a la lambda.
  2. Declaramos un lambda que llama a una declaración impresa e imprime el resultado.

¿Pero por qué el programa no imprime la cadena que pasamos? Esto se debe a que la propia lambda devuelve un objeto de función. En este ejemplo, el lambda no está siendo llamado por la función de impresión sino simplemente devolviendo el objeto de función y la ubicación de memoria donde está almacenado. Eso es lo que se imprime en la consola.

Ejemplo 3

Sin embargo, si escribes un programa como este:

>

Y ejecútalo pulsando F5, verás una salida como esta.

Salida:

algún tipo de lambda inútil 

Ahora, la lambda está siendo llamada, y la cuerda que pasamos se imprime en la consola. Pero, ¿cuál es esa extraña sintaxis y por qué la definición de lambda está entre corchetes? Vamos a entender eso ahora.

Código Explicación

  1. Aquí está la misma cadena que definimos en el ejemplo anterior.
  2. En esta parte, definimos una lambda y la llamamos inmediatamente pasando la cadena como argumento. Esto es algo llamado IIFE, y aprenderá más sobre ello en las próximas secciones de este tutorial.

Ejemplo 4

Veamos un ejemplo final para entender cómo se ejecutan las lambdas y las funciones regulares. Por lo tanto, abra su IDLE y en un nuevo archivo, escriba lo siguiente:

#A FUNCIONAMIENTO REGULAR
def guru( funct, *args):
funct( *args)
def printer_one( arg):
volver a imprimir (arg)
def printer_two( arg):
imprimir(arg)
#CALL A REGULAR FUNCTION
guru( printer_one, $0027printer 1 REGULAR CALL$0027)
guru( printer_two, $0027printer 2 REGULAR CALL
$0027 )
# LLAMA A UNA FUNCIÓN REGULAR A TRAVÉS DE UN LAMBDA
guru(lambda: printer_one($0027printer 1 LAMBDA CALL$0027))
guru(lambda: printer_two($0027printer 2 LAMBDA CALL$0027))

>

Ahora, guarde el archivo y presione F5 para ejecutar el programa. Si no cometió ningún error, la salida debería ser algo así.

Salida:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Código Explicación

  1. Una función llamada gurú que toma otra función como primer parámetro y cualquier otro argumento que le siga.
  2. printer_one es una función sencilla que imprime el parámetro que se le ha pasado y lo devuelve.
  3. printer_two es similar a printer_one pero sin la declaración de retorno.
  4. En esta parte, llamamos a la función gurú y pasamos las funciones de impresora y una cadena como parámetros.
  5. Esta es la sintaxis para lograr el cuarto paso (es decir, llamar a la función gurú) pero usando lambdas.

En la siguiente sección, aprenderá a usar las funciones lambda con map(), reduce(), y filter() en Python.

Uso de lambdas con Python incorporado

Las funciones Lambda proporcionan una forma elegante y potente de realizar operaciones utilizando métodos incorporados en Python. Esto es posible porque los lambdas pueden ser invocados inmediatamente y pasados como un argumento a estas funciones.

IIFE en Python Lambda

IIFE significa ejecución de función inmediatamente invocada. Significa que una función lambda se puede llamar tan pronto como se define. Entendamos esto con un ejemplo; encienda su IDLE y escriba lo siguiente:

 (lambda x: x + x)(2) 

Aquí está la explicación de la salida y el código:

Esta habilidad de las lambdas para ser invocadas inmediatamente le permite usarlas dentro de funciones como map() y reduce(). Es útil porque es posible que no desee volver a utilizar estas funciones.

lambdas en filter()

La función de filtro se utiliza para seleccionar algunos elementos particulares de una secuencia de elementos. La secuencia puede ser cualquier iterador como listas, conjuntos, tuplas, etc.

Los elementos que se seleccionarán se basan en alguna restricción predefinida. Toma 2 parámetros:

  • Una función que define la restricción de filtrado
  • Una secuencia (cualquier iterador como listas, tuplas, etc.)

Por ejemplo,

secuencias =[10,2,8,7,5,4,3,11,0,1]
filtertered_result = filter (lambda x: x > 4, secuencias)
print(lista(resultado_filtrado))

>

Aquí está la salida:

10, 8, 7, 5, 11][10, 8, 7, 5, 11]

Código Explicación:

1. En la primera sentencia, definimos una lista llamada secuencias que contiene algunos números.

2. Aquí, declaramos una variable llamada filtered_result, que almacenará los valores filtrados devueltos por la función filter().

3. Una función lambda que se ejecuta en cada elemento de la lista y devuelve true si es mayor que 4.

4. Imprime el resultado devuelto por la función de filtro.

lambdas en map()

la función de mapa se utiliza para aplicar una operación particular a cada elemento de una secuencia. Al igual que filter(), también toma 2 parámetros:

  1. Una función que define la opción a realizar en los elementos
  2. Una o más secuencias

Por ejemplo, aquí hay un programa que imprime los cuadrados de los números en una lista dada:

secuencias =[10,2,8,7,5,4,3,11,0,1]
filtered_result = mapa (lambda x: x*x, secuencias)
print(lista(resultado_filtrado))

>

Salida:

.

KR1]

Código Explicación:

  1. Aquí definimos una lista llamada secuencias que contiene algunos números.
  2. Declaramos una variable llamada filtered_result que almacenará los valores mapeados
  3. Una función lambda que se ejecuta en cada elemento de la lista y devuelve el cuadrado de ese número.
  4. Imprimir el resultado devuelto por la función de mapa.

lambdas en reducir[vV2][J3]()

La función reducir, como map(), se utiliza para aplicar una operación a cada elemento de una secuencia. Sin embargo, difiere del mapa en su funcionamiento. Estos son los pasos que sigue la función reduce() para calcular una salida:

Paso 1) Realice la operación definida en los 2 primeros elementos de la secuencia.

Paso 2) Guardar este resultado

Paso 3) Realice la operación con el resultado guardado y el siguiente elemento de la secuencia.

Paso 4) Repita hasta que no queden más elementos.

También se necesitan dos parámetros:

  1. Una función que define la operación a realizar
  2. Una secuencia (cualquier iterador como listas, tuplas, etc.)

Por ejemplo, aquí hay un programa que devuelve el producto de todos los elementos de una lista:

de la importación de functools reducir
secuencias =[1,2,3,4,5]
producto = reducir (lambda x, y: x*y, secuencias)
imprimir(producto)
>

Aquí está la salida:

120

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>i

Código Explicación:

  1. Importar reducir desde el módulo functools
  2. Aquí definimos una lista llamada secuencias que contiene algunos números.
  3. Declaramos una variable llamada producto que almacenará el valor reducido
  4. Una función lambda que se ejecuta en cada elemento de la lista. Devolverá el producto de ese número según el resultado anterior.
  5. Imprimir el resultado devuelto por la función reducir.

¿Por qué (y por qué no) usar funciones lambda?

Como verá en la siguiente sección, las lambdas son tratadas de la misma manera que las funciones regulares a nivel de intérprete. En cierto modo, se podría decir que las lambdas proporcionan una sintaxis compacta para escribir funciones que devuelven una sola expresión.

Sin embargo, usted debe saber cuándo es una buena idea usar lambdas y cuándo evitarlas. En esta sección, aprenderá algunos de los principios de diseño utilizados por los desarrolladores de python al escribir lambdas.

Uno de los casos de uso más comunes para las lambdas es en la programación funcional, ya que Python soporta un paradigma (o estilo) de programación conocido como programación funcional.

Permite proporcionar una función como parámetro a otra función (por ejemplo, en mapa, filtro, etc.). En tales casos, el uso de lambdas ofrece una forma elegante de crear una función de una sola vez y pasarla como parámetro.

¿Cuándo no se debe usar Lambda?

Nunca debe escribir funciones lambda complicadas en un entorno de producción. Será muy difícil para los codificadores que mantienen tu código descifrarlo. Si te encuentras haciendo expresiones complejas de una sola línea, sería una práctica muy superior definir una función apropiada. Como mejor práctica, debe recordar que un código simple es siempre mejor que un código complejo.

Lambdas vs. funciones regulares

Como se ha dicho anteriormente, las lambdas son[vV4][J5] sólo funciones que no tienen un identificador vinculado a ellas. En palabras más sencillas, son funciones sin nombre (por lo tanto, anónimas). Aquí hay una tabla para ilustrar la diferencia entre lambdas y funciones regulares en python.

Lambdas

Funciones regulares

Sintaxis:

lambda x : x + x 

Sintaxis:

def (x) :
devolución x + x

>

Las funciones lambda sólo pueden tener una expresión en su cuerpo.

Las funciones regulares pueden tener múltiples expresiones y afirmaciones en su cuerpo.

Los lambdas no tienen un nombre asociado con ellos. Es por eso que también se conocen como funciones anónimas.

Las funciones regulares deben tener un nombre y una firma.

Las lambdas no contienen una declaración de devolución porque el cuerpo es devuelto automáticamente.

Las funciones que necesitan devolver el valor deben incluir una declaración de devolución.

Explicación de las diferencias?

La principal diferencia entre una lambda y una función regular es que la función lambda evalúa una sola expresión y produce un objeto de función. En consecuencia, podemos nombrar el resultado de la función lambda y usarlo en nuestro programa como lo hicimos en el ejemplo anterior.

Una función regular para el ejemplo anterior se vería así:

def adder (x, y):
retorno x + y
print (adder (1, 2))
>

Aquí, tenemos que definir un nombre para la función que devuelve el resultado cuando lo llamamos . Una función lambda no contiene una declaración de retorno porque sólo tendrá una única expresión que siempre se devuelve por defecto. Ni siquiera tienes que asignar una lambda, ya que puede ser invocada inmediatamente (ver la siguiente sección). Como verá en el siguiente ejemplo, las lambdas se vuelven particularmente poderosas cuando las usamos con las funciones incorporadas de Python.

Sin embargo, puede que todavía se pregunte en qué se diferencian los lambdas de una función que devuelve una sola expresión (como la anterior). A nivel de intérprete, no hay mucha diferencia. Puede sonar sorprendente, pero cualquier función lambda que usted defina en Python es tratada como una función normal por el intérprete.

Como puede ver en el diagrama, las dos definiciones son manejadas de la misma manera por el intérprete de python cuando se convierten a bytecode. Ahora, no puede nombrar una función lambda porque está reservada por Python, pero cualquier otro nombre de función producirá el mismo código de byte[KR6].

Resumen

  • Las Lambdas, también conocidas como funciones anónimas, son funciones pequeñas y restringidas que no necesitan un nombre (es decir, un identificador).
  • Cada función lambda en Python tiene 3 partes esenciales:
  • La palabra clave lambda.
  • Los parámetros (o variables encuadernadas), y
  • La función cuerpo.
  • La sintaxis para escribir un lambda es: parámetro lambda: expresión
  • Las lambdas pueden tener cualquier número de parámetros, pero no están encerradas en llaves
  • .

  • Una lambda sólo puede tener una expresión en su cuerpo funcional, que es devuelta por defecto.
  • En el nivel de bytecode, no hay mucha diferencia entre la forma en que el intérprete maneja las funciones lambdas y las funciones regulares.
  • Los Lambdas soportan IIFE a través de esta sintaxis: (parámetro lambda: expresión)(argumento)
  • Las lambda se utilizan comúnmente con las siguientes pitones incorporadas:
  • Filtro: filtro (parámetro lambda: expresión, secuencia iterable)
  • Mapa: mapa (parámetro lambda: expresión, secuencias iterables)
  • Reduce: reduce (parámetro lambda1, parámetro2: expresión, secuencia iterable)
  • No escriba funciones lambda complicadas en un entorno de producción porque será difícil para los mantenedores de códigos.

He añadido una tabla, pero la explicación es necesaria para entender las diferencias.

[vV4] Ponga esta sección en el formulario de la tabla. Vea este enlace: https://www.guru99.com/call-by-value-vs-call-by-reference.html agregue más puntos en esta sección.

J3] Está debajo de la explicación

vV2]Falta imagen en esta sección.

KR1]No quiero imágenes de código… sólo pegar la salida en la preetiqueta… hazlo en todas partes

KR6]Añade más ejemplos ya que queremos que el número de palabras sea 2300+