Funções Lambda no Python: o que é, sintaxe e exemplos

✅ Artigo atualizado em Setembro 2026 (Python 3.x) Nova resposta rápida, seções sobre lambda com sorted/max/min e com if else, tabela lambda vs def, erros comuns com traceback e 8 exercícios resolvidos. Todos os exemplos foram executados novamente.

1
2
3
4

(lambda x, y: x + y)(2, 3)          # 5

alunos = [('Ana', 8.5), ('Bruno', 6.0), ('Carla', 9.2)]
sorted(alunos, key=lambda a: a[1])  # [('Bruno', 6.0), ('Ana', 8.5), ('Carla', 9.2)]

Salve salve Pythonista!

Funções lambda são uma ferramenta elegante do Python que permite criar funções anônimas (sem nome) de forma concisa. São ideais para operações simples e únicas onde uma função completa seria excessiva.

Neste guia, você vai aprender:

• ✅ Sintaxe e criação de funções lambda
• ✅ Casos de uso reais (sort, filter, map, max/min)
• ✅ Lambda com if else
• ✅ Lambda vs funções normais (def)
• ✅ Quando usar e quando NÃO usar lambdas
• ✅ Erros comuns e exercícios resolvidos

Vá direto ao assunto…

• O que é lambda em Python
• Como criar Funções lambda
• Lambda com sorted, max e min (parâmetro key)
• Usando funções lambda com map, filter e reduce
• Lambda com if else
• Casos de Uso do Mundo Real
• Lambda vs Funções Normais (def)
• Erros comuns
• Exercícios resolvidos

O que é lambda em Python

O que é lambda? Em Python, lambda é a palavra-chave que cria uma função anônima: uma função pequena, sem nome, definida em uma única expressão e normalmente escrita no próprio lugar onde vai ser usada. O valor da expressão é retornado automaticamente. Pela documentação oficial do Python, lambdas são “açúcar sintático” para uma definição de função normal e ficam restritas a uma única expressão.

Na prática, estas duas funções fazem a mesma coisa:

1
2
3
4

def dobro(x):
    return x * 2

(lambda x: x * 2)(5)  # 10, a mesma conta, sem nome e sem return

Se ainda não domina funções “normais”, vale ler antes o nosso guia de funções em Python (def, parâmetros e retorno).

E de onde vem o nome? O termo vem do cálculo lambda, o sistema formal criado pelo matemático Alonzo Church na década de 1930, que usa a letra grega λ (lambda) para definir funções. Por isso, em programação, “lambda” virou sinônimo de função anônima, e não é exclusividade do Python: JavaScript, Java, C# e muitas outras linguagens também têm lambdas.

💡 Não confundir com AWS Lambda, o serviço de computação em nuvem da Amazon que executa código sem você administrar servidores. O nome é inspirado no mesmo conceito, mas é outra coisa: este artigo trata da expressão lambda da linguagem Python.

Como criar Funções lambda

Uma função lambda é criada usando a palavra-chave lambda, seguida de um ou mais argumentos, e uma expressão:

• argumentos são os dados de entrada que esta função irá receber
• expressão é o código que será executado quando a função lambda for chamada.

Sua sintaxe básica é a seguinte:

1

lambda {argumentos}: {expressão}

Veja o exemplo abaixo:

1
2

soma = lambda x, y: x + y
print(soma(2, 3))

Nela:

• Os argumentos são 2: x e y
• A expressão a ser executada: x + y

A saída do código acima será o resultado de soma(2, 3):

1

5

Podemos armazenar a função lambda em uma variável, como no exemplo acima, ou chamá-la diretamente:

1

print((lambda x, y: x + y)(2, 3))

E a saída será a mesma.

Note o conjunto de parênteses para criação da função e outro para os argumentos.

Dessa forma a função lambda está sendo criada e já chamada!

⚠️ Guardar uma lambda em uma variável (como soma acima) funciona e é ótimo para aprender, mas em código real a PEP 8 recomenda usar def nesse caso. Veja o porquê em Erros comuns.

Os parâmetros de uma lambda aceitam as mesmas formas de uma função comum: nenhum parâmetro, valores padrão e *args.

1
2
3

print((lambda: 'oi')())                   # oi
print((lambda x, y=2: x ** y)(3))         # 9
print((lambda *args: sum(args))(1, 2, 3)) # 6

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Lambda com sorted, max e min (parâmetro key)

Este é, de longe, o uso mais comum de lambda no dia a dia. As funções sorted(), max(), min() e o método lista.sort() aceitam um parâmetro key: uma função que recebe cada elemento e devolve o valor que deve ser usado na comparação. Como essa função geralmente é curta e só serve para aquele ponto, uma lambda cai como uma luva.

1
2
3
4
5
6
7
8
9
10
11
12
13

alunos = [('Ana', 8.5), ('Bruno', 6.0), ('Carla', 9.2)]

# Ordenar pela nota (segundo item da tupla)
print(sorted(alunos, key=lambda a: a[1]))
# [('Bruno', 6.0), ('Ana', 8.5), ('Carla', 9.2)]

# Ordem decrescente: basta reverse=True
print(sorted(alunos, key=lambda a: a[1], reverse=True))
# [('Carla', 9.2), ('Ana', 8.5), ('Bruno', 6.0)]

# Maior e menor nota
print(max(alunos, key=lambda a: a[1]))  # ('Carla', 9.2)
print(min(alunos, key=lambda a: a[1]))  # ('Bruno', 6.0)

Outros padrões que aparecem o tempo todo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

frutas = ['banana', 'kiwi', 'abacaxi', 'uva']
print(sorted(frutas, key=lambda f: len(f)))
# ['uva', 'kiwi', 'banana', 'abacaxi']

# Ordenar ignorando maiúsculas/minúsculas
nomes = ['ana', 'Bruno', 'carla', 'Daniel']
print(sorted(nomes))                          # ['Bruno', 'Daniel', 'ana', 'carla']
print(sorted(nomes, key=lambda n: n.lower())) # ['ana', 'Bruno', 'carla', 'Daniel']

# Ordenar um dicionário pelos valores
estoque = {'caneta': 40, 'caderno': 12, 'borracha': 25}
print(sorted(estoque.items(), key=lambda item: item[1]))
# [('caderno', 12), ('borracha', 25), ('caneta', 40)]

# Chave com maior valor
print(max(estoque, key=lambda k: estoque[k]))  # caneta

Alguns detalhes que caem em prova:

• sorted() devolve uma lista nova; lista.sort(key=...) ordena a própria lista e retorna None. Mais sobre isso no guia de listas no Python.
• Quando já existe uma função pronta, não precisa de lambda: sorted(frutas, key=len) dá o mesmo resultado de key=lambda f: len(f).
• estoque.items() gera pares (chave, valor), por isso item[1] é o valor. Revise os métodos em dicionários no Python.

A documentação oficial sobre ordenação tem mais exemplos de key.

Usando funções lambda com map, filter e reduce

Uma das principais utilidades das funções lambda é quando elas são usadas em conjunto com as funções map, filter e reduce (agora no pacote functools).

Ainda não domina a utilização das funções map e filter? Então não perca tempo e aprenda essas duas funções incríveis AGORA clicando aqui para ler esse artigo completão!

Veja o exemplo abaixo, onde usamos a função map para aplicar uma função lambda que eleva cada elemento de uma lista ao quadrado:

1
2
3

lista = [1, 2, 3, 4]

print(list(map(lambda x: x ** 2, lista)))

E a saída será:

1

[1, 4, 9, 16]

No exemplo abaixo, usamos a função filter para retornar apenas os números pares de uma lista:

1
2
3

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print(list(filter(lambda x: x % 2 == 0, lista)))

Gerando a saída:

1

[2, 4, 6, 8, 10]

Por fim, veja o exemplo a seguir, onde usamos a função reduce para somar todos os elementos de uma lista:

1
2
3
4
5

from functools import reduce

lista = [1, 2, 3, 4, 5]

print(reduce(lambda x, y: x + y, lista))

1

15

Repare no list(...) em volta do map e do filter: os dois devolvem um iterador, não uma lista. Sem o list(), o print mostra só algo como <map object at 0x7d0adc69b730> (o endereço muda a cada execução).

A alternativa com list comprehension: para transformar ou filtrar uma lista, a comunidade Python costuma preferir list comprehensions, que fazem o mesmo sem lambda e sem list():

1
2
3
4

lista = [1, 2, 3, 4]
print([x ** 2 for x in lista])                  # [1, 4, 9, 16]

print([x for x in range(1, 11) if x % 2 == 0])  # [2, 4, 6, 8, 10]

Regra prática: se você já tem uma função pronta (map(str.upper, nomes), map(int, entradas)), map fica curto e claro. Se você precisaria escrever uma lambda só para isso, a list comprehension geralmente é mais legível.

Criei o Ebookr.ai, uma plataforma que usa IA para gerar ebooks profissionais sobre qualquer tema - com capa gerada por IA, infográficos automáticos e exportação em PDF. Confere!

Lambda com if else

Uma lambda não aceita a instrução if com bloco, mas aceita a expressão condicional (o “ternário” do Python), que cabe em uma linha:

1

lambda parametros: valor_se_verdadeiro if condicao else valor_se_falso

Exemplo:

1
2
3
4
5
6

classifica = lambda n: 'par' if n % 2 == 0 else 'ímpar'
print(classifica(4), classifica(7))  # par ímpar

notas = [8.5, 4.0, 7.0, 6.9]
print(list(map(lambda n: 'aprovado' if n >= 7 else 'reprovado', notas)))
# ['aprovado', 'reprovado', 'aprovado', 'reprovado']

Três regras para não errar:

• O else é obrigatório. lambda n: 'par' if n % 2 == 0 gera SyntaxError: expected 'else' after 'if' expression.
• Não existe elif em lambda. Dá para encadear ternários (lambda x: 'positivo' if x > 0 else 'negativo' if x < 0 else 'zero'), mas a partir daí uma função com def fica mais legível, como mostramos em Exemplos de Quando NÃO Usar Lambda.
• O ternário é o mesmo que você usa fora da lambda. Se quiser revisar if, elif e else, veja estruturas condicionais no Python.

Casos de Uso do Mundo Real

Vamos ver onde lambdas são úteis na prática:

1. Ordenar Listas Complexas

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# Ordenar lista de dicionários por chave
users = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie', 'age': 35}
]

# Ordenar por idade
sorted_by_age = sorted(users, key=lambda u: u['age'])
# [{'name': 'Bob', 'age': 25}, ...]

# Ordenar por nome
sorted_by_name = sorted(users, key=lambda u: u['name'])
# [{'name': 'Alice', ...}, ...]

# Ordenar por múltiplos critérios (idade desc, nome asc)
sorted_users = sorted(users, key=lambda u: (-u['age'], u['name']))
# Charlie (35), Alice (30), Bob (25)

2. Encontrar Máximo/Mínimo Customizado

1
2
3
4
5
6
7
8
9
10
11
12
13

products = [
    {'name': 'Notebook', 'price': 2500, 'stock': 10},
    {'name': 'Mouse', 'price': 50, 'stock': 100},
    {'name': 'Teclado', 'price': 150, 'stock': 50}
]

# Produto mais caro
most_expensive = max(products, key=lambda p: p['price'])
print(most_expensive)  # {'name': 'Notebook', 'price': 2500, 'stock': 10}

# Produto com menor estoque
lowest_stock = min(products, key=lambda p: p['stock'])
print(lowest_stock)  # {'name': 'Notebook', 'price': 2500, 'stock': 10}

3. Filtrar e Transformar Dados

1
2
3
4
5
6
7
8
9

# Filtrar números pares e elevar ao quadrado
numbers = [1, 2, 3, 4, 5, 6]

# Com lambda
evens_squared = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers)))
# [4, 16, 36]

# Equivalente com list comprehension (mais legível)
evens_squared = [x**2 for x in numbers if x % 2 == 0]

4. Funções de Alta Ordem

1
2
3
4
5
6
7
8
9

# Criar funções multiplicadoras
def make_multiplier(n):
    return lambda x: x * n

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

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

Saber quando trocar lambda por uma função def de verdade é sinal de quem já entende Python além da sintaxe. Se você quer esse tipo de critério, construído com prática e suporte de professor, conheça a Jornada Python:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Lambda vs Funções Normais (def)

Resumo para decidir rápido:

Quando Usar Lambda:

✅ Operações simples e únicas

• key em sorted(), max(), min()
• Callback simples

✅ Expressão de uma linha

• Sem lógica condicional complexa
• Fácil de entender

✅ Usado uma vez

• Não será reutilizado

Quando Usar def (Função Normal):

✅ Lógica complexa

• Múltiplas linhas
• Condições if/else aninhadas

✅ Reutilização

• Usada em vários lugares
• Precisa de nome descritivo

✅ Docstring necessária

• Precisa documentação
• API pública

Exemplos de Quando NÃO Usar Lambda:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# ❌ RUIM: Lambda complexa (ilegível)
calculate = lambda x: x**2 if x > 0 else -x**2 if x < 0 else 0

# ✅ BOM: Função normal (legível)
def calculate(x):
    """Calcula quadrado com sinal"""
    if x > 0:
        return x**2
    elif x < 0:
        return -x**2
    return 0

# ❌ RUIM: Lambda reutilizada (sem nome descritivo)
process_data = lambda data: [x.strip().upper() for x in data]
result1 = process_data(data1)
result2 = process_data(data2)

# ✅ BOM: Função nomeada (clareza)
def normalize_data(data):
    """Normaliza dados: remove espaços e converte para maiúsculas"""
    return [x.strip().upper() for x in data]

Erros comuns

1. Usar return ou mais de uma instrução dentro da lambda

1

dobro = lambda x: return x * 2

1

SyntaxError: invalid syntax

A lambda já retorna o valor da expressão, então return não é permitido; atribuições também não (lambda x: y = x + 1 dá SyntaxError: cannot assign to lambda). Cuidado também com o ponto e vírgula: em f = lambda x: print(x); x * 2, o ; x * 2 não faz parte da lambda, é uma instrução separada, e o Python responde NameError: name 'x' is not defined. A correção é escrever só a expressão (lambda x: x * 2) ou, se precisar de várias instruções, usar def.

2. Lambda dentro de um loop “lembrando” só o último valor

1
2

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

1

[20, 20, 20]

Não dá erro, mas o resultado surpreende: você esperava [0, 10, 20]. A lambda não guarda o valor de i no momento em que é criada; ela procura a variável i só quando é chamada, e aí o loop já terminou com i = 2. A correção clássica é “congelar” o valor em um parâmetro padrão:

1
2

funcs = [lambda i=i: i * 10 for i in range(3)]
print([f() for f in funcs])  # [0, 10, 20]

3. Atribuir uma lambda a um nome (a PEP 8 desaconselha)

1
2

dobro = lambda x: x * 2
dobro('a', 1)

1

TypeError: <lambda>() takes 1 positional argument but 2 were given

Funciona, mas a mensagem de erro diz <lambda> em vez de dobro, o que atrapalha a depuração em um projeto grande. A PEP 8, nas recomendações de programação, é direta: sempre use uma instrução def em vez de uma atribuição que liga uma expressão lambda diretamente a um nome. Com def, o traceback passa a mostrar TypeError: dobro() takes 1 positional argument but 2 were given:

1
2

def dobro(x):
    return x * 2

Use lambda onde ela é passada direto como argumento (sorted(..., key=lambda ...)), não como atalho para def.

4. Esquecer o list() em map e filter

1
2

resultado = map(lambda x: x * 2, [1, 2, 3])
print(resultado[0])

1

TypeError: 'map' object is not subscriptable

map() e filter() devolvem iteradores, que não aceitam índice e, se impressos direto, mostram algo como <map object at 0x7d0adc69b730>. Converta com list(map(lambda x: x * 2, [1, 2, 3])), que resulta em [2, 4, 6]. Atenção: um iterador só pode ser percorrido uma vez; chamar list() de novo no mesmo resultado devolve [].

5. Usar if sem else na lambda

1

par = lambda x: 'par' if x % 2 == 0

1

SyntaxError: expected 'else' after 'if' expression

Dentro da lambda, o if é um ternário e precisa de else: lambda x: 'par' if x % 2 == 0 else 'ímpar'. Se a ideia era filtrar (manter só os pares), use filter(lambda x: x % 2 == 0, numeros).

Exercícios resolvidos

Exercício 1. Crie uma lambda que recebe dois números e devolve o produto deles, e chame-a na mesma linha com 3 e 4.

1

print((lambda x, y: x * y)(3, 4))

Exercício 2. Ordene a lista ['banana', 'kiwi', 'abacaxi', 'uva'] pelo tamanho das palavras, da menor para a maior, usando lambda.

1
2

frutas = ['banana', 'kiwi', 'abacaxi', 'uva']
print(sorted(frutas, key=lambda f: len(f)))

Exercício 3. Dada a lista de alunos [('Ana', 8.5), ('Bruno', 6.0), ('Carla', 9.2)], mostre só os nomes em ordem da maior para a menor nota.

1
2
3

alunos = [('Ana', 8.5), ('Bruno', 6.0), ('Carla', 9.2)]
ranking = sorted(alunos, key=lambda a: a[1], reverse=True)
print([nome for nome, nota in ranking])

Exercício 4. Dado o dicionário precos = {'café': 18.9, 'pão': 7.5, 'leite': 5.2}, mostre o produto mais barato e a lista de itens do mais caro para o mais barato.

1
2
3

precos = {'café': 18.9, 'pão': 7.5, 'leite': 5.2}
print(min(precos, key=lambda k: precos[k]))
print(sorted(precos.items(), key=lambda item: item[1], reverse=True))

1
2

leite
[('café', 18.9), ('pão', 7.5), ('leite', 5.2)]

Exercício 5. Use map e uma lambda com if else para transformar as notas [8.5, 4.0, 7.0, 6.9] em 'aprovado' (nota maior ou igual a 7) ou 'reprovado'.

1
2

notas = [8.5, 4.0, 7.0, 6.9]
print(list(map(lambda n: 'aprovado' if n >= 7 else 'reprovado', notas)))

Exercício 6. (Questão de prova) O que o código abaixo imprime?

1

print((lambda x, y=2: x ** y)(3))

a) 6
b) 9
c) 8
d) TypeError

Exercício 7. (Questão de prova) O que o código abaixo imprime?

1
2

fs = [lambda: i * 10 for i in range(3)]
print([f() for f in fs])

a) [0, 10, 20]
b) [20, 20, 20]
c) [0, 0, 0]
d) NameError

Exercício 8. (Questão de prova) Qual das expressões abaixo gera SyntaxError?

a) lambda: 0
b) lambda x, y: x + y
c) lambda x: return x
d) lambda *args: sum(args)

Quer praticar isso com projetos guiados, do básico ao avançado? Conheça o nosso curso de Python completo, a Jornada Python.

Conclusão

Neste guia completo sobre Funções Lambda, você aprendeu:

✅ Sintaxe lambda - Funções anônimas de uma linha
✅ Casos de uso reais - sort, filter, map, max/min
✅ Lambda com if else - O ternário dentro da lambda
✅ Lambda vs def - Quando usar cada uma
✅ Quando NÃO usar - Complexidade e reutilização

Principais lições:

• Lambdas são ideais para operações simples e únicas
• Perfeitas como key em sorted() e callbacks
• Use def quando lógica é complexa ou reutilizada
• Lambdas NÃO têm docstrings ou nomes descritivos
• Legibilidade > concisão - se está confuso, use def

Próximos passos:

• Pratique com sorted(), max(), min()
• Explore functools.partial para alternativa a lambdas
• Combine com map(), filter() (mas list comprehension é mais Pythônico)
• Estude funções de alta ordem

Agora que você domina funções lambda, experimente usá-las em seus próprios projetos e veja como elas podem simplificar seu código!

Por Vinícius Ramos em 10/01/2023

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Bora se conectar no LinkedIn! vinicius-aramos

Minhas redes:

• 
• 
•