Funções do Python Lambda com EXEMPLOS

O que é função Lambda em Python?

Uma função Lambda em Python programação é uma função anônima ou uma função sem nome. É uma função pequena e restrita que não possui mais de uma linha. Assim como uma função normal, uma função Lambda pode ter vários argumentos com uma expressão.

Em Python, expressões lambda (ou formas lambda) são utilizadas para construir funções anônimas. Para fazer isso, você usará o lambda palavra-chave (assim como você usa def para definir funções normais). Cada função anônima que você define em Python terá 3 partes essenciais:

A palavra-chave lambda.
Os parâmetros (ou variáveis vinculadas) e
O corpo da função.

Uma função lambda pode ter qualquer número de parâmetros, mas o corpo da função pode conter apenas um expressão. Além disso, um lambda é escrito em uma única linha de código e também pode ser invocado imediatamente. Você verá tudo isso em ação nos próximos exemplos.

Neste tutorial Lambda em Python, você aprenderá:

Sintaxe e exemplos
Usando lambdas com Python integrado
lambdas em filtro()
lambdas no mapa()
lambdas em reduce()
Por que (e por que não) usar funções lambda?
Lambdas versus funções regulares

Sintaxe e exemplos

A sintaxe formal para escrever uma função lambda é a seguinte:

lambda p1, p2: expression

Aqui, p1 e p2 são os parâmetros que são passados para a função lambda. Você pode adicionar quantos parâmetros precisar.

No entanto, observe que não usamos colchetes em torno dos parâmetros como fazemos com funções normais. A última parte (expressão) é qualquer expressão python válida que opera nos parâmetros que você fornece à função.

Exemplo 1

Agora que você sabe sobre lambdas, vamos tentar com um exemplo. Então, abra seu IDLE e digite o seguinte:

adder = lambda x, y: x + y
print (adder (1, 2))

Aqui está a saída:

Explicação do código

Aqui, definimos uma variável que conterá o resultado retornado pela função lambda.

1. A palavra-chave lambda usada para definir uma função anônima.

2. xey são os parâmetros que passamos para a função lambda.

3. Este é o corpo da função, que adiciona os 2 parâmetros que passamos. Observe que é uma única expressão. Você não pode escrever várias instruções no corpo de uma função lambda.

4. Chamamos a função e imprimimos o valor retornado.

Exemplo 2

Esse foi um exemplo básico para entender os fundamentos e a sintaxe do lambda. Vamos agora tentar imprimir um lambda e ver o resultado. Novamente, abra seu IDLE e digite o seguinte:

#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))

Agora salve seu arquivo e pressione F5 para executar o programa. Esta é a saída que você deve obter.

Saída:

<function <lambda> at 0x00000185C3BF81E0>

O que está acontecendo aqui? Vamos ver o código para entender melhor.

Explicação do código

Aqui, definimos uma string que você passará como parâmetro para o lambda.
Declaramos um lambda que chama uma instrução print e imprime o resultado.

Mas por que o programa não imprime a string que passamos? Isso ocorre porque o próprio lambda retorna um objeto de função. Neste exemplo, o lambda não está sendo chamado pela função de impressão, mas simplesmente retornando o objeto de função e o local de memória onde ele está armazenado. Isso é o que é impresso no console.

Exemplo 3

No entanto, se você escrever um programa como este:

#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)

E execute-o pressionando F5, você verá uma saída como esta.

Saída:

some kind of a useless lambda

Agora, o lambda está sendo chamado e a string que passamos é impressa no console. Mas o que é essa sintaxe estranha e por que a definição lambda é coberta entre colchetes? Vamos entender isso agora.

Explicação do código

Aqui está a mesma string que definimos no exemplo anterior.
Nesta parte, estamos definindo um lambda e chamando-o imediatamente, passando a string como argumento. Isso é chamado de IIFE, e você aprenderá mais sobre isso nas próximas seções deste tutorial.

Exemplo 4

Vejamos um exemplo final para entender como lambdas e funções regulares são executadas. Então, abra seu IDLE e em um novo arquivo, digite o seguinte:

#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION 
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

Agora, salve o arquivo e pressione F5 para executar o programa. Se você não cometeu nenhum erro, a saída deve ser algo assim.

Saída:

impressora 1 CHAMADA REGULAR

impressora 2 CHAMADA REGULAR

impressora 1 LAMBDA CALL

impressora 2 LAMBDA CALL

Explicação do código

Uma função chamada guru que recebe outra função como primeiro parâmetro e quaisquer outros argumentos que a seguem.
printer_one é uma função simples que imprime o parâmetro passado para ela e o retorna.
printer_two é semelhante a printer_one, mas sem a instrução return.
Nesta parte, estamos chamando a função guru e passando as funções da impressora e uma string como parâmetros.
Esta é a sintaxe para alcançar a quarta etapa (ou seja, chamar a função guru), mas usando lambdas.

Na próxima seção, você aprenderá como usar funções lambda com map(), reduzir(), e filtro() em Python.

Usando lambdas com Python integrado

As funções do Lambda fornecem uma maneira elegante e poderosa de realizar operações usando métodos integrados em Python. Isso é possível porque lambdas podem ser invocados imediatamente e passados como um argumento para essas funções.

IIFE em Python Lambda

IIFE significa execução de função invocada imediatamente. Isso significa que uma função lambda pode ser chamada assim que é definida. Vamos entender isso com um exemplo; inicie seu IDLE e digite o seguinte:

 (lambda x: x + x)(2)

Aqui está a saída e a explicação do código:

Essa capacidade dos lambdas de serem invocados imediatamente permite que você os use dentro de funções como map() e reduce(). É útil porque você pode não querer usar essas funções novamente.

lambdas em filtro()

A função de filtro é usada para selecionar alguns elementos específicos de uma sequência de elementos. A sequência pode ser qualquer iterador como listas, conjuntos, tuplas, etc.

Os elementos que serão selecionados são baseados em alguma restrição pré-definida. São necessários 2 parâmetros:

Uma função que define a restrição de filtragem
Uma sequência (qualquer iterador, como listas, tuplas etc.)

Por exemplo,

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

Aqui está a saída:

[10, 8, 7, 5, 11]

Explicação do código:

1. Na primeira declaração, definimos uma lista chamada sequências que contém alguns números.

2. Aqui, declaramos uma variável chamada filter_result, que armazenará os valores filtrados retornados pela função filter().

3. Uma função lambda que é executada em cada elemento da lista e retorna true se for maior que 4.

4. Imprima o resultado retornado pela função de filtro.

lambdas no mapa()

a função map é usada para aplicar uma operação específica a cada elemento em uma sequência. Assim como filter(), também leva 2 parâmetros:

Uma função que define a operação a ser executada nos elementos
Uma ou mais sequências

Por exemplo, aqui está um programa que imprime os quadrados dos números em uma determinada lista:

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

Saída:

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

[KR1]

Explicação do código:

Aqui, definimos uma lista chamada sequências que contém alguns números.
Declaramos uma variável chamada filter_result que armazenará os valores mapeados
Uma função lambda que é executada em cada elemento da lista e retorna o quadrado desse número.
Imprima o resultado retornado pela função map.

lambdas em reduce()

A função reduce, como map(), é usada para aplicar uma operação a cada elemento em uma sequência. No entanto, difere do mapa em seu funcionamento. Estas são as etapas seguidas pela função reduce() para calcular uma saída:

Etapa 1) Execute a operação definida nos 2 primeiros elementos da sequência.

Etapa 2) Salvar este resultado

Etapa 3) Execute a operação com o resultado salvo e o próximo elemento na sequência.

Etapa 4) Repita até que não restem mais elementos.

Também recebe dois parâmetros:

Uma função que define a operação a ser executada
Uma sequência (qualquer iterador, como listas, tuplas etc.)

Por exemplo, aqui está um programa que retorna o produto de todos os elementos em uma lista:

from functools import reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

Aqui está a saída:

Explicação do código:

Importar redução do módulo functools
Aqui, definimos uma lista chamada sequências que contém alguns números.
Declaramos uma variável chamada produto que armazenará o valor reduzido
Uma função lambda que é executada em cada elemento da lista. Ele retornará o produto desse número conforme o resultado anterior.
Imprima o resultado retornado pela função de redução.

Por que (e por que não) usar funções lambda?

Como você verá na próxima seção, lambdas são tratados da mesma forma que funções regulares no nível do interpretador. De certa forma, você poderia dizer que lambdas fornecem uma sintaxe compacta para escrever funções que retornam uma única expressão.

No entanto, você deve saber quando é uma boa ideia usar lambdas e quando evitá-los. Nesta seção, você aprenderá alguns dos princípios de design usados pelos desenvolvedores python ao escrever lambdas.

Um dos casos de uso mais comuns para lambdas é na programação funcional, pois o Python suporta um paradigma (ou estilo) de programação conhecido como programação funcional.

Ele permite que você forneça uma função como parâmetro para outra função (por exemplo, no mapa, filtro, etc.). Nesses casos, o uso de lambdas oferece uma maneira elegante de criar uma função única e passá-la como parâmetro.

Quando você não deve usar o Lambda?

Você nunca deve escrever funções lambda complicadas em um ambiente de produção. Será muito difícil para os codificadores que mantêm seu código decifrá-lo. Se você estiver fazendo expressões complexas de uma linha, seria uma prática muito superior definir uma função adequada. Como prática recomendada, você precisa lembrar que código simples é sempre melhor que código complexo.

Lambdas versus funções regulares

Como dito anteriormente, lambdas são [vV4][J5] apenas funções que não possuem um identificador vinculado a elas. Em palavras mais simples, são funções sem nomes (portanto, anônimas). Aqui está uma tabela para ilustrar a diferença entre lambdas e funções regulares em python.

Lambdas

Funções regulares

Sintaxe:

lambda x : x + x

Sintaxe:

def (x) :
return x + x

As funções lambda podem ter apenas uma expressão em seu corpo.

Funções regulares podem ter várias expressões e instruções em seu corpo.

Lambdas não têm um nome associado a eles. É por isso que eles também são conhecidos como funções anônimas.

As funções regulares devem ter um nome e uma assinatura.

Lambdas não contêm uma instrução de retorno porque o corpo é retornado automaticamente.

As funções que precisam retornar valor devem incluir uma instrução de retorno.

Explicação das diferenças?

A principal diferença entre uma função lambda e uma função regular é que a função lambda avalia apenas uma única expressão e produz um objeto de função. Consequentemente, podemos nomear o resultado da função lambda e usá-lo em nosso programa como fizemos no exemplo anterior.

Uma função regular para o exemplo acima ficaria assim:

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

Aqui, temos que definir um nome para a função que retorna o resultado quando chamamos isto. Uma função lambda não contém uma instrução de retorno porque terá apenas uma única expressão que sempre é retornada por padrão. Você nem precisa atribuir um lambda, pois ele pode ser invocado imediatamente (consulte a próxima seção). Como você verá no exemplo a seguir, lambdas se tornam particularmente poderosos quando os usamos com as funções internas do Python.

No entanto, você ainda pode estar se perguntando como os lambdas são diferentes de uma função que retorna uma única expressão (como a acima). No nível do intérprete, não há muita diferença. Pode parecer surpreendente, mas qualquer função lambda que você define em Python é tratada como uma função normal pelo interpretador.

Como você pode ver no diagrama, as duas definições são tratadas da mesma maneira pelo interpretador python quando convertidas em bytecode. Agora, você não pode nomear uma função lambda porque é reservado pelo Python, mas qualquer outro nome de função produzirá o mesmo bytecode[KR6].

Resumo

Lambdas, também conhecidas como funções anônimas, são funções pequenas e restritas que não precisam de um nome (ou seja, um identificador).
Toda função lambda em Python tem 3 partes essenciais:
A palavra-chave lambda.
Os parâmetros (ou variáveis vinculadas) e
O corpo da função.
A sintaxe para escrever um lambda é:parâmetro lambda:expressão
Lambdas pode ter qualquer número de parâmetros, mas eles não são colocados entre chaves
Um lambda pode ter apenas 1 expressão em seu corpo de função, que é retornada por padrão.
No nível de bytecode, não há muita diferença entre como lambdas e funções regulares são tratadas pelo interpretador.
Lambdas suporta IIFE através desta sintaxe:(parâmetro lambda:expressão)(argumento)
Lambdas são comumente usados com os seguintes built-ins python:
Filtro:filtro (parâmetro lambda:expressão, sequência iterável)
Mapa:mapa (parâmetro lambda:expressão, sequências iteráveis)
Reduzir:reduzir (parâmetro lambda1, parâmetro2:expressão, sequência iterável)
Não escreva funções lambda complicadas em um ambiente de produção porque será difícil para os mantenedores de código.

[J5]Adicionei uma tabela, mas a explicação é necessária para entender as diferenças.

Exemplos de funções Python:chamada, recuo, argumentos e valores de retorno Função Python abs():exemplos de valor absoluto

python