Funções lambda e prática do módulo

O que é uma função lambda

Às vezes você precisa de uma função tão pequena e tão pontual que dar um nome a ela com def parece burocracia. Para esses casos existe a lambda: uma função anônima, escrita em uma única linha, com a forma lambda parâmetros: expressão. Ela recebe parâmetros como qualquer função, mas o corpo é uma só expressão, cujo valor é devolvido automaticamente, sem a palavra return. É a mesma ideia de uma função comum, comprimida ao essencial.

dobro = lambda x: x * 2
print(dobro(5))  # 10

# Equivale a esta funcao com def:
def dobro_def(x):
    return x * 2
print(dobro_def(5))  # 10

# Lambda com dois parametros
soma = lambda a, b: a + b
print(soma(3, 4))  # 7

A lambda e a função com def fazem o mesmo. A lambda só é mais curta e anônima.

Guardar uma lambda em uma variável, como no exemplo, serve para mostrar a equivalência, mas quase nunca é o melhor uso. Se você vai dar um nome a ela de qualquer forma, é mais claro usar def. A lambda brilha mesmo quando é usada de passagem, sem nome, entregue direto para outra função que espera uma pequena regra. O caso mais comum é dizer a uma função de ordenação como comparar os itens.

Quando lambda ajuda de verdade

O lugar natural da lambda é como argumento de funções que recebem outra função, chamadas de ordem superior. O exemplo clássico é sorted com o parâmetro key: você entrega uma lambda que extrai, de cada item, o valor que serve de critério. Ordenar uma lista de pessoas pela idade, ou de produtos pelo preço, fica limpo e direto. A lambda existe só naquele momento, faz o seu trabalho e some.

pessoas = [
    {"nome": "Ana", "idade": 30},
    {"nome": "Bruno", "idade": 25},
    {"nome": "Carla", "idade": 41},
]

# Ordena pela idade usando lambda como criterio
por_idade = sorted(pessoas, key=lambda p: p["idade"])
for p in por_idade:
    print(p["nome"], p["idade"])
# Bruno 25
# Ana 30
# Carla 41

sorted recebe uma lambda que diz qual valor de cada item usar para ordenar.

A regra prática é curta: lambda para lógica trivial e de uma linha, usada de passagem; def para tudo que tem nome, corpo maior ou vai se repetir. A lambda não é uma versão melhor da função; é uma conveniência para casos minúsculos. Usá-la fora disso costuma piorar a leitura, e legibilidade é o valor que este módulo inteiro defende. Sabendo quando não usar, você já usa lambda bem.

Prática: funções flexíveis de verdade

Para fechar o módulo, vamos juntar o que você aprendeu em uma prática. A ideia é criar funções flexíveis, que aceitam quantidade variável de valores e têm padrões convenientes. Primeiro, uma função de estatísticas que recebe quantos números você quiser com *args e devolve um resumo. Depois, um formatador de moeda com parâmetros padrão, chamado com argumentos nomeados. Abra o Playground do curso e digite os dois blocos abaixo, mudando os valores para experimentar.

def estatisticas(*numeros):
    if not numeros:
        return {"quantidade": 0, "soma": 0, "media": 0}
    return {
        "quantidade": len(numeros),
        "soma": sum(numeros),
        "media": sum(numeros) / len(numeros),
    }

print(estatisticas(10, 20, 30))
# {'quantidade': 3, 'soma': 60, 'media': 20.0}
print(estatisticas(7))
# {'quantidade': 1, 'soma': 7, 'media': 7.0}
print(estatisticas())
# {'quantidade': 0, 'soma': 0, 'media': 0}

*numeros aceita de zero a muitos valores; o if trata o caso sem números com segurança.

def formatar_moeda(valor, moeda="BRL", casas=2, prefixo=True):
    numero = f"{valor:.{casas}f}"
    if prefixo:
        return f"{moeda} {numero}"
    return f"{numero} {moeda}"

print(formatar_moeda(1990.5))
# BRL 1990.50
print(formatar_moeda(1990.5, moeda="USD"))
# USD 1990.50
print(formatar_moeda(1990.5, casas=0, prefixo=False))
# 1991 BRL

Parâmetros padrão para o caso comum, argumentos nomeados para ajustar só o que muda.

Repare como as duas funções aplicam o módulo inteiro. Em estatisticas, o *numeros deixa a função aberta a qualquer quantidade de valores, e o if not numeros evita a divisão por zero quando nada é passado. Em formatar_moeda, os parâmetros padrão cobrem o caso mais comum (Real, duas casas, prefixo na frente) e os argumentos nomeados deixam a chamada clara quando você quer mudar só um detalhe. Nada de padrão mutável, tudo legível. É exatamente o tipo de função reaproveitável que separa o intermediário do básico.