Funções Python Lambda com EXEMPLOS

Índice:

Anonim

O que é a função Lambda em Python?

Uma Função Lambda na programação Python é 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á a palavra-chave lambda (da mesma forma que 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 ​​associadas), 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 uma expressão. Além disso, um lambda é escrito em uma única linha de código e também pode ser chamado 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 no filtro ()
  • lambdas no mapa ()
  • lambdas em reduzir ()
  • Por que (e por que não) usar funções lambda?
  • Lambdas vs. funções regulares

Sintaxe e exemplos

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

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 ou poucos parâmetros precisar.

No entanto, 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 para a 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 + yprint (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 ú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 de lambda. Vamos agora tentar imprimir um lambda e ver o resultado. Novamente, abra seu IDLE e digite o seguinte:

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

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

Resultado:

 at 0x00000185C3BF81E0>

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

Explicação do código

  1. Aqui, definimos uma string 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 retornando 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 #2x="some kind of a useless lambda"(lambda x : print(x))(x)

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

Resultado:

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 um argumento. Isso é algo 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 FUNCTIONdef guru( funct, *args ):funct( *args )def printer_one( arg ):return print (arg)def printer_two( arg ):print(arg)#CALL A REGULAR FUNCTIONguru( printer_one, 'printer 1 REGULAR CALL' )guru( printer_two, 'printer 2 REGULAR CALL \n' )#CALL A REGULAR FUNCTION THRU A LAMBDAguru(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.

Resultado:

impressora 1 CHAMADA REGULAR

impressora 2 CHAMADA REGULAR

impressora 1 LAMBDA CALL

impressora 2 LAMBDA CALL

Explicação do código

  1. Uma função chamada guru que recebe outra função como o primeiro parâmetro e quaisquer outros argumentos a seguir.
  2. printer_one é uma função simples que imprime o parâmetro passado a ela e o retorna.
  3. printer_two é semelhante a printer_one, mas sem a instrução return.
  4. Nesta parte, estamos chamando a função guru e passando as funções de impressora e uma string como parâmetros.
  5. Esta é a sintaxe para atingir 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 (), reduce () e filter () em Python.

Usando lambdas com Python integrado

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

IIFE em Python Lambda

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

 (lambda x: x + x)(2)

Aqui está o resultado e a explicação do código:

Essa capacidade de lambdas de serem chamados 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 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 alguma restrição pré-definida. Leva 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á o resultado:

[10, 8, 7, 5, 11]

Explicação do código:

1. No primeiro comando, 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 verdadeiro se for maior que 4.

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

lambdas no mapa ()

a função de mapa é usada para aplicar uma operação específica a cada elemento em uma sequência. 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))

Resultado:

 [100, 4, 64, 49, 25, 16, 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 filter_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 de mapa.

lambdas em reduzir ()

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

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

Etapa 2) Salve 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 leva dois parâmetros:

  1. Uma função que define a operação a ser realizada
  2. 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 reducesequences = [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 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 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 ​​por desenvolvedores de Python ao escrever lambdas.

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

Ele permite que você forneça uma função como um 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 Lambda?

Você nunca deve escrever funções lambda complicadas em um ambiente de produção. Será muito difícil para os programadores 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, você precisa se lembrar que um código simples é sempre melhor do que um 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 podem ter apenas uma expressão em seu corpo.

As 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 também são conhecidas como funções anônimas.

As funções regulares devem ter um nome e 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 return.

Explicação das diferenças?

A principal diferença entre um 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 + yprint (adder (1, 2))

Aqui, temos que definir um nome para a função que retorna o resultado quando a chamamos . 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 mesmo 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 integradas 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 definida 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 para bytecode. Agora, você não pode nomear uma função lambda porque ela é reservada 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).
  • Cada função lambda em Python tem 3 partes essenciais:
  • A palavra-chave lambda.
  • Os parâmetros (ou variáveis ​​associadas), 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 eles não são colocados entre colchetes
  • Um lambda pode ter apenas 1 expressão em seu corpo de função, que é retornado 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 por meio desta sintaxe: (parâmetro lambda: expressão) (argumento)
  • Lambdas são comumente usados ​​com os seguintes recursos integrados do 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 (lambda parâmetro1, 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 do código.

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