O que são funções Python Lambda e como você as usa?

Embora Python seja geralmente uma linguagem muito fácil de aprender e de fácil compreensão, isso não significa que não existam conceitos que possam ser um pouco mais desafiadores. Um desses conceitos é a função Lambda. Essas funções (também chamadas de funções anônimas) são semelhantes às funções que você mesmo constrói, mas não possuem nome.

Mas para que servem essas funções? Simplificando, você usa funções Lambda quando deseja escrever uma função que contém apenas expressões simples. Você pode ter uma expressão que precisa usar e que não precisa de uma função completa para funcionar corretamente ou que será usada apenas uma vez em seu código/aplicativo. É aí que as funções Lambda entram em ação.

As funções lambda consistem em apenas três partes: a palavra-chave (que é lambda), um espaço reservado para conter o valor a ser passado para a expressão e a expressão.

O formato de uma função Lambda é assim:

argumentos lambda: expressão

No exemplo acima, argumentos é o espaço reservado de valor.

Para ilustrar o quão útil uma função Lambda pode ser, considere que queremos escrever uma função que adicione 20 à variável a e imprima os resultados. Essa função pode ser assim:

x = lambda a : a + 20

Deixe-me explicar. O que estamos fazendo é definir a variável x com o Lambda a função que adiciona 20 à variável. Claro, temos que definir ao que podemos fazer dentro do imprimir() funcionar assim:

print(x10))

O código inteiro fica assim:

x = lambda a : a + 20
print(x10))

Se você executasse o código acima, o resultado seria 30. Por quê? Porque definimos nossa função Lambda de forma que ela adicione o valor 20 a a e então definimos a como 10.

20+10=30

Também podemos criar uma função Lambda que inclua duas variáveis ​​(digamos x e sim) e multiplicá-los juntos. Essa função Lambda ficaria assim:

a = lambda x, y : x * y

O que fizemos acima foi definido a com nossa nova função Lambda que então multiplica x*y. Podemos então definir x e sim em nossa função de impressão assim:

print(a(10, 50))

O código inteiro fica assim:

a = lambda x, y : x * y
print(a(10, 50))

Execute o código acima e o resultado será 500.

10 * 50 = 500

Organizado.

Vamos dar um passo adiante. Vamos adicionar várias variáveis ​​em uma função Lambda. Isso pode ser assim:

x = lambda a, b, c : a + b * c
print(x(10, 20, 30))

O resultado acima é 610.

Mas como podemos usar efetivamente as funções Lambda em nosso código? Por que não definimos uma função com uma função Lambda e depois chamamos essa função posteriormente no código? Para fazer isso, usaremos a instrução return, que é usada para finalizar a execução de uma chamada de função e retornar os resultados.

Vamos primeiro definir uma função Lambda que multiplica a vezes x é assim:

def myfunc(x):
    return lambda a : a * x

A seguir, triplicaremos o valor de myfunc(x) com a linha:

tripler = myfunc(3)

O que fizemos acima é chamado myfunc e definimos x como 3 para a função Lambda.

Nossa próxima linha fica assim:

print(tripler(10))

O que fizemos aqui está definido a (da nossa função Lambda) como 10, então temos efetivamente 10 vezes 3. O resultado (como esperado) será 30.

Vamos comparar a função Lambda com uma função padrão (para que você possa ver quão eficaz ela pode ser). Considere isto:

def a(x):
     return x * 10

print(a(3))

Se executarmos o procedimento acima, será impresso 30.

Mas como isso funcionaria como uma função Lambda? Assim:

a = lambda x : x * 10
print(a(3))

O código acima imprimiria os mesmos resultados, mas só tivemos que usar 2 linhas de código.

Claro, se quiséssemos criar uma função que fosse usada continuamente em nosso código, não optaríamos por uma função Lambda. Mas para aquelas funções que serão usadas apenas uma vez, Lambda é a melhor opção. Por que isso acontece? Porque nossas funções Lambda não possuem nomes e, sem nome, não podem ser chamadas posteriormente.

Usando funções Lambda com listas

Você também pode usar funções Lambda com listas. Isto é conseguido usando o filtro() função, que usa uma função e uma lista de argumentos e facilita a filtragem de objetos da sequência que a função retorna como verdadeira. Digamos que você queira retornar apenas os números ímpares de uma lista. Podemos fazer isso com a função Lambda:

x : (x % 2 !=0)

O que isso faz? Simples. Com o operador % ele retorna o resto quando o primeiro operando é dividido pelo segundo e então != significa que não é igual. Essa função retornará False se x não é par.

Nossa lista será:

lista = (1, 3, 6, 9, 11, 16, 21, 24, 30, 31)

Em seguida, definimos odd_out com nossa função Lambda assim:

odd_out = list(filter(lambda x : (x % 2 != 0), lista))

Podemos então imprimir os resultados com:

print(odd_out)

O código inteiro fica assim:

lista = (1, 3, 6, 9, 11, 16, 21, 24, 30, 31)

odd_out = list(filter(lambda x : (x % 2 != 0), lista))

print(odd_out)

Se executarmos o código acima, obteremos a seguinte saída:

(1, 3, 9, 11, 21, 31)

Somente os números ímpares são impressos.

E esta, meus amigos, é a sua introdução às funções Lambda em Python. Essas pequenas cantigas podem ser muito úteis e até mesmo manter seu código um pouco mais limpo.

A postagem O que são funções Python Lambda e como usá-las? apareceu primeiro em The New Stack.