Lambda é uma função anônima de única expressão em Python.
Ela usa a palavra-chave lambda em vez de def.
Primeiramente, lambdas são ideais para operações curtas e simples.
Por exemplo, lambda x: x * 2 dobra um número.
Além disso, lambdas podem receber múltiplos argumentos.
A voz passiva é usada aqui: “a expressão é avaliada e retornada automaticamente”.
Quando utilizar funções lambda? Em funções de alta ordem.
Também para operações descartáveis que não precisam de nome.
Lambda é comum com map, filter e sorted.
Evite lambdas complexos que prejudicam a legibilidade.
Vamos explorar sintaxe, usos e limitações práticas.
Três subtítulos guiarão você pelo mundo das lambdas.
Ao final, você usará lambdas de forma elegante e eficiente.
Sintaxe básica e usos simples
Lambda tem a forma lambda args: expressão.
Ela não usa return explicitamente na expressão.
Pode receber zero, um ou vários argumentos.
Quando usar lambdas simples? Em transformações rápidas.
Por exemplo, ordenar listas ou mapear valores.
A voz passiva é aplicada: “os argumentos são separados por vírgulas”.
Exemplo de sintaxe básica:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
# Lambda básica dobro = lambda x: x * 2 soma = lambda a, b: a + b quadrado = lambda x: x ** 2 print("=== Lambda Básica ===") print(f"dobro(5): {dobro(5)}") print(f"soma(3, 7): {soma(3, 7)}") print(f"quadrado(4): {quadrado(4)}") # Lambda sem argumentos saudacao = lambda: "Olá, mundo!" print(f"saudacao(): {saudacao()}") # Lambda com valor padrão potencia = lambda base, exp=2: base ** exp print(f"potencia(3): {potencia(3)}") print(f"potencia(3, 4): {potencia(3, 4)}") # Lambda imediata (invocação direta) resultado = (lambda x, y: x * y)(4, 5) print(f"(lambda x,y: x*y)(4,5): {resultado}") # Comparação com função normal def funcao_normal(x): return x * 2 lambda_eq = lambda x: x * 2 print(f"\nFunção normal: {funcao_normal(10)}") print(f"Lambda: {lambda_eq(10)}") print(f"São iguais? {funcao_normal(10) == lambda_eq(10)}") |
Lambdas são concisas, mas não substituem funções complexas. Use-as apenas quando a expressão for realmente simples.
Lambda com map, filter e sorted
Lambda brilha em combinação com funções de alta ordem.
map aplica lambda a cada elemento da sequência.
filter usa lambda para selecionar elementos.
sorted usa lambda como chave de ordenação.
Quando usar essas combinações? Em pipelines de dados.
Elas são mais declarativas que loops tradicionais.
A voz passiva é aplicada: “os elementos são processados um a um”.
Exemplo prático:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
# Map com lambda numeros = [1, 2, 3, 4, 5] quadrados = list(map(lambda x: x ** 2, numeros)) cubos = list(map(lambda x: x ** 3, numeros)) print("=== Map com Lambda ===") print(f"Original: {numeros}") print(f"Quadrados: {quadrados}") print(f"Cubos: {cubos}") # Filter com lambda pares = list(filter(lambda x: x % 2 == 0, numeros)) maiores_que_3 = list(filter(lambda x: x > 3, numeros)) print(f"\n=== Filter com Lambda ===") print(f"Pares: {pares}") print(f"Maiores que 3: {maiores_que_3}") # Sorted com lambda pessoas = [ ("Ana", 25), ("Carlos", 35), ("Beatriz", 28), ("Daniel", 22) ] ordenado_por_idade = sorted(pessoas, key=lambda p: p[1]) ordenado_por_nome = sorted(pessoas, key=lambda p: p[0]) print(f"\n=== Sorted com Lambda ===") print(f"Original: {pessoas}") print(f"Por idade: {ordenado_por_idade}") print(f"Por nome: {ordenado_por_nome}") # Ordenação reversa ordenado_idade_decrescente = sorted(pessoas, key=lambda p: p[1], reverse=True) print(f"Por idade decrescente: {ordenado_idade_decrescente}") # Pipeline combinado resultado = list( map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numeros)) ) print(f"\nPipeline: quadrados dos pares: {resultado}") |
Lambdas tornam essas operações muito mais elegantes. Evite lambdas longos; prefira funções nomeadas nesses casos.
Limitações e boas práticas
Lambda só pode conter uma única expressão.
Não pode conter statements como if-else (após Python 3.10).
Não pode ter loops, atribuições ou return explícito.
Quando evitar lambda? Em lógica com múltiplas linhas.
Também quando a expressão fica difícil de ler.
A voz passiva é aplicada: “a legibilidade é sacrificada em lambdas longos”.
Exemplo de boas e más práticas:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
# Lambda com expressão condicional (ok) par_ou_impar = lambda x: "par" if x % 2 == 0 else "impar" print("=== Lambda com Condicional ===") print(f"par_ou_impar(4): {par_ou_impar(4)}") print(f"par_ou_impar(5): {par_ou_impar(5)}") # Lambda com múltiplas operações (ainda ok, mas cuidado) calculo = lambda a, b: (a + b) * (a - b) print(f"calculo(5, 3): {calculo(5, 3)}") # Exemplo RUIM: lambda muito complexo (evite!) # processar = lambda lista: [x for x in lista if x > 0] # List comprehension é melhor # Prefira função nomeada para isso # Comparação de legibilidade # Ruim (lambda complexo) valores = [-5, -2, 0, 3, 7, 10] filtro_ruim = list(filter(lambda x: x > 0 and x % 2 == 0, valores)) print(f"\n=== Boas Práticas ===") print(f"Lambda complexo (ruim): {filtro_ruim}") # Bom (função nomeada) def positivo_e_par(x): return x > 0 and x % 2 == 0 filtro_bom = list(filter(positivo_e_par, valores)) print(f"Função nomeada (bom): {filtro_bom}") # Lambda com múltiplos argumentos em sorted dados = [ {"nome": "Ana", "idade": 25, "salario": 3000}, {"nome": "Carlos", "idade": 35, "salario": 4500}, {"nome": "Beatriz", "idade": 28, "salario": 3200} ] # Ordenação por múltiplas chaves ordenado = sorted(dados, key=lambda x: (x["idade"], x["salario"])) print(f"\nOrdenado por idade e salário: {[(d['nome'], d['idade']) for d in ordenado]}") # Lambda em max e min pessoa_mais_velha = max(dados, key=lambda p: p["idade"]) pessoa_mais_nova = min(dados, key=lambda p: p["idade"]) print(f"Pessoa mais velha: {pessoa_mais_velha['nome']}") print(f"Pessoa mais nova: {pessoa_mais_nova['nome']}") # Lambda com reduce from functools import reduce produto = reduce(lambda a, b: a * b, numeros) print(f"\nProduto com reduce: {produto}") # Quando NÃO usar lambda - exemplo didático # Em vez disso: def calcular_imposto(preco, taxa=0.1): return preco * (1 + taxa) # Não faça: calcular_imposto = lambda preco, taxa=0.1: preco * (1 + taxa) print(f"Função nomeada: R${calcular_imposto(100):.2f}") |
Lambdas são ferramentas para simplicidade, não para tudo.
A fórmula da legibilidade de uma lambda:
\(L = \frac{1}{\text{número de operações}} \quad \text{(quanto menor, melhor)}\)
Use lambda para funções de uma linha sem efeitos colaterais.
Prefira funções nomeadas para lógica complexa.
Lambdas com map, filter e sorted são ideais.
Seu código será mais expressivo e funcional.