O que são Funções Lambda no Python

✅ Atualizado para Python 3.13 (Dezembro 2025)
Conteúdo enriquecido com casos de uso do mundo real e análise de quando usar vs funções normais.

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 vs funções normais (def)
• ✅ Quando usar e quando NÃO usar lambdas

Vá direto ao assunto…

• Como criar Funções lambda
• Usando funções lambda com map, filter e reduce
• Casos de Uso do Mundo Real
• Lambda vs Funções Normais (def)

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 parentêses para criação da função e outro para os argumentos.

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

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

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

Estou desenvolvendo o DevBook, uma plataforma que usa IA para gerar ebooks técnicos profissionais. Não deixe de conferir clicando no botão abaixo!

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

# 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']))

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, ...}

# Produto com menor estoque
lowest_stock = min(products, key=lambda p: p['stock'])
print(lowest_stock)  # {'name': 'Notebook', '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

Lambda vs Funções Normais (def)

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]

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 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.

Minhas redes: