Um guia para funções do Python Lambda, com exemplos

Este artigo apresenta as funções lambda do Python e como escrevê-las e usá-las.

Embora o Python seja uma linguagem de programação orientada a objetos, as funções lambda são úteis quando você está fazendo vários tipos de programação funcional.

Nota: este artigo assumirá que você já entende de programação Python e como usar uma função regular. Também supõe-se que você tenha o Python 3.8 ou superior instalado em seu dispositivo.

Explicando as funções do Python Lambda

Em Python, as funções podem receber um ou mais argumentos posicionais ou de palavras-chave, uma lista de variáveis ​​de argumentos, uma lista de variáveis ​​de argumentos de palavras-chave e assim por diante. Eles podem ser passados ​​para uma função de ordem superior e retornados como saída. Funções regulares podem ter várias expressões e várias instruções. Eles também sempre têm um nome.

Um Python função lambda é simplesmente uma função anônima. Também poderia ser chamado de sem nome função. As funções normais do Python são definidas pelo def palavra-chave. As funções lambda em Python são geralmente compostas pelo lambda palavra-chave, qualquer número de argumentos e uma expressão.

Nota: os termos funções lambda, expressões lambdae formas lambda podem ser usados ​​alternadamente, dependendo da linguagem de programação ou do programador.

As funções lambda são usadas principalmente como one-liners. Eles são usados ​​com muita frequência em funções de ordem superior, como map() e filter(). Isso ocorre porque funções anônimas são passadas como argumentos para funções de ordem superior, o que não é feito apenas na programação Python.

Uma função lambda também é muito útil para lidar com a compreensão de listas em Python — com várias opções para usar expressões lambda do Python para essa finalidade.

Lambdas são ótimos quando usados ​​para renderização condicional em estruturas de interface do usuário como Tkinter, wxPython, Kivy etc. interação do usuário.

Coisas para entender antes de mergulhar nas funções do Python Lambda

Como Python é uma linguagem de programação orientada a objetos, tudo é um objeto. Classes Python, instâncias de classe, módulos e funções são todos tratados como objetos.

Um objeto de função pode ser atribuído a uma variável.

Não é incomum atribuir variáveis ​​a funções regulares em Python. Esse comportamento também pode ser aplicado a funções lambda. Isso ocorre porque eles são objetos de função, mesmo que não tenham nome:

def greet(name):
    return f'Hello {name}'

greetings = greet
greetings('Clint')
>>>>
Hello Clint

Funções de ordem superior como map(), filter() e reduce()

É provável que você precise usar uma função lambda em funções internas, como filter() e map()e também com reduce() — que é importado do módulo functools em Python, porque não é uma função integrada. Por padrão, funções de ordem superior são funções que recebem outras funções como argumentos.

Como visto nos exemplos de código abaixo, as funções normais podem ser substituídas por lambdas, passadas como argumentos para qualquer uma dessas funções de ordem superior:

names = ['Clint', 'Lisa', 'Asake', 'Ada']

greet_all = list(map(greet, names))
print(greet_all)
>>>>
['Hello Clint', 'Hello Lisa', 'Hello Asake', 'Hello Ada']

numbers = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
def multiples_of_three(x):
        return x % 3 == 0

print(list(filter(multiples_of_three, numbers)))
>>>>
[12, 15, 18]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def add_numbers(x, y):
        return x * y

print(reduce(add_numbers, numbers))
>>>>
55

A diferença entre uma declaração e uma expressão

Um ponto comum de confusão entre os desenvolvedores é diferenciar entre uma declaração e uma expressão na programação.

UMA declaração é qualquer pedaço de código que faz algo ou executa uma ação – como if ou while condições.

Um expressão é feito de uma combinação de variáveis, valores e operadores e avalia um novo valor.

Essa distinção é importante à medida que exploramos o assunto das funções lambda em Python. Uma expressão como a abaixo retorna um valor:

square_of_three = 3 ** 2
print(square_of_three)
>>>>
9

Uma declaração se parece com isso:

for i in range(len(numbers), 0, -1):
        if i % 2 == 1:
                print(i)
        else:
                print('even')
>>>>
even 9 even 7 even 5 even 3 even 1

Como usar funções do Python Lambda

O guia de estilo do Python estipula que toda função lambda deve começar com a palavra-chave lambda (diferentemente das funções normais, que começam com o def palavra-chave). A sintaxe para uma função lambda geralmente é assim:

lambda arguments : expression

As funções do Lambda podem receber qualquer número de argumentos posicionais, argumentos de palavras-chave ou ambos, seguidos por dois pontos e apenas uma expressão. Não pode haver mais de uma expressão, pois ela é sintaticamente restrita. Vamos examinar um exemplo de uma expressão lambda abaixo:

add_number = lambda x, y : x + y
print(add_number(10, 4))
>>>>
14

No exemplo acima, a expressão lambda é atribuída à variável add_number. Uma chamada de função é feita passando argumentos, que são avaliados como 14.

Vejamos outro exemplo abaixo:

discounted_price = lambda price, discount = 0.1, vat = 0.02 : price * (1 - discount) * (1 + vat)

print(discounted_price(1000, vat=0.04, discount=0.3))
>>>>
728.0

Como visto acima, a função lambda é avaliada como 728,0. Uma combinação de argumentos posicionais e de palavras-chave é usada na função lambda do Python. Ao usar argumentos posicionais, não podemos alterar a ordem descrita na definição da função. No entanto, podemos colocar argumentos de palavras-chave em qualquer posição somente após os argumentos posicionais.

As funções lambda são sempre executadas como expressões de função imediatamente invocadas (IIFEs) em JavaScript. Isso é usado principalmente com um interpretador Python, conforme mostrado no exemplo a seguir:

print((lambda x, y: x - y)(45, 18))
>>>>
27

O objeto de função lambda é colocado entre parênteses e outro par de parênteses segue de perto com os argumentos passados. Como um IIFE, a expressão é avaliada e a função retorna um valor atribuído à variável.

As funções lambda do Python também podem ser executadas em uma compreensão de lista. Uma compreensão de lista sempre tem uma expressão de saída, que é substituída por uma função lambda. aqui estão alguns exemplos:

my_list = [(lambda x: x * 2)(x) for x in range(10) if x % 2 == 0]
print(my_list)
>>>>
[0, 4, 8, 12, 16]

value = [(lambda x: x % 2 and 'odd' or 'even')(x) for x in my_list] 
print(value)
>>>>
['even', 'even', 'even', 'even', 'even']

As funções lambda podem ser usadas ao escrever expressões ternárias em Python. UMA expressão ternária emite um resultado com base em uma determinada condição. Confira os exemplos abaixo:

test_condition1 = lambda x: x / 5 if x > 10 else x + 5
print(test_condition1(9))
>>>>
14

test_condition2 = lambda x: f'{x} is even' if x % 2 == 0 else (lambda x: f'{x} is odd')(x)

print(test_condition2(9))
>>>>
9 is odd

Funções lambda dentro de funções de ordem superior

O conceito de funções de ordem superior é popular em Python, assim como em outras linguagens. São funções que aceitam outras funções como argumentos e também retornam funções como saída.

Em Python, uma função de ordem superior recebe dois argumentos: uma função e um iterável. O argumento da função é aplicado a cada item no objeto iterável. Como podemos passar uma função como argumento para uma função de ordem superior, podemos igualmente passar uma função lambda.

Aqui estão alguns exemplos de uma função lambda usada com o map() função:

square_of_numbers = list(map(lambda x: x ** 2, range(10)))

print(square_of_numbers)
>>>>
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

strings = ['Nigeria', 'Ghana', 'Niger', 'Kenya', 'Ethiopia', 'South Africa', 'Tanzania', 'Egypt', 'Morocco', 'Uganda']

length_of_strings = list(map(lambda x: len(x), strings))

print(length_of_strings)
>>>>
[7, 5, 5, 5, 8, 12, 8, 5, 7, 6]

Aqui estão algumas funções lambda usadas com o filter() função:

length_of_strings_above_five = list(filter(lambda x: len(x) > 5, strings))

print(length_of_strings_above_five)
>>>>
['Nigeria', 'Ethiopia', 'South Africa', 'Tanzania', 'Morocco', 'Uganda']

fruits_numbers_alphanumerics = ['apple', '123', 'python3', '4567', 'mango', 'orange', 'web3', 'banana', '890']

fruits = list(filter(lambda x: x.isalpha(), fruits_numbers_alphanumerics))

numbers = list(filter(lambda x: x.isnumeric(), fruits_numbers_alphanumerics))

print(fruits)
print(numbers)
>>>>
['apple', 'mango', 'orange', 'banana']
['123', '4567', '890']

Aqui estão algumas funções lambda usadas com o reduce() função:

values = [13, 6, 12, 23, 15, 31, 16, 21]
max_value = reduce(lambda x,y: x if (x > y) else y, values)
print(max_value)
>>>>
31

nums = [1, 2, 3, 4, 5, 6]
multiplication_of_nums = reduce(lambda x,y: x*y, nums)

print(multiplication_of_nums)
>>>>
720

Conclusão

Embora os lambdas do Python possam reduzir significativamente o número de linhas de código que você escreve, eles devem ser usados ​​com moderação e somente quando necessário. A legibilidade do seu código deve ser priorizada sobre a concisão. Para um código mais legível, sempre use uma função normal onde for adequado sobre funções lambda, conforme recomendado pelo Guia de Estilo do Python.

Lambdas pode ser muito útil com expressões ternárias do Python, mas, novamente, tente não sacrificar a legibilidade. As funções lambda realmente se destacam quando funções de ordem superior estão sendo usadas.

Resumindo:

• Lambdas Python são bons para escrever funções de uma linha.
• Eles também são usados ​​para IIFEs (expressão de função invocada imediatamente).
• Lambdas não deve ser usado quando há várias expressões, pois torna o código ilegível.
• Python é uma linguagem de programação orientada a objetos, mas lambdas são uma boa maneira de explorar a programação funcional em Python.

Conteúdo Relacionado: