Funções Lambda em Python: Um guia para iniciantes

As funções Lambda em Python são ferramentas poderosas e concisas para criar pequenas funções anônimas na hora. Elas são perfeitas pra simplificar tarefas de curto prazo, otimizar o código com funções de ordem superior como map, filter ou sorted e reduzir a desorganização ao definir lógica temporária ou descartável. Eles também oferecem uma solução elegante para melhorar a legibilidade do código em cenários simples. Este artigo vai falar sobre o que são funções lambda, suas características e como usá-las de forma eficaz.

Neste guia, vamos dar um guia completo sobre funções lambda em Python, falando sobre como elas funcionam, sintaxe e como elas se comparam às funções padrão, com exemplos simples pra ilustrar os conceitos principais. Vamos explorar casos de uso comuns, como usar funções lambda dentro de paradigmas de programação funcional e sua eficiência em relação às funções padrão. Exemplos práticos e melhores práticas estão incluídos para te ajudar a incorporar funções lambda de forma eficaz em seu Python. programação Python.

O que é uma função Lambda em Python?

As funções Lambda são diferentes das funções Python padrão em vários pontos importantes. São expressões anônimas, ou seja, não têm nome, a menos que sejam explicitamente atribuídas a uma variável. Elas também são mais curtas e definidas em uma única linha, sem precisar de uma instrução return. Isso faz com que sejam ideais para operações simples e únicas e para uso como argumentos em linha em funções de ordem superior, como map, filter e sorted.

Aqui está um exemplo de uma função lambda que soma dois números:

fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xe508b8>

Como funcionam as funções lambda

Como essa função lambda funciona? Pra entender isso, vamos comparar com uma função Python padrão.

# Example: add two numbers using standard Python function
def add_numbers(x, y):
    return x + y

Essa função padrão é bem simples. A palavra-chave def define a função, que recebe dois argumentos, x e y. Ele calcula a soma de x e y e mostra o resultado.

Agora, vamos ver como nossa função lambda faz a mesma coisa.

# Example: add two numbers using a lambda function
fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xbfb968>

A palavra-chave lambda significa que estamos definindo uma função lambda, eliminando a necessidade da palavra-chave def. Depois dessa palavra-chave lambda, aparecem os argumentos de entrada x e y. Depois do dois pontos, a gente coloca a expressão cujo resultado vai ser devolvido, x + y.

Escrevendo funções Lambda em Python: Exemplos

Pra te ajudar a entender os conceitos que vimos até agora, vamos dar uma olhada em alguns exemplos de como as funções Lambda funcionam em Python. 

Guia passo a passo para escrever funções lambda

As funções Lambda são ideais para criar funções curtas e diretas, sem complicações extras. 

Por exemplo, digamos que você queira ver se um número inteiro diferente de zero é par. Você poderia escrever uma função Python padrão, mas a mesma funcionalidade pode ser alcançada com uma função lambda concisa de uma linha atribuída a uma variável: is_even = lambda x: x % 2 == 0. 

Aqui, a função lambda no lado direito da atribuição recebe uma entrada x e devolve True se x for par (ou seja, se o resto da divisão por 2 for 0). 

Essa função lambda é então atribuída à variável is_even, permitindo que ela seja chamada como uma função normal. Por exemplo, is_even(5) (retorna False) e is_even(678432) (retorna True).

As funções Lambda também são ótimas para definir fórmulas simples. Por exemplo, pra converter Celsius pra Fahrenheit, você pode usar uma função lambda: c_to_f = lambda c: (c * 9/5) + 32. Depois, você chama a função como qualquer outra função: c_to_f(0).

Casos de uso comuns para funções lambda

As funções Lambda são frequentemente usadas na programação funcional, principalmente com funções como map() e filter(), que pegam outras funções como argumentos para processar elementos em uma coleção. Vamos ver como usar uma função lambda com um filter(). Aqui está um trecho de código:

# Use filter with lambda function
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # print the list of the filter object to see the result

# [2, 4, 6, 8]

Neste código, começamos definindo um conjunto de numbers. Depois, vamos criar uma função lambda pra ver se um número é par. A função filter aplica essa função lambda ao conjunto numbers. Depois, imprimimos a lista de números pares identificados pela função filter.

Da mesma forma, podemos usar a função map para aplicar um lambda a uma coleção de elementos. No exemplo abaixo, calculamos os comprimentos das strings em uma lista mapeando a função len() para cada elemento.

# Use map with lambda function
fruits = ['apple', 'banana', 'cherry']
lengths = list(map(lambda x: len(x), fruits))
print(lengths)

# [5, 6, 6]

As funções Lambda também são usadas com a função sorted(), que organiza os elementos de uma coleção para devolver uma nova coleção. No exemplo a seguir (sem lambda), usamos a função sorted() para ordenar uma lista de números.

numbers = [1, 10, -1, 3, -10, 5]
sorted_stuff = sorted(numbers)
print(sorted_stuff)

# [-10, -1, 1, 3, 5, 10]

Digamos que a gente queira organizar a lista de números pelo valor absoluto. Como a gente conseguiria isso? A função sorted() tem um argumento key que nos deixa personalizar a ordem de classificação usando uma função lambda.

# Sort according to absolute value
sorted_numbers_absolute = sorted(numbers, key=lambda x: abs(x))
print(sorted_numbers_absolute)

# [1, -1, 3, 5, 10, -10]

Outro caso de uso para sort() com uma função lambda é classificar uma lista de tuplas com base em um elemento específico, digamos, o segundo.

# Sort a list of tuples by the second element
data = [(1, 3), (2, 1), (4, 2)]
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data)

# [(2, 1), (4, 2), (1, 3)]

Neste trecho de código, a gente define data como uma lista de tuplas. Depois, usamos a função sorted() com o parâmetro key, onde uma função lambda pega o segundo elemento de cada tupla para classificar.

As funções Lambda são mais rápidas em Python?

Em Python, as funções lambda não são inerentemente mais rápidas do que as funções padrão, pois ambas são compiladas em bytecode semelhante. Mas, eles podem diminuir um pouco a sobrecarga nos casos em que definir uma função completa adicionaria código repetitivo desnecessário.

Aqui estão alguns casos de teste comparando funções lambda com funções Python padrão. O código foi rodado no meu laptop, um MacBook Pro com chip Apple M1 Pro, 16 GB de memória, rodando macOS Sequoia 15.2.

As funções lambda podem ser usadas inline como funções anônimas quando passadas diretamente para funções de ordem superior, como map(), filter() ou sorted(). Isso evita a necessidade de definir e referenciar uma função nomeada separada, reduzindo tanto o código padrão quanto a sobrecarga de pesquisa.

import time

numbers = list(range(1, 1000000))

# Standard function
def double_standard(x):
    return x * 2

start = time.time()
map(double_standard, numbers)
print(time.time() - start)

# Lambda function
double_lambda = map(lambda x: x * 2, numbers)

start = time.time()
list(map(lambda x: x * 2, numbers))
print(time.time() - start)

# 3.504753112792969e-05
# 2.384185791015625e-05

As funções Lambda são ideais para uso único ou temporário, pois eliminam a necessidade de um bloco formal de def, economizando tempo e espaço. No bloco de código a seguir, comparamos o desempenho de uma função padrão com o de uma função lambda. Classificamos um dicionário com um milhão de elementos, onde as chaves são códigos aleatórios de duas letras e os valores são números inteiros aleatórios.

import random
import string

# Generate a dictionary with elements of the form 'XX': number.
NUMBER_ITEMS = 1000000
items = {
    ''.join(random.choices(string.ascii_uppercase, k=2)): random.randint(1, 100)
    for _ in range(NUMBER_ITEMS)
}

# Standard function (extra definition step)
def sort_standard(item):
    return item[1]

print('Standard')
start = time.time()
sorted_items_standard = sorted(items, key=sort_standard)
print(time.time() - start)
print(sorted_items_standard[:5])
print()

# Lambda function
print('Lambda')
start = time.time()
sorted_items_lambda = sorted(items, key=lambda x: x[1])
print(time.time() - start)
print(sorted_items_lambda[:5])
print()

# Standard
# 0.00011610984802246094
# ['OA', 'VA', 'XA', 'IA', 'BA']
# Lambda
# 0.00011014938354492188
# ['OA', 'VA', 'XA', 'IA', 'BA']

Funções Lambda em Python: Exemplos e prática

Vamos ver mais alguns exemplos práticos pra mostrar como as funções Lambda funcionam no Python. 

Exemplos práticos

As funções Lambda costumam ser usadas com métodos Python embutidos. Por exemplo, vamos ver como usar reduce() para aplicar uma função binária definida pelo usuário de forma cumulativa aos itens de uma sequência.

# Example: Use lambda function with built-in Python method reduce.
from functools import reduce

numbers = [5, -6, 2, 7]
total = reduce(lambda x, y: x + y, numbers)
print(f'The sum of the numbers is {total}.')

# The sum of the numbers is 8.

Parecido com filter() ou map() acima, reduce() aplica uma função, aqui dada por um lambda, a um conjunto de elementos.

Agora, vamos ver outra função embutida do Python, o zip(). A função zip junta elementos correspondentes de várias listas em tuplas. Por exemplo, o resultado de zip(['a', 'b', 'c'], [1, 2, 3]) é [('a', 1), ('b', 2), ('c', 3)].

# Example: Use lambda function with built-in Python method zip.
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Using zip and a lambda function to multiply corresponding elements
result = list(map(lambda x: x[0] * x[1], zip(list1, list2)))

print(f'The result of multiplying corresponding elements is {result}.')

# The result of multiplying corresponding elements is [4, 10, 18].

Esse código calcula o produto dos elementos correspondentes de duas listas, list1 e list2. Ele usa zip() para emparelhar elementos das listas em tuplas, depois aplica uma função lambda com map() para multiplicar os elementos emparelhados e, por fim, converte o resultado em uma lista.

Exemplo real: transformação de dados

Imagina que você tem uma banca de frutas e quer calcular o valor total das vendas de cada tipo de fruta.

Primeiro, vamos criar alguns registros de vendas. Então, usamos map() com uma função lambda para calcular total_sales multiplicando o preço e a quantidade de cada item no dicionário sales_data. A sintaxe ` **record ` descompacta o dicionário original, garantindo que todas as suas chaves e valores sejam mantidos no novo dicionário. Por fim, imprimimos cada registro dos dados transformados.

# Sample data: list of dictionaries representing sales records
sales_data = [
	{'fruit': 'peaches', 'price': 1.41, 'quantity': 3},
	{'fruit': 'pears', 'price': 1.21, 'quantity': 2},
	{'fruit': 'mangoes', 'price': 0.56, 'quantity': 3},
]

# Using a lambda function to calculate total sales for each record
transformed_data = list(
	map(
		lambda entry: {**entry, 'total_sales': round(entry['price'] * entry['quantity'], 2)},
		sales_data
	)
)

# Print the transformed data
for record in transformed_data:
	print(record)

# {'fruit': 'peaches', 'price': 1.41, 'quantity': 3, 'total_sales': 4.23}
# {'fruit': 'pears', 'price': 1.21, 'quantity': 2, 'total_sales': 2.42}
# {'fruit': 'mangoes', 'price': 0.56, 'quantity': 3, 'total_sales': 1.68}

Problemas simples para os usuários resolverem com funções lambda

Se você quiser praticar o uso de funções lambda, aqui estão alguns problemas para tentar resolver.

• Dado um número, calcule o seu quadrado.
• Dados dois números, descubra qual é o maior.
• Dado um número, veja se ele é ímpar.
• Dada uma lista de números inteiros positivos, separe todos os números ímpares.
• Ordena uma lista de tuplas de 3 elementos usando o terceiro elemento de cada uma.
• Pega o domínio de um endereço de e-mail. Por exemplo, dado user@example.com, extraia example.com.

Erros comuns relacionados ao lambda

Vamos dar uma olhada em alguns erros comuns que os programadores cometem com lambdas e algumas soluções.

1. O primeiro erro é usar uma função lambda quando não é apropriado. É importante lembrar que as funções lambda são feitas pra tarefas curtas e simples, não pra lidar com lógica complexa. Por exemplo, o trecho de código a seguir não é um caso de uso ideal para uma função lambda.

# Complex logic in a lambda
result = lambda x: (x ** 2 + x - 1) / (x + 1 if x != -1 else 1)
print(result(5))  # Hard to understand

# 4.833333333333333

Nesse caso, é melhor usar só uma função padrão do Python.

def complex_logic(x):
    if x == -1:
        return x ** 2 + x - 1
    return (x ** 2 + x - 1) / (x + 1)
print(complex_logic(5))

# 4.833333333333333

2. Outro erro fácil de cometer é confundir a sintaxe. Por exemplo, esquecer a palavra-chave lambda vai dar erro. Outro erro comum de sintaxe é deixar de fora o(s) argumento(s) de entrada:

# Forgetting the required arguments
numbers = [1, 2, 3, 4]
squared = map(lambda: x ** 2, numbers)  # <-- Where is the input argument? Error: lambda missing argument

A solução é incluir o argumento de entrada:

squared = map(lambda x: x ** 2, numbers)

Uma boa maneira de detectar erros como esse é incluir casos de teste informais e simples durante o desenvolvimento.

print(list(squared))

3. Outro erro a evitar é não incluir lógica para casos extremos. Por exemplo, esse código falha quando y é 0. A solução é incluir uma simples instrução if para detectar o caso problemático ou envolver o código em um bloco de exceção.

# Dividing without handling zero
divide = lambda x, y: x / y

safe_divide = lambda x, y: x / y if y != 0 else "undefined"
print(safe_divide(5, 0))

# undefined

4. Um problema mais sutil é esquecer de converter o iterador em uma lista ao enviar os resultados. Por exemplo, a função map() retorna um objeto map, não uma lista. Para acessar os resultados, converta o objeto map em um objeto list.

# Forgetting to convert to a list
numbers = [1, 2, 3]
squared = map(lambda x: x ** 2, numbers)
print(squared)  # <-- squared is the map, not the result

# <map object at 0x106d2b0>

print(list(squared))  # list(squared) gives the result

# [1, 4, 9]

Estratégias de depuração Python Lambda

Então, como fazemos para depurar lambdas? Aqui estão algumas possibilidades.

• Quebre o lambda. Transforme temporariamente em uma função nomeada para fins de depuração.
• Use instruções de impressão para mostrar valores intermediários em funções de ordem superior, como map() ou filter().
• Testar casos extremos. Teste com valores extremos, inválidos ou limites para detectar possíveis erros.

Um truque útil para imprimir etapas intermediárias é incluir uma instrução print dentro de uma tupla junto com o resultado. A saída desejada pode então ser passada para a função de ordem superior, indexando a tupla na posição 1.

Aqui vai um exemplo:

numbers = [1, 2, 3, 4, 5]

# Lambda function with print to debug intermediate values
filtered_numbers = filter(lambda x: (print(f'Checking: {x} -> {x >= 3}'), x >= 3)[1], numbers)

# Converting filter object to list to force evaluation
print(list(filtered_numbers))

# Checking: 1 -> False
# Checking: 2 -> False
# Checking: 3 -> True
# Checking: 4 -> True
# Checking: 5 -> True
# [3, 4, 5]

Neste código, usa-se um truque para imprimir etapas intermediárias enquanto filtra uma lista de números. A função lambda em filter inclui uma tupla: o primeiro elemento é uma instrução print que registra o número atual e se ele satisfaz a condição (x >= 3), e o segundo elemento é a própria condição.

O comando [1] no final do lambda garante que a condição (x >= 3) seja devolvida à função filter, ao mesmo tempo que permite que a instrução print seja executada para depuração.

Converter o objeto filter em uma lista força a avaliação de todos os elementos, ativando as instruções print para cada número. Essa abordagem ajuda a depurar a lógica enquanto mantém a funcionalidade da operação de filtragem.

Melhores práticas para usar funções Lambda

As melhores práticas para usar funções lambda envolvem entender quando elas são apropriadas e quando devem ser evitadas.

Quando usar funções Lambda

• Lógica curta e simples. Ideal para operações curtas que não precisam de uma definição completa da função.
• Funções de ordem superior. Funcionam bem como argumentos para funções de ordem superior, como map(), filter() ou sorted().
• Funções temporárias (descartáveis). É útil quando uma função é necessária apenas uma vez e defini-la com um def e sobrecarregaria desnecessariamente o código.
• Legibilidade melhorada. Ótimo pra tarefas simples, onde usar uma função lambda deixa o código compacto e fácil de entender.

Quando evitar funções Lambda

• lógico complexo ou multilinha. As lambdas são limitadas a uma única expressão e podem rapidamente se tornar ilegíveis para operações mais complexas.
• Funções reutilizáveis ou nomeadas. Se a função precisar ser reutilizada ou se beneficiar de um nome descritivo, uma função padrão def é mais apropriada.
• Depuração ou documentação. As funções Lambda não têm como incluir docstrings e podem ser mais difíceis de depurar em comparação com as funções nomeadas.

Para melhorar a legibilidade e a manutenção ao usar lambdas, siga estas práticas recomendadas:

• Use nomes que sejam fáceis de entender para maior clareza.
• Mantenha as coisas simples: Os lambdas devem, idealmente, caber em uma linha e representar uma lógica direta.
• Limite de aninhamento: Evite usar funções lambda dentro de outras funções lambda ou estruturas de dados complexas, a menos que seja necessário.
• Prefira a legibilidade à concisão: Se usar um lambda prejudica a legibilidade, é melhor definir uma função nomeada.

Conclusão

As funções lambda do Python são uma ferramenta poderosa para escrever funções concisas e anônimas. Eles são ótimos em situações que precisam de operações curtas, temporárias ou inline, principalmente quando usados com funções de ordem superior, como map, filter ou sorted. 

Mas, é bom usar com cuidado, porque uma lógica mais complexa combina melhor com funções padrão definidas com def. Ao entender seus pontos fortes, limitações e melhores práticas, você pode usar as funções lambda de forma eficaz para escrever código Python limpo, eficiente e fácil de manter.

Pra saber mais sobre as funções do Python, dá uma olhada nos recursos do DataCamp.

• Funções Python: Como chamar e escrever funções
• Curso sobre como escrever funções em Python
• Fundamentos de dados Python
• Fundamentos da Programação em Python
• Curso de Python intermediário para desenvolvedores