Até o momento, definimos funções usando a palavra reservada def, seguida do nome da função e dos seus parâmetros, com em seguida sendo definido o bloco de código que a função irá desempenhar ao ser invocada:
In [1]: def soma_2(x):
...: return x + 2
...:
In [2]: soma_2(5)
Out[2]: 7
In [3]: soma_2(12)
Out[3]: 14
In [4]: def soma_dois_numeros(x, y):
...: return x + y
...:
In [5]: soma_dois_numeros(5, 7)
Out[5]: 12
In [6]: soma_dois_numeros(12, 25)
Out[6]: 37
As duas funções acima são funções nomeadas, pois, obviamente, têm nome.
Mas eu posso criar funções anônimas ou lambdas, que não recebem nome. O ideal é que funções lambda não tenham mais que uma linha de código. São bastante usadas para realizar códigos pequenos tais como os das duas funções acima. Entretanto, em programas grandes, usar muitas funções anônimas pode dificultar o debug (a correção de erros), pois a identificação das funções é mais difícil. Além de outros aspectos tais como lambdas não terem docstrings, que são strings usadas para explicar funções em funções nomeadas, etc. Mas isso é assunto pra depois.
Vamos definir duas funções lambda que fazem o mesmo que as duas funções acima fazem:
In [7]: anonima = lambda x: x + 2
In [8]: anonima
Out[8]: <function __main__.<lambda>(x)>
In [9]: anonima_2 = lambda x, y: x + y
In [10]: anonima_2
Out[10]: <function __main__.<lambda>(x, y)>
Notem que eu estou usando Python no console e não num script, então para não perder minha função eu precisei atribuir cada lambda function a uma variável. Chamando a variável (e não a função ainda) o Python me disse que ambas as funções são funções lambda dentro do meu __main__ (meu programa principal) e que a primeira recebe x como parâmetro e a segunda recebe x e y.
Chamando as duas funções agora:
In [11]: anonima(5)
Out[11]: 7
In [12]: anonima_2(5, 8)
Out[12]: 13
No entanto, ao atribuir a variáveis minhas funções anônimas acabei realizando uma má prática. O ideal é que a função lambda realize o que precisa realizar e depois não exista mais na memória do meu computador. Para funções que precisam ser reaproveitadas em meu código (imaginem um programa de uma calculadora, se eu preciso realizar somas várias vezes estou várias vezes chamando a função que realiza a soma, então nesse caso como estou reaproveitando a função de soma, esta função deve ser nomeada, seguindo as boas práticas).
Eu também posso definir a função lambda e já chamá-la na mesma linha de código, dessa forma:
In [15]: # Função lambda que multiplica 3 números
In [16]: (lambda x, y, z: x * y * z)(3, 5, 2)
Out[16]: 30
Sobre funções anônimas não tem muito segredo mais. São simples mas podem nos ajudar bastante a depender da nossa necessidade de uma função em um código.
