Python Funções Lambda com EXEMPLOS

Em que consiste a função Lambda Python?

A 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.

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.

Observe, no entanto, que não usamos parênteses em torno dos parâmetros como fazemos com funções regulares. A última parte (expressão) é qualquer valor válido. Python Expressão que opera sobre os parâmetros fornecidos à 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))

Code Explicação

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 de uma função lambda. Agora, vamos tentar imprimir uma função lambda e ver o resultado. Novamente, abra seu arquivo. 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 analisar o código para entender melhor.

Code Explicação:

1. Aqui, definimos um corda que você passará como parâmetro para a função lambda.

2. Declaramos uma função 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 a própria função lambda retorna um objeto de função. Neste exemplo, a função lambda não está sendo... chamado pela função de impressão, mas é simplesmente voltar O objeto da função e o endereço de memória onde ela está armazenada. É isso 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 programa pressionando F5; você verá uma saída como esta.

Saída:

some kind of a useless lambda

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

Code Explicação:

1. Aqui está a mesma string que definimos no exemplo anterior.

2. Nesta parte, definimos uma função lambda e a chamamos imediatamente, passando a string como argumento. Isso é chamado de IIFE (Função Executiva Inversa de Instância), e você aprenderá mais sobre isso nas próximas seções deste tutorial.

Exemplo 4

Vejamos um exemplo final para entender como as funções lambda e as 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 deverá ser semelhante a esta.

Saída:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Explicação:

1. Uma função chamada guru que recebe outra função como primeiro parâmetro e quaisquer outros argumentos subsequentes.

2. printer_one é uma função simples que imprime o parâmetro que lhe é passado e o retorna.

3. A impressora_dois é semelhante à impressora_um, mas sem a instrução de retorno.

4. Nesta parte, estamos chamando a função guru e passando as funções de impressão e uma string como parâmetros.

5. Esta é a sintaxe para realizar o quarto passo (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. Significa que uma função lambda pode ser chamada assim que for 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 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 baseiam-se em algumas restrições predefinidas. 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]

Code Explicação:

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(), ela também recebe 2 parâmetros:

1. Uma função que define a operação a ser realizada 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]

Code Explicação:

1. Aqui, definimos uma lista chamada sequências que contém alguns números.

2. Declaramos uma variável chamada filtered_result que armazenará os valores mapeados.

3. Uma função lambda que percorre 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

Code Explicação:

1. Importe a função reduce 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 que percorre cada elemento da lista. Ela retornará o produto desse número conforme o resultado anterior.

5. Imprima o resultado retornado pela função reduce.

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 ​​por Python desenvolvedores 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.

Isso permite que você forneça uma função como parâmetro para outra função (por exemplo, em map, filter, 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 mencionado anteriormente, lambdas são simplesmente funções que não possuem um identificador associado. Em outras palavras, são funções sem nome (daí o termo "anônimas"). Aqui está uma tabela para ilustrar a diferença entre lambdas e funções regulares. Python.

lambda x : x + x

def (x) :
return x + x 

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 Uma função lambda não contém uma instrução `return` porque terá apenas uma única expressão, que é sempre retornada por padrão. Você nem precisa atribuir um valor a uma função lambda, pois ela pode ser invocada imediatamente (veja a seção anterior). Como você verá, as funções lambda 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.

No nível do bytecode, as duas definições são tratadas da mesma forma pelo Python interpretador. 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.

Perguntas Frequentes