Funções lambda em Python: quando usar (e quando evitar)

Intermediário20 min5 exercícios70 XP

Este tutorial foi traduzido do original em inglês.Read in English Leer en español Читать на русском อ่านภาษาไทย Avisar sobre um erro de tradução

Antes de começar

Funções em Python: definir, chamar e retornar valores

0/5 exercícios

Imagine que você precisa deixar um recado rápido para alguém: "Volto em 5 minutos". Você não escreveria uma carta formal, com saudação, três parágrafos e assinatura. Você rabiscaria num post-it e pronto.

As funções lambda são os post-its do Python. São funções minúsculas, anônimas e descartáveis, para quando você precisa de algo rápido em uma linha e um bloco def completo seria exagero.

Neste tutorial, você vai aprender a escrever funções lambda, onde elas brilham (ordenar, filtrar, mapear) e, tão importante quanto, quando é melhor deixá-las de lado e usar uma função comum.

Como escrever uma função lambda

Uma função lambda é criada com a palavra-chave lambda, seguida dos parâmetros, de dois-pontos e de uma única expressão. Essa expressão é retornada automaticamente: não é preciso usar a palavra-chave return.

Lambda vs. def: mesmo resultado

# Regular function

def double(x):

return x * 2

# Same thing as a lambda

double_lambda = lambda x: x * 2

print(double(5))

print(double_lambda(5))

Saída

10
10

A sintaxe é: lambda parameters: expression. Não há nome de função (é por isso que elas são chamadas de "anônimas"), nem def, nem return, nem corpo com várias linhas. Só uma expressão, que é avaliada e retornada.

As lambdas podem receber vários parâmetros, como as funções comuns:

Lambda com vários parâmetros

add = lambda a, b: a + b

print(add(3, 7))

full_name = lambda first, last: first + ' ' + last

print(full_name('Ada', 'Lovelace'))

Saída

10
Ada Lovelace

Usando lambda com sorted()

O uso mais comum das funções lambda é como argumento key do sorted(). O parâmetro key diz ao Python: "antes de comparar os itens, transforme cada um com esta função".

Ordenação que ignora maiúsculas e minúsculas, com lambda

names = ['Charlie', 'alice', 'Bob']

# Default sort is case-sensitive (uppercase first)

print(sorted(names))

# Sort by lowercase version (case-insensitive)

print(sorted(names, key=lambda name: name.lower()))

Saída

['Bob', 'Charlie', 'alice']
['alice', 'Bob', 'Charlie']

A lambda lambda name: name.lower() diz ao sorted() para comparar as versões em minúsculas de cada string. As strings originais continuam iguais: a lambda só afeta a comparação.

As lambdas são especialmente úteis para ordenar dados complexos, como listas de tuplas ou de dicionários:

Ordenar tuplas pelo segundo elemento

students = [

('Alice', 88),

('Bob', 95),

('Charlie', 72),

('Diana', 91),

]

# Sort by grade (second element)

by_grade = sorted(students, key=lambda s: s[1])

for name, grade in by_grade:

print(name + ': ' + str(grade))

Saída

Charlie: 72
Alice: 88
Diana: 91
Bob: 95

Ordenar dicionários por um campo

products = [

{'name': 'Laptop', 'price': 999},

{'name': 'Mouse', 'price': 25},

{'name': 'Keyboard', 'price': 75},

]

# Sort by price, cheapest first

by_price = sorted(products, key=lambda p: p['price'])

for item in by_price:

print(item['name'] + ': $' + str(item['price']))

Saída

Mouse: $25
Keyboard: $75
Laptop: $999

Usando lambda com map() e filter()

map() aplica uma função a cada item de uma lista e devolve os resultados transformados. filter() mantém só os itens para os quais a função retorna True. As duas recebem uma função como primeiro argumento: o lugar perfeito para uma lambda.

map() e filter() com lambdas

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

# Double every number

doubled = list(map(lambda x: x * 2, numbers))

print(doubled)

# Keep only even numbers

evens = list(filter(lambda x: x % 2 == 0, numbers))

print(evens)

Saída

[2, 4, 6, 8, 10]
[2, 4]

Envolvemos map() e filter() com list() porque elas retornam iteradores preguiçosos (que só calculam cada valor quando ele é pedido), e não listas. A chamada de list() obriga os dois a produzir todos os resultados de uma vez.

Agora um exemplo mais prático, que extrai e filtra dados:

map e filter na prática

prices = [10.50, 23.99, 5.00, 45.00, 12.75]

# Add 10% tax to each price

with_tax = list(map(lambda p: round(p * 1.1, 2), prices))

print(with_tax)

# Filter prices over $20

expensive = list(filter(lambda p: p > 20, prices))

print(expensive)

Saída

[11.55, 26.39, 5.5, 49.5, 14.03]
[23.99, 45.0]

Lambda com map/filter

doubled = list(map(
    lambda x: x * 2, numbers
))
evens = list(filter(
    lambda x: x % 2 == 0, numbers
))

List comprehension (em geral, a preferida)

doubled = [x * 2 for x in numbers]

evens = [x for x in numbers
         if x % 2 == 0]

Lambda vs. def: quando usar cada uma

As lambdas são tentadoras porque parecem espertas e compactas. Mas elas têm limitações reais. Veja quando usar cada uma:

Use lambda quando:

Você precisa de uma função minúscula para um argumento key=, map() ou filter()

A lógica cabe em uma única expressão simples

Você não vai reutilizar a função em outro lugar

Use def quando:

A lógica precisa de mais de uma expressão

Você precisa de instruções if/else, laços ou tratamento de erros

Você quer um nome descritivo, que sirva de documentação

Você vai reutilizar a função em vários lugares

Lógica de ordenação simples vs. complexa

# Lambda: fine for simple key functions

words = ['banana', 'apple', 'cherry']

print(sorted(words, key=lambda w: len(w)))

# def: better when logic is complex

def sort_key(word):

'''Sort by length, then alphabetically.'''

return (len(word), word)

print(sorted(words, key=sort_key))

Saída

['apple', 'banana', 'cherry']
['apple', 'banana', 'cherry']

Padrões comuns com lambda

Aqui estão alguns padrões que você vai encontrar em código Python de verdade. Reconhecê-los vai ajudar você a ler o código de outras pessoas e a saber quando uma lambda é a ferramenta certa.

Padrão: ordenar uma lista de dicionários

# Pattern 1: Sort by dictionary key

people = [{'name': 'Zara', 'age': 22}, {'name': 'Alex', 'age': 30}]

by_name = sorted(people, key=lambda p: p['name'])

for p in by_name:

print(p['name'] + ': ' + str(p['age']))

Saída

Alex: 30
Zara: 22

Padrão: lambda com condição

# Pattern 2: Conditional expression in lambda

classify = lambda x: 'even' if x % 2 == 0 else 'odd'

print(classify(4))

print(classify(7))

Saída

even
odd

Padrão: max/min com key

# Pattern 3: Using max/min with a key

words = ['python', 'is', 'awesome']

longest = max(words, key=lambda w: len(w))

print(longest)

shortest = min(words, key=lambda w: len(w))

print(shortest)

Saída

awesome
is

Exercícios práticos

Preveja a saída da lambda

Preveja a saída

O que este código exibe? Digite a saída exata.

operation = lambda a, b: a * b + 1
print(operation(3, 4))
print(operation(0, 10))

operation = lambda a, b: a * b + 1

print(operation(3, 4))

print(operation(0, 10))

Ordenar pelo último caractere

Escreva o código

Dada uma lista de palavras, use sorted() com uma lambda para ordená-las pelo último caractere. Exiba a lista ordenada resultante.

Use esta lista: words = ['hello', 'world', 'python', 'code']

Saída esperada: ['world', 'code', 'python', 'hello']

words = ['hello', 'world', 'python', 'code']

# Sort by last character and print

Filtrar e transformar

Escreva o código

Dada uma lista de números, use filter() com uma lambda para manter só os números maiores que 10 e depois use map() com uma lambda para elevar ao quadrado cada número restante. Exiba a lista final.

Use esta lista: numbers = [3, 15, 7, 20, 8, 12]

Saída esperada: [225, 400, 144]

numbers = [3, 15, 7, 20, 8, 12]

# Filter numbers > 10, then square them

Ordenar alunos pela média

Escreva o código

Dada uma lista de tuplas de alunos (name, gpa), ordene-as pela média (GPA) da maior para a menor usando sorted() com uma lambda. Exiba cada aluno em uma linha separada, no formato name: gpa.

Use esta lista:

students = [('Alice', 3.5), ('Bob', 3.9), ('Charlie', 3.2), ('Diana', 3.7)]

Saída esperada:

Bob: 3.9
Diana: 3.7
Alice: 3.5
Charlie: 3.2

students = [('Alice', 3.5), ('Bob', 3.9), ('Charlie', 3.2), ('Diana', 3.7)]

# Sort by GPA (highest first) and print

Ordenar palavras pelo tamanho

Escreva o código

Dada uma lista de palavras, use sorted() com uma lambda para ordená-las pelo tamanho (as mais curtas primeiro). Se duas palavras tiverem o mesmo tamanho, elas devem aparecer em ordem alfabética. Exiba a lista ordenada.

Use esta lista: words = ['fig', 'apple', 'date', 'kiwi', 'banana', 'pear', 'plum']

Saída esperada: ['fig', 'date', 'kiwi', 'pear', 'plum', 'apple', 'banana']

words = ['fig', 'apple', 'date', 'kiwi', 'banana', 'pear', 'plum']

# Sort by length, then alphabetically

Como escrever uma função lambda

Usando lambda com sorted()

Usando lambda com map() e filter()

Lambda vs. def: quando usar cada uma

Padrões comuns com lambda

Exercícios práticos

Tutoriais relacionados