Python Lambda

O Que É uma Função Lambda?

Uma função lambda é uma função pequena e anônima definida com a palavra-chave lambda em vez de def. Anônima significa que ela não possui um nome vinculado — embora você possa atribuí-la a uma variável se precisar reutilizá-la. As funções lambda são uma forma concisa de escrever funções simples de expressão única inline, sem a sobrecarga de uma definição de função completa.

As funções lambda são especialmente úteis como callbacks de curta duração passados para funções de ordem superior como map(), filter() e sorted().

Sintaxe

lambda arguments: expression

• arguments — zero ou mais parâmetros separados por vírgula (igual à lista de parâmetros de uma função def, incluindo valores padrão).
• expression — uma única expressão cujo valor é retornado automaticamente. Instruções (como blocos if/else, laços for ou return) não são permitidas dentro do corpo de uma lambda.

Uma comparação válida lado a lado:

def square(x):
    return x ** 2

square_lambda = lambda x: x ** 2

print(square(5))        # Output: 25
print(square_lambda(5)) # Output: 25

Exemplos Básicos

# No arguments
greet = lambda: "Hello, World!"
print(greet())  # Output: Hello, World!

# One argument
square = lambda x: x ** 2
print(square(5))  # Output: 25

# Two arguments
add = lambda x, y: x + y
print(add(10, 20))  # Output: 30

# Default argument value
greet_name = lambda name="World": "Hello, " + name + "!"
print(greet_name())          # Output: Hello, World!
print(greet_name("Alice"))   # Output: Hello, Alice!

Lógica Condicional em uma Lambda

Como as lambdas devem ser uma única expressão, você não pode usar uma instrução if/else. No entanto, é possível usar uma expressão ternária (condicional):

classify = lambda n: "positive" if n > 0 else ("zero" if n == 0 else "negative")

print(classify(5))   # Output: positive
print(classify(0))   # Output: zero
print(classify(-3))  # Output: negative

Expressões ternárias profundamente aninhadas prejudicam rapidamente a legibilidade — mude para uma função def regular assim que a lógica crescer.

Usando Lambda com map()

map(function, iterable) aplica uma função a cada elemento de um iterável e retorna um objeto map. Lambda é uma opção natural para o argumento de função.

nums = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, nums))
print(doubled)  # Output: [2, 4, 6, 8, 10]

A compreensão de lista equivalente é frequentemente preferida por legibilidade:

doubled = [x * 2 for x in nums]  # same result

Veja List Comprehension para mais detalhes sobre essa abordagem.

Usando Lambda com filter()

filter(function, iterable) mantém apenas os elementos para os quais a função retorna True.

nums = [1, 2, 3, 4, 5]
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens)  # Output: [2, 4]

Usando Lambda com sorted()

O parâmetro key de sorted() (e list.sort()) aceita um callable que retorna o valor de comparação para cada elemento. Lambda torna as chaves de ordenação pontuais mais concisas.

# Sort strings by length
words = ["banana", "apple", "cherry", "date"]
by_length = sorted(words, key=lambda s: len(s))
print(by_length)  # Output: ['date', 'apple', 'banana', 'cherry']

# Sort a list of tuples by the second element
pairs = [(1, "b"), (2, "a"), (3, "c")]
by_second = sorted(pairs, key=lambda p: p[1])
print(by_second)  # Output: [(2, 'a'), (1, 'b'), (3, 'c')]

Para mais informações sobre ordenação de listas, veja Sort Lists.

Lambda Imediatamente Invocada

Uma lambda pode ser chamada no momento em que é definida, envolvendo-a entre parênteses e acrescentando os argumentos:

result = (lambda x, y: x + y)(3, 7)
print(result)  # Output: 10

Esse padrão é incomum em código de produção, mas ocasionalmente útil em scripts pontuais ou testes rápidos.

Lambda Armazenada em uma Estrutura de Dados

Como uma lambda é um objeto de primeira classe em Python, você pode armazenar lambdas em listas ou dicionários para criar tabelas de despacho simples:

ops = {
    "add": lambda x, y: x + y,
    "sub": lambda x, y: x - y,
    "mul": lambda x, y: x * y,
}

print(ops["add"](3, 4))   # Output: 7
print(ops["sub"](10, 3))  # Output: 7
print(ops["mul"](2, 6))   # Output: 12

Lambda vs. def — Quando Usar Cada Um

O guia de estilo PEP 8 recomenda não atribuir uma lambda a um nome de variável quando um def seria mais claro. Por exemplo, prefira def add(x, y): return x + y em vez de add = lambda x, y: x + y quando a função vive no escopo do módulo.

Limitações Principais

• Apenas uma expressão. Sem atribuições, laços ou lógica de múltiplas linhas.
• Sem instruções. print() é uma chamada de função (válida), mas assert, raise ou return são instruções e não podem aparecer no corpo de uma lambda.
• Sem anotações. Dicas de tipo (x: int) não são permitidas em listas de parâmetros de lambda.
• Mais difícil de depurar. Rastreamentos de pilha mostram <lambda> em vez de um nome de função significativo.
• Não pode ser serializada com pickle. O pickle padrão não consegue serializar objetos lambda — relevante ao usar multiprocessamento.

Relação com Closures e Decoradores

Assim como uma função regular definida com def, uma lambda fecha sobre variáveis em seu escopo envolvente:

def make_multiplier(n):
    return lambda x: x * n   # 'n' is captured from the enclosing scope

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))  # Output: 10
print(triple(5))  # Output: 15

Para uma análise mais aprofundada de como os closures funcionam em Python, veja Python Closures. As funções lambda também aparecem frequentemente dentro de Python Decorators como wrappers leves. Para uma visão completa das definições de funções, veja Python Functions.

Prática