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 umiterator
objeto. Na prática, lançamos o resultado como umlist
,tuple
,set
,dict
, etc, o que for mais conveniente.
Suponha que você queira elevar ao quadrado todos os termos de uma lista usando omap()
função. Para fazer isso, definiremos umsquare()
função e usá-la como parâmetro paramap()
:
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'
Confira nosso guia prático e prático para aprender Git, com práticas recomendadas, padrões aceitos pelo setor e folha de dicas incluída. Pare de pesquisar comandos Git no Google e realmente aprender -lo!
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.