Você precisa classificar os produtos por preço. Escrever uma função nomeada separada apenas para dizer “usar o preço” parece muita cerimônia. Funções lambda do Python permitem definir aquele pequeno pedaço de lógica in-line, exatamente onde você o usa.

Lambdas são úteis, mas também fáceis de usar em excesso. Este guia mostra onde eles realmente ajudam e onde dificultam a leitura do código. Executamos todos os exemplos no Python 3.13 e a saída mostrada vem dessa execução.

O que é um lambda?

Um lambda é uma função sem nome, escrita com a palavra-chave lambda:

lambda arguments: expression

Recebe qualquer número de argumentos e retorna o valor de uma única expressão automaticamente. Não há palavra-chave return e nenhum corpo de declarações.

square = lambda x: x * x
print(square(4))                     # 16

print((lambda a, b=10: a + b)(5))    # 15

A segunda linha define um lambda com um argumento padrão e o chama imediatamente. Você raramente escreveria isso em código real, mas mostra que um lambda é um objeto de função comum.

lambda versus def

Esses dois produzem funções que se comportam da mesma forma:

square = lambda x: x * x

def square_def(x):
    return x * x

print(square(4), square_def(4))                 # 16 16
print(square.__name__, square_def.__name__)     # <lambda> square_def

Veja os nomes. Cada lambda é chamado apenas <lambda>, portanto, mensagens de erro e logs não podem dizer qual deles falhou. Esta é a principal razão pela qual guias de estilo como o PEP 8 recomendam um def sempre que você quiser dar um nome a uma função.

Classificando com chave: o melhor uso

Funções como sorted, min e max aceitam uma função key que decide o que comparar. É aqui que os lambdas brilham:

products = [("pen", 10), ("bag", 900), ("book", 250)]

sorted(products, key=lambda p: p[1])
# [('pen', 10), ('book', 250), ('bag', 900)]

max(products, key=lambda p: p[1])
# ('bag', 900)

Para classificar por vários itens, retorne uma tupla. Aqui, as pessoas são classificadas por idade, primeiro as mais velhas e depois por nome:

people = [{"name": "Asha", "age": 31}, {"name": "Ben", "age": 25},
          {"name": "Dev", "age": 31}]

[p["name"] for p in sorted(people, key=lambda p: (-p["age"], p["name"]))]
# ['Asha', 'Dev', 'Ben']

O sinal de menos inverte a ordem apenas do número. Às vezes você nem precisa de um lambda, porque uma função existente já faz o trabalho. Compare a classificação padrão com uma que não diferencia maiúsculas de minúsculas:

names = ["Asha", "ben", "Chitra", "dev"]

sorted(names)                  # ['Asha', 'Chitra', 'ben', 'dev']
sorted(names, key=str.lower)   # ['Asha', 'ben', 'Chitra', 'dev']

O padrão coloca todas as palavras em maiúsculas primeiro. Passar str.lower corrige isso sem qualquer lambda. O módulo operator oferece ajudantes semelhantes, como itemgetter(1) para lambda p: p[1].

mapear e filtrar

map aplica uma função a cada item e filter mantém os itens para os quais retorna verdadeiro. Ambos funcionam com lambdas, mas compare cada um com uma compreensão de lista:

nums = [1, 2, 3, 4, 5, 6]

list(map(lambda n: n * 10, nums))      # [10, 20, 30, 40, 50, 60]
[n * 10 for n in nums]                 # [10, 20, 30, 40, 50, 60]

list(filter(lambda n: n % 2 == 0, nums))   # [2, 4, 6]
[n for n in nums if n % 2 == 0]            # [2, 4, 6]

Os resultados são idênticos e a maioria dos desenvolvedores Python acha a compreensão mais fácil de ler. Observe também que map e filter retornam iteradores preguiçosos, então você precisa de list() para ver os valores. Nosso guia para compreensão de listas em Python aborda esse estilo em profundidade. map ainda funciona bem com uma função nomeada existente, como em map(str.strip, lines).

reduzir

functools.reduce combina itens em um único valor, carregando um resultado contínuo:

from functools import reduce

reduce(lambda acc, n: acc + n, nums, 0)   # 21
sum(nums)                                 # 21

Para trabalhos comuns, como totais, use um recurso integrado como sum, max ou any. Mantenha reduce para casos mais raros e considere um loop simples se o lambda começar a parecer complicado.

Condições em um lambda

Você não pode usar uma instrução if em um lambda, mas pode usar uma expressão condicional:

label = lambda total: "large" if total >= 1000 else "small"

label(1200), label(300)
# ('large', 'small')

Uma condição é boa. Depois de começar a aninhá-los, os leitores terão que trabalhar duro, o que é um sinal claro para mudar para def com instruções if comuns.

Lambdas que retornam funções

Uma função pode criar e retornar um lambda que lembra um valor do seu entorno:

def multiplier(n):
    return lambda x: x * n

double = multiplier(2)
double(7)   # 14

Isso funciona por causa dos encerramentos, que nosso artigo sobre fechamento JavaScript explica em uma linguagem diferente. O functools.partial do Python oferece outra maneira de preencher previamente argumentos.

A armadilha da ligação tardia

Isso pega quase todo mundo eventualmente. Criamos três lambdas em um loop, esperando que cada um retornasse seu próprio número:

funcs = [lambda: i for i in range(3)]
[f() for f in funcs]

# [2, 2, 2]

Todos os três retornam 2. Um lambda não captura o valor de i quando é criado. Ele procura a variável quando ela é chamada, e então o loop termina, deixando i em 2. A solução usual é capturar o valor como um argumento padrão, já que os padrões são avaliados no momento da definição:

funcs = [lambda i=i: i for i in range(3)]
[f() for f in funcs]

# [0, 1, 2]

Isso não é exclusivo dos lambdas, pois def dentro de um loop se comporta da mesma maneira. Ele aparece com mais frequência com lambdas, porque eles são comumente criados em loops, como ao anexar retornos de chamada de botão.

Tabelas de consulta de pequenas funções

Lambdas se encaixam perfeitamente em um dicionário que mapeia nomes para pequenas operações:

ops = {
    "add": lambda a, b: a + b,
    "sub": lambda a, b: a - b,
}

ops["sub"](10, 3)   # 7

Isso pode substituir uma longa cadeia de if e elif. O guia dicionário Python cobre mais padrões de dicionário, e o módulo operator já fornece operator.add e operator.sub.

Limites de lambdas

• Apenas uma expressão. Sem atribuições com =, sem loops e sem try blocos.
• Sem declarações. A escrita lambda x: return x falha com SyntaxError, como nosso teste confirmou.
• Sem documentação ou dicas de tipo. Ferramentas e leitores recebem menos ajuda.
• Depuração mais difícil. Os erros apontam para <lambda> em vez de um nome útil.

Lambdas ainda podem gerar exceções, é claro. O tratamento deles funciona da mesma forma que para qualquer função, conforme abordado em Tratamento de exceções do Python.

Quando não usar um lambda

Esse último ponto é importante. Vale a pena testar a lógica que vale a pena reutilizar, e uma função nomeada é muito mais fácil de testar, como mostra nosso tutorial pytest.

Considerações finais

Um bom lambda é curto o suficiente para ser lido rapidamente e usado uma vez, geralmente como argumento. As chaves de classificação são o exemplo clássico. Para verificar seu próprio código, pesquise = lambda e transforme-os em funções nomeadas. Em seguida, observe qualquer map ou filter com um lambda e veja se uma compreensão é melhor.

Perguntas frequentes

Continue aprendendo