programa
Funções Lambda do Python: Um guia para iniciantes
As funções lambda em Python são ferramentas poderosas e concisas para a criação de funções pequenas e anônimas em tempo real. Elas são perfeitas para simplificar tarefas de curto prazo, otimizar o código com funções de ordem superior, como map
, filter
ou sorted
, e reduzir a desordem 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 explorará o que são funções lambda, suas características e como usá-las de forma eficaz.
Neste guia, forneceremos um guia completo sobre as funções lambda em Python, abordando sua mecânica, sintaxe e como elas se comparam às funções padrão, com exemplos simples para ilustrar os principais conceitos. Exploramos casos de uso comuns, como o uso de funções lambda em paradigmas de programação funcional e sua eficiência em relação às funções padrão. Exemplos práticos e práticas recomendadas estão incluídos para ajudar você a incorporar efetivamente as funções lambda em sua programação Python.
O que é uma função lambda em Python?
As funções lambda diferem das funções padrão do Python de várias maneiras importantes. Elas são expressões anônimas, o que significa que não têm nome, a menos que sejam explicitamente atribuídas a uma variável. Eles também são mais concisos e definidos em uma única linha, sem a necessidade de uma declaração return
. Isso os torna 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 adiciona dois números:
lambda x, y: x + y
(x, y)>
Como funcionam as funções lambda
Como essa função lambda funciona? Para você entender, vamos compará-la a uma função padrão do Python.
# Example: add two numbers using standard Python function
def add_numbers(x, y):
return x + y
Essa função padrão é 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 retorna o resultado.
Agora, vamos ver como nossa função lambda realiza a mesma tarefa.
# Example: add two numbers using a lambda function
lambda x, y: x + y
(x, y)>
A palavra-chave lambda
significa que estamos definindo uma função lambda, o que elimina a necessidade da palavra-chave def
. Após essa palavra-chave lambda
, os argumentos de entrada x
e y
são listados. Após os dois pontos, especificamos a expressão cujo resultado será retornado, x + y
.
Escrevendo funções Lambda em Python: Exemplos
Para ajudar você a se familiarizar com os conceitos que exploramos 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 a criação de funções curtas e diretas, sem complexidade adicional.
Por exemplo, suponha que você queira verificar se um determinado número inteiro diferente de zero é par. Você poderia escrever uma função padrão do Python, mas a mesma funcionalidade pode ser obtida 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 retorna True
se x
for par (ou seja, se o resto quando dividido 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, para converter Celsius em Fahrenheit, você pode usar uma função lambda: c_to_f = lambda c: (c * 9/5) + 32
. Em seguida, 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 em programação funcionalVocê pode usar as funções Lambda na programação funcional, especialmente com funções como map()
e filter()
, que recebem outras funções como argumentos para processar elementos em uma coleção. Vamos ver como usar uma função lambda com 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
. Em seguida, criamos uma função lambda para verificar se um número é par. A função filter
aplica essa função lambda ao conjunto numbers
. Em seguida, 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 cadeias de caracteres 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]
A função Lambda também é usada com a função sorted()
, que classifica os elementos de uma coleção para retornar uma nova coleção. No exemplo a seguir (sem um lambda), usamos a função sorted()
para classificar 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]
Suponha que você queira classificar a lista de números por valor absoluto. Como conseguiríamos isso? A função sorted()
inclui um argumento key
que nos permite personalizar a ordem de classificação fornecendo 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, por exemplo, 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, definimos data
como uma lista de tuplas. Em seguida, usamos a função sorted()
com o parâmetro key
, em que uma função lambda extrai o segundo elemento de cada tupla para classificação.
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. No entanto, elas podem reduzir um pouco a sobrecarga nos casos em que a definição de uma função completa acrescentaria um padrão desnecessário.
Aqui estão alguns casos de teste que comparam as funções lambda com as funções padrão do Python. O código foi executado em meu laptop, um MacBook Pro com um chip Apple M1 Pro, 16 GB de memória, executando o macOS Sequoia 15.2.
As funções lambda podem ser usadas em linha 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 fazer referência a uma função nomeada separada, reduzindo o código boilerplate e 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 def
formal, 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, em que 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 do Python: Exemplos e práticas
Vamos analisar alguns exemplos mais práticos para mostrar como as funções Lambda funcionam em Python.
Exemplos práticos
As funções lambda são frequentemente usadas com métodos Python incorporados. Por exemplo, vamos usar o site 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.
Semelhante a filter()
ou map()
acima, reduce()
aplica uma função, aqui dada por um lambda, a um conjunto de elementos.
Agora, vamos explorar outra função integrada do Python, zip()
. A função zip
emparelha 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}.')
O resultado da multiplicação dos elementos correspondentes é [4, 10, 18].
Esse código calcula o produto dos elementos correspondentes de duas listas, list1
e list2
. Ele usa zip()
para emparelhar os 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 do mundo real: transformação de dados
Vamos imaginar que você tenha uma banca de frutas e queira calcular o valor total das vendas de cada tipo de fruta.
Primeiro, vamos criar alguns registros de vendas.
# 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},
]
Agora, 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 preservados no novo dicionário.
# 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
)
)
Por fim, imprimimos cada registro dos dados transformados.
# 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.
- Dado um número, encontre seu quadrado.
- Se você tiver dois números, encontre o maior deles.
- Dado um número, verifique se ele é ímpar.
- Dada uma lista de números inteiros positivos, filtre todos os números ímpares.
- Classifica uma lista de tuplas de 3 elementos usando seus terceiros elementos.
- Extraia o domínio de um endereço de e-mail. Por exemplo, dado
user@example.com
, extraiaexample.com
.
Erros comuns relacionados a lambda
Vamos dar uma olhada em alguns erros comuns que os programadores cometem com lambdas e algumas correções.
1. O primeiro erro é usar uma função lambda quando ela é inadequada. É importante lembrar que as funções lambda são projetadas para tarefas curtas e simples, não para 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 você usar apenas 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 simples que você pode cometer é confundir a sintaxe. Por exemplo, se você esquecer a palavra-chave lambda
, isso resultará em um erro. Outro erro comum de sintaxe é omitir 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 correçã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 simples e informais durante o desenvolvimento.
print(list(squared))
[1, 4, 9, 16]
3. Outro erro que você deve observar é não incluir lógica para casos extremos. Por exemplo, esse código falha quando y
é 0.
# Dividing without handling zero
divide = lambda x, y: x / y
A solução é incluir uma instrução if
simples para capturar o caso problemático ou envolver o código em um bloco de exceção.
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 gerar os resultados. Por exemplo, a função map()
retorna um objeto map
, não uma lista.
# 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
Para acessar os resultados, converta o objeto map
em um list
.
print(list(squared)) # list(squared) gives the result
[1, 4, 9]
Estratégias de depuração do Python Lambda
Então, como podemos fazer a depuração de lambdas? Aqui estão algumas possibilidades.
- Desmembrar o lambda. Converta-o temporariamente em uma função nomeada para fins de depuração.
- Use instruções de impressão Para exibir valores intermediários em funções de ordem superior, como
map()
oufilter()
. - Teste os casos de borda. Teste com valores extremos, inválidos ou de limite 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 está 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]
Nesse código, um truque é usado para imprimir etapas intermediárias durante a filtragem de 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 [1]
no final do lambda garante que a condição (x >= 3
) seja retornada à função filter
e permite que a instrução print
seja executada para depuração.
A conversão do objeto filter
em uma lista força a avaliação de todos os elementos, acionando as instruções print
para cada número. Essa abordagem ajuda a depurar a lógica e, ao mesmo tempo, mantém a funcionalidade da operação de filtragem.
Práticas recomendadas para o uso de funções Lambda
As práticas recomendadas para o uso de funções lambda envolvem a compreensão de quando elas são apropriadas e quando devem ser evitadas.
Quando usar as funções Lambda
- Lógica curta e simples. Ideal para operações concisas que não exigem uma definição completa da função.
- Funções de ordem superior. Funcionam efetivamente como argumentos para funções de ordem superior, como
map()
,filter()
, ousorted()
. - Funções temporárias (descartáveis). Útil quando uma função é necessária apenas uma vez, e defini-la com
def
sobrecarregaria desnecessariamente o código. - Melhoria da legibilidade. Adequado para tarefas simples em que o uso de uma função lambda mantém o código compacto e fácil de seguir.
Quando você deve evitar as funções Lambda
- Lógica complexa ou de várias linhas. Os lambdas são limitados 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 do
def
será mais adequada. - Depuração ou documentação. As funções lambda não têm a capacidade de 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 descritivos para maior clareza.
- Mantenha a simplicidade: O ideal é que os lambdas caibam em uma linha e representem 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 o uso de um lambda sacrificar a legibilidade, é melhor você 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 se destacam em cenários que exigem operações curtas, temporárias ou em linha, especialmente quando usados com funções de ordem superior, como map
, filter
ou sorted
.
No entanto, elas devem ser usadas criteriosamente, pois a lógica mais complexa é mais adequada às funções padrão definidas com def
. Ao compreender seus pontos fortes, limitações e práticas recomendadas, você pode aproveitar efetivamente as funções lambda para escrever um código Python limpo, eficiente e de fácil manutenção.
Para saber mais sobre as funções Python, confira os recursos do DataCamp.
Perguntas frequentes sobre as funções Lambda do Python
Por que usar uma função lambda?
Elas são perfeitas para simplificar tarefas de curto prazo, otimizar o código com funções de ordem superior, como map
, filter
ou sorted
, e reduzir a desordem ao definir lógica temporária ou descartável.
Quando devo usar funções lambda?
As funções lambda são apropriadas para: lógica curta e simples, adequada para linhas únicas, como argumentos de função para funções de ordem superior, como map()
ou filter()
, e para funções temporárias que são necessárias apenas uma vez.
Quando devo evitar as funções lambda?
As funções lambda podem não ser a melhor opção para lógica complexa ou funções que exijam documentação (como docstrings).

Mark Pedigo, PhD, é um ilustre cientista de dados com experiência em ciência de dados de saúde, programação e educação. Com doutorado em matemática, bacharelado em ciência da computação e certificado profissional em IA, Mark combina conhecimento técnico com solução prática de problemas. Sua carreira inclui funções em detecção de fraudes, previsão de mortalidade infantil e previsão financeira, além de contribuições para o software de estimativa de custos da NASA. Como educador, ele lecionou no DataCamp e na Washington University em St. Louis e foi mentor de programadores juniores. Em seu tempo livre, Mark curte o ar livre de Minnesota com sua esposa Mandy e seu cachorro Harley e toca piano jazz.
Principais cursos da DataCamp
curso
Writing Functions in Python
curso
Introduction to Functions in Python
tutorial
Tutorial de lambda em Python

DataCamp Team
3 min
tutorial
Tutorial e exemplos de funções e métodos de lista do Python
tutorial
Tutorial de funções Python
tutorial
Tutorial de compreensão de dicionário Python
tutorial
Função Python Print()
tutorial
Desenvolvimento de back-end em Python: Um guia completo para iniciantes

Oluseye Jeremiah
26 min