Python Funções Lambda com EXEMPLOS

In 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 só pode conter 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.

Sintaxe e exemplos

A sintaxe formal para escrever uma função lambda é fornecida abaixo:

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.

Entretanto, observe que não usamos colchetes em torno dos parâmetros como fazemos com funções regulares. 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á o resultado:

3

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. x e y 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 expressão única. 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? Vejamos o código para entender melhor.

Explicação do código

1. Aqui, definimos um corda que você passará como parâmetro para o lambda.
2. 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 voltar o objeto de função e o local da 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 está entre colchetes? Vamos entender isso agora.

Explicação do código

1. Aqui está a mesma string que definimos no exemplo anterior.
2. Nesta parte, estamos definindo um lambda e chamando-o imediatamente, passando a string como argumento. Isso é algo chamado 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, o resultado deverá ser algo assim.

Saída:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Explicação do código

1. Uma função chamada guru que recebe outra função como primeiro parâmetro e quaisquer outros argumentos que a seguem.
2. print_one é uma função simples que imprime o parâmetro passado e o retorna.
3. impressora_dois é semelhante a impressora_one, mas sem a instrução return.
4. Nesta parte, chamamos a função guru e passamos as funções de impressora e uma string como parâmetros.
5. 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 mapa(), reduzir(), e filtro() in Python.

Usando lambdas com Python embutidos

As funções lambda fornecem uma maneira elegante e poderosa de executar operações usando métodos integrados em Python. É possível porque lambdas podem ser invocadas imediatamente e passadas como argumento para essas funções.

IIFE em Python Lambda

IIFE é um anagrama para execução da função invocada imediatamente. Isso significa que uma função lambda pode ser chamada assim que for definida. Vamos entender isso com um exemplo; acenda 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 de invocar lambdas imediatamente permite que você os use dentro de funções como map() e reduzir(). É útil porque você pode não querer usar essas funções novamente.

lambdas no 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, nos

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á o resultado:

[10, 8, 7, 5, 11]

Explicação do código:

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

2. Aqui, declaramos uma variável chamada filtered_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 verdadeiro 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:

1. Uma função que define a operação a ser executada nos elementos
2. 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:

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

lambdas em redução()

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

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

Passo 2) Salve este resultado

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

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

Também leva dois parâmetros:

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

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

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

Aqui está o resultado:

120

Explicação do código:

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

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

Como você verá na próxima seção, lambdas são tratadas da mesma forma que funções regulares no nível do intérprete. De certa forma, você poderia dizer que lambdas fornecem 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á-las. 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 como Python suporta um paradigma (ou estilo) de programação conhecido como programação funcional.

Permite fornecer uma função como parâmetro para outra função (por exemplo, em 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 descriptografá-lo. Se você estiver criando expressões complexas de uma linha, seria uma prática muito superior definir uma função adequada. Como prática recomendada, lembre-se de que código simples é sempre melhor que código complexo.

Lambdas vs. funções regulares

Como afirmado 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 só podem ter uma expressão em seu corpo.

Funções regulares podem ter múltiplas expressões e instruções em seu corpo.

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

Funções regulares devem ter nome e assinatura.

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

Funções que precisam retornar valor devem incluir uma instrução return.

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. Conseqüentemente, 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 seria 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 nós chamada isto. Uma função lambda não contém uma instrução return porque ela terá apenas uma única expressão que é sempre retornada por padrão. Você nem precisa atribuir uma lambda, pois ela pode ser imediatamente invocada (veja a próxima seção). Como você verá no exemplo a seguir, as lambdas se tornam particularmente poderosas quando as usamos com Pythonfunções integradas do.

No entanto, você ainda deve 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 definida em Python é tratada como uma função normal pelo intérprete.

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 por 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 nome (ou seja, identificador).
• Cada 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 podem ter qualquer número de parâmetros, mas não estão entre colchetes
• Um lambda pode ter apenas 1 expressão no corpo da função, que é retornada por padrão.
• No nível do bytecode, não há muita diferença entre como lambdas e funções regulares são tratadas pelo interpretador.
• Lambdas suportam IIFE através desta sintaxe: (parâmetro lambda: expressão)(argumento)
• Lambdas são comumente usados ​​com os seguintes python integrados:
• 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.

Este código é editável. Clique em Executar para executar