Funções Lambda em Python

O que são funções Lambda?

Em Python, funções são objetos: podem ser atribuídas a variáveis, podem ser retornadas de outras funções, armazenadas em listas ou dictos e passadas como parâmetros para outras funções. Considere, por exemplo, o map() função integrada. Sua sintaxe é map(function, iterable) e é usado para aplicar facilmente function a cada elemento de iterable.

map() realmente retorna um iterator objeto. Na prática, lançamos o resultado como um list, tuple, set, dict, etc, o que for mais conveniente.

Suponha que você queira elevar ao quadrado todos os termos de uma lista usando o map() função. Para fazer isso, definiremos um square() função e usá-la como parâmetro para map():

my_list = [1,2,3,4,5]
def square(x):
    return x**2

my_modified_list = list(map(square, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

No entanto, se o único uso do nosso square() função é criar esta lista, é mais limpo usar um lambda função:

my_list = [1,2,3,4,5]
my_modified_list = list(map(lambda x: x**2, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

Em Python, lambda funções são funções anônimas que levam seu nome e sintaxe do livro de Alonzo Church Cálculo lambda. A sintaxe deles é:

lambda x_1,..., x_n : expression(x_1, ..., x_n)

Isso cria uma função anônima que recebe como entrada as variáveis x_1, ..., x_n e retorna o avaliado expression(x_1, ..., x_n).

A finalidade do lambda funções deve ser usada como parâmetro para funções que aceitam funções como parâmetro, como fizemos com map() acima. Python permite que você atribua um lambda função para uma variável, mas o Guia de estilo PEP 8 desaconselha. Se você deseja atribuir uma função simples a uma variável, é melhor fazê-lo como uma definição de uma linha. Isso garante que o objeto resultante seja nomeado corretamente, melhorando a legibilidade do rastreamento:

anonymous_square = lambda x : x**2
​
def named_square(x): return x**2
​
print(anonymous_square.__name__)
print(named_square.__name__)


a = anonymous_square
b = named_square
print(a.__name__)
print(b.__name__)

Por que usar funções Lambda?

Após o último parágrafo, você deve estar se perguntando por que deseja usar um lambda função. Afinal, tudo o que pode ser feito com um lambda função poderia ser feita com uma função nomeada.

A resposta para isso é que lambda funções propósito é viver dentro de expressões maiores que representam um cálculo. Uma maneira de pensar sobre isso é por analogia com variáveis ​​e valores. Considere o seguinte código:

x = 2

A variável x é um espaço reservado (ou um nome) para o número inteiro 2. Por exemplo, ligar print(x) e print(2) fornece exatamente a mesma saída. No caso de funções:

def square(x): return x**2

A função square() é um espaço reservado para o cálculo da quadratura de um número. Este cálculo pode ser escrito de uma forma anônima como lambda x: x**2.

Seguindo esta digressão filosófica, vejamos alguns exemplos de aplicações para lambda funções.

Usando Lambda com a função sorted()

A sorted() função classifica um iterável. Ele aceita uma função como sua key argumento, e o resultado da função aplicada a cada elemento do iterável é usado para ordenar os elementos.

Isto é perfeitamente adequado para um lambda função: definindo o key parâmetro com um lambda função, podemos classificar por qualquer tipo de atributo dos elementos. Por exemplo, podemos classificar uma lista de nomes por sobrenome:

name_list = ['Grace Hopper', 'Ada Lovelace', 'Emmy Noether', 'Marie Curie']
​
sorted_by_surname = sorted(name_list, key = lambda x: x.split()[1])
​
print(sorted_by_surname)

['Marie Curie', 'Grace Hopper', 'Ada Lovelace', 'Emmy Noether']

Usando Lambda com função ‘filter()’

A filter() função tem a seguinte sintaxe: filter(function, iterable) e produz os elementos de iterable que avalia function(element) como verdadeiro (é semelhante a um WHERE cláusula em SQL). Podemos usar lambda funcionam como parâmetros para filter() para selecionar elementos de um iterável.

Considere o seguinte exemplo:

num_list = list(range(0,100))
​
multiples_of_15= filter(lambda x: (x % 3 == 0) and (x % 5 == 0), num_list)
​
print(list(multiples_of_15))

[0, 15, 30, 45, 60, 75, 90]

filter() aplica o lambda função lambda x: (x % 3 == 0) and (x % 5 == 0) para cada elemento de range(0,100), e retorna um filter objeto. Acessamos os elementos lançando-os como list.

Usando Lambda com a função map()

Nosso último exemplo é algo que vimos na introdução – o map() função. o map() a sintaxe da função é: map(function, iterable) e map() aplica function para cada elemento de iterable, retornando um map objeto que pode ser acessado lançando para um list.

Vimos como isso pode ser aplicado a listas, mas poderia ser aplicado a dictos usando o dict.items() método:

my_data = {'Mary':1, 'Alice':2, 'Bob':0}
map_obj = map(lambda x: f'{x[0]} had {x[1]} little lamb', my_data.items())
print(', '.join((map_obj)))

Mary had 1 little lamb, Alice had 2 little lamb, Bob had 0 little lamb

ou para uma string:

my_string = 'abcdefg'
''.join(map(lambda x: chr(ord(x)+2),my_string))

'cdefghi'

Podemos usar map() funcionar de maneiras engenhosas – um exemplo é aplicar muitas funções à mesma entrada.

Por exemplo, suponha que você esteja criando uma API que receba uma string de texto e queira aplicar uma lista de funções a ela.

Cada função extrai alguma característica do texto. As características que queremos extrair são o número de palavras, a segunda palavra e a quarta letra da quarta palavra:

def number_of_words(text):
  return len(text.split())
​
def second_word(text):
  return text.split()[1]
​
def fourth_letter_of_fourth_word(text):
  return text.split()[3][3]
​
function_list = [number_of_words, second_word, fourth_letter_of_fourth_word]
​
my_text = 'Mary had a little lamb'
map_obj = map(lambda f: f(my_text), function_list)
​
feature_list = list(map_obj)
​
print(feature_list)

[5, 'had', 't']

Conclusão

Neste guia, exploramos a funcionalidade de lambda funções em Python. Nós vimos isso lambda funções são funções anônimas a serem usadas como parâmetro de função embutido para outras funções. Vimos alguns casos de uso e também quando não usá-los.

Ao programar, é importante ter em mente a citação de Donald Knuth: “Os programas são feitos para serem lidos por humanos e apenas incidentalmente para serem executados por computadores”. Com isso em mente, lambda funções são uma ferramenta útil para simplificar nosso código, mas devem ser usadas com sabedoria.