Neste tutorial, exploraremos como usar funções lambda para atualizar valores de dicionários em Python. Funções lambda são funções compactas e anônimas que podem tornar seu código mais conciso e legível ao trabalhar com dicionários. Ao final deste guia, você entenderá como usar essas ferramentas poderosas para otimizar as operações de dicionários em seus programas Python.
Nesta etapa, aprenderemos o que são funções lambda e como criá-las em Python.
Uma função lambda é uma função pequena e anônima definida com a palavra-chave lambda. Ao contrário das funções regulares declaradas com a palavra-chave def, as funções lambda podem ser escritas em uma única linha e não precisam de um nome. Elas são perfeitas para operações simples que você precisa realizar rapidamente.
A sintaxe básica de uma função lambda é:
lambda argumentos: expressãoAqui, argumentos são as entradas para a função, e expressão é a operação que produz o resultado.
Vamos criar uma função lambda simples e ver como ela funciona. Abra um novo arquivo Python no editor de código clicando em "File" > "New File" na barra de menu superior. Nomeie o arquivo lambda_basics.py e salve-o no diretório /home/labex/project.
Adicione o seguinte código ao arquivo:
## Define a regular function
def add_numbers(x, y):
return x + y
## Same function as a lambda
add_lambda = lambda x, y: x + y
## Test both functions
print("Regular function result:", add_numbers(5, 3))
print("Lambda function result:", add_lambda(5, 3))Execute o código abrindo um terminal (se ainda não estiver aberto) e executando:
python3 lambda_basics.pyVocê deve ver a seguinte saída:
Regular function result: 8
Lambda function result: 8Ambas as funções realizam a mesma operação, mas a versão lambda é mais concisa.
As funções lambda são mais úteis em situações onde:
Vamos ver outro exemplo. Adicione o seguinte código ao seu arquivo lambda_basics.py:
## Using lambda with built-in functions
numbers = [1, 2, 3, 4, 5]
## Square each number using lambda
squared = list(map(lambda x: x**2, numbers))
## Filter even numbers using lambda
evens = list(filter(lambda x: x % 2 == 0, numbers))
print("Original numbers:", numbers)
print("Squared numbers:", squared)
print("Even numbers:", evens)Execute o arquivo novamente:
python3 lambda_basics.pyA saída agora incluirá:
Original numbers: [1, 2, 3, 4, 5]
Squared numbers: [1, 4, 9, 16, 25]
Even numbers: [2, 4]Neste exemplo, usamos funções lambda com as funções embutidas map e filter para transformar e filtrar uma lista de números. Esse tipo de operação será útil quando trabalharmos com dicionários nas próximas etapas.
Antes de usarmos funções lambda com dicionários, vamos garantir que entendemos como os dicionários funcionam em Python.
Um dicionário é uma coleção de pares chave-valor. Cada chave está conectada a um valor, permitindo que você acesse rapidamente os valores quando souber a chave. Dicionários são mutáveis, o que significa que você pode alterar, adicionar ou remover itens após a criação do dicionário.
Vamos criar um novo arquivo chamado dictionary_basics.py no diretório /home/labex/project e adicionar o seguinte código:
## Creating a dictionary
product_prices = {
'apple': 1.50,
'banana': 0.75,
'orange': 1.20,
'grapes': 2.50
}
## Accessing dictionary values
print("Price of apple:", product_prices['apple'])
## Adding a new item
product_prices['watermelon'] = 3.75
print("Updated dictionary:", product_prices)
## Modifying an existing item
product_prices['banana'] = 0.85
print("After modification:", product_prices)
## Iterating through a dictionary
print("\nAll products and their prices:")
for product, price in product_prices.items():
print(f"{product}: ${price:.2f}")Execute o arquivo:
python3 dictionary_basics.pyVocê deve ver uma saída semelhante a esta:
Price of apple: 1.5
Updated dictionary: {'apple': 1.5, 'banana': 0.85, 'orange': 1.2, 'grapes': 2.5, 'watermelon': 3.75}
After modification: {'apple': 1.5, 'banana': 0.85, 'orange': 1.2, 'grapes': 2.5, 'watermelon': 3.75}
All products and their prices:
apple: $1.50
banana: $0.85
orange: $1.20
grapes: $2.50
watermelon: $3.75Dicionários têm vários métodos úteis. Vamos adicionar o seguinte código ao nosso arquivo dictionary_basics.py:
## Dictionary methods
print("\nDictionary Methods:")
print("Keys:", list(product_prices.keys()))
print("Values:", list(product_prices.values()))
print("Items:", list(product_prices.items()))
## Check if a key exists
if 'apple' in product_prices:
print("Apple is in the dictionary")
## Get a value with a default if key doesn't exist
price = product_prices.get('pineapple', 'Not available')
print("Price of pineapple:", price)Execute o arquivo novamente:
python3 dictionary_basics.pyVocê deve ver a saída adicional:
Dictionary Methods:
Keys: ['apple', 'banana', 'orange', 'grapes', 'watermelon']
Values: [1.5, 0.85, 1.2, 2.5, 3.75]
Items: [('apple', 1.5), ('banana', 0.85), ('orange', 1.2), ('grapes', 2.5), ('watermelon', 3.75)]
Apple is in the dictionary
Price of pineapple: Not availableAgora que entendemos tanto as funções lambda quanto os dicionários, estamos prontos para combiná-los na próxima etapa.
Agora que entendemos tanto as funções lambda quanto os dicionários, vamos ver como podemos usar funções lambda para atualizar valores de dicionário.
Vamos criar um novo arquivo chamado update_dictionaries.py no diretório /home/labex/project e adicionar o seguinte código:
## Create a dictionary of product prices
prices = {
'apple': 1.50,
'banana': 0.75,
'orange': 1.20,
'grapes': 2.50
}
print("Original prices:", prices)
## Apply a 10% discount to all prices using lambda and dictionary comprehension
discounted_prices = {item: round(price * 0.9, 2) for item, price in prices.items()}
print("Prices after 10% discount:", discounted_prices)
## Another way: using map() and lambda
## First, let's create a function that applies the map
def apply_to_dict(func, dictionary):
return dict(map(func, dictionary.items()))
## Now apply a 20% increase using the function and lambda
increased_prices = apply_to_dict(lambda item: (item[0], round(item[1] * 1.2, 2)), prices)
print("Prices after 20% increase:", increased_prices)Execute o arquivo:
python3 update_dictionaries.pyVocê deve ver uma saída semelhante a:
Original prices: {'apple': 1.5, 'banana': 0.75, 'orange': 1.2, 'grapes': 2.5}
Prices after 10% discount: {'apple': 1.35, 'banana': 0.68, 'orange': 1.08, 'grapes': 2.25}
Prices after 20% increase: {'apple': 1.8, 'banana': 0.9, 'orange': 1.44, 'grapes': 3.0}Vamos detalhar o que aconteceu:
apply_to_dict que usa map() e converte o resultado de volta para um dicionário.Agora, vamos atualizar nossos valores de dicionário condicionalmente. Adicione o seguinte código ao seu arquivo update_dictionaries.py:
print("\n--- Conditional Updates ---")
## Apply different discounts: 15% for items over $1.00, 5% for the rest
varied_discount = {
item: round(price * 0.85, 2) if price > 1.00 else round(price * 0.95, 2)
for item, price in prices.items()
}
print("Varied discounts:", varied_discount)
## Using filter and lambda to update only certain items
def update_filtered_items(dictionary, filter_func, update_func):
## First, filter the items
filtered = dict(filter(filter_func, dictionary.items()))
## Then, update the filtered items
updated = {key: update_func(value) for key, value in filtered.items()}
## Merge with the original dictionary (only updating filtered items)
result = dictionary.copy()
result.update(updated)
return result
## Apply a 50% discount only to fruits starting with 'a'
special_discount = update_filtered_items(
prices,
lambda item: item[0].startswith('a'),
lambda price: round(price * 0.5, 2)
)
print("Special discount on items starting with 'a':", special_discount)Execute o arquivo novamente:
python3 update_dictionaries.pyVocê deve agora ver uma saída adicional:
--- Conditional Updates ---
Varied discounts: {'apple': 1.28, 'banana': 0.71, 'orange': 1.02, 'grapes': 2.12}
Special discount on items starting with 'a': {'apple': 0.75, 'banana': 0.75, 'orange': 1.2, 'grapes': 2.5}Neste exemplo:
Esses exemplos demonstram como as funções lambda podem tornar as atualizações de dicionário mais concisas e legíveis, especialmente quando combinadas com as funções embutidas do Python, como map() e filter().
Vamos explorar algumas aplicações mais avançadas de funções lambda com dicionários, focando na ordenação e transformação de dados de dicionário.
Dicionários em Python não são ordenados por padrão, mas às vezes precisamos processá-los em uma ordem específica. Vamos criar um novo arquivo chamado advanced_dictionary_ops.py no diretório /home/labex/project e adicionar o seguinte código:
## Create a dictionary of student scores
student_scores = {
'Alice': 92,
'Bob': 85,
'Charlie': 78,
'David': 95,
'Eva': 88
}
print("Original student scores:", student_scores)
## Sort by student names (keys)
sorted_by_name = dict(sorted(student_scores.items()))
print("\nSorted by name:", sorted_by_name)
## Sort by scores (values) in ascending order
sorted_by_score_asc = dict(sorted(student_scores.items(), key=lambda item: item[1]))
print("\nSorted by score (ascending):", sorted_by_score_asc)
## Sort by scores (values) in descending order
sorted_by_score_desc = dict(sorted(student_scores.items(), key=lambda item: item[1], reverse=True))
print("\nSorted by score (descending):", sorted_by_score_desc)
## Get the top 3 students by score
top_3_students = dict(sorted(student_scores.items(), key=lambda item: item[1], reverse=True)[:3])
print("\nTop 3 students:", top_3_students)Execute o arquivo:
python3 advanced_dictionary_ops.pyVocê deve ver uma saída semelhante a:
Original student scores: {'Alice': 92, 'Bob': 85, 'Charlie': 78, 'David': 95, 'Eva': 88}
Sorted by name: {'Alice': 92, 'Bob': 85, 'Charlie': 78, 'David': 95, 'Eva': 88}
Sorted by score (ascending): {'Charlie': 78, 'Bob': 85, 'Eva': 88, 'Alice': 92, 'David': 95}
Sorted by score (descending): {'David': 95, 'Alice': 92, 'Eva': 88, 'Bob': 85, 'Charlie': 78}
Top 3 students: {'David': 95, 'Alice': 92, 'Eva': 88}Neste exemplo, usamos a função sorted() com funções lambda para ordenar o dicionário de diferentes maneiras:
Também usamos o fatiamento [:3] para obter apenas os 3 melhores alunos após a ordenação.
Agora, vamos ver como podemos transformar os valores em um dicionário. Adicione o seguinte código ao seu arquivo advanced_dictionary_ops.py:
print("\n--- Transforming Dictionary Values ---")
## Create a dictionary of temperatures in Celsius
celsius_temps = {
'New York': 21,
'London': 18,
'Tokyo': 26,
'Sydney': 22,
'Moscow': 14
}
print("Temperatures in Celsius:", celsius_temps)
## Convert Celsius to Fahrenheit: F = C * 9/5 + 32
fahrenheit_temps = {city: round(temp * 9/5 + 32, 1) for city, temp in celsius_temps.items()}
print("Temperatures in Fahrenheit:", fahrenheit_temps)
## Categorize temperatures as cool, moderate, or warm
def categorize_temp(temp):
if temp < 18:
return "Cool"
elif temp < 25:
return "Moderate"
else:
return "Warm"
categorized_temps = {city: categorize_temp(temp) for city, temp in celsius_temps.items()}
print("Categorized temperatures:", categorized_temps)
## Group cities by temperature category using a lambda and reduce
from collections import defaultdict
from functools import reduce
grouped_cities = reduce(
lambda result, item: result[categorize_temp(item[1])].append(item[0]) or result,
celsius_temps.items(),
defaultdict(list)
)
print("\nCities grouped by temperature category:")
for category, cities in grouped_cities.items():
print(f"{category}: {', '.join(cities)}")Execute o arquivo novamente:
python3 advanced_dictionary_ops.pyVocê deve agora ver uma saída adicional:
--- Transforming Dictionary Values ---
Temperatures in Celsius: {'New York': 21, 'London': 18, 'Tokyo': 26, 'Sydney': 22, 'Moscow': 14}
Temperatures in Fahrenheit: {'New York': 69.8, 'London': 64.4, 'Tokyo': 78.8, 'Sydney': 71.6, 'Moscow': 57.2}
Categorized temperatures: {'New York': 'Moderate', 'London': 'Moderate', 'Tokyo': 'Warm', 'Sydney': 'Moderate', 'Moscow': 'Cool'}
Cities grouped by temperature category:
Cool: Moscow
Moderate: New York, London, Sydney
Warm: TokyoNeste exemplo:
reduce() com uma lambda para agrupar cidades por categoria de temperatura.Essas técnicas demonstram como as funções lambda podem tornar as operações de dicionário complexas mais concisas e legíveis. Como você pode ver, combinar funções lambda com as funções embutidas do Python e operações de dicionário fornece ferramentas poderosas para manipulação de dados.
Neste tutorial, você aprendeu como usar funções lambda para atualizar valores de dicionário em Python. Cobrimos:
map(), filter() e reduce()Essas técnicas ajudarão você a escrever um código mais conciso e legível ao trabalhar com dicionários em Python. À medida que você continua sua jornada em Python, descobrirá que as funções lambda se tornam uma ferramenta cada vez mais valiosa em seu kit de ferramentas de programação, especialmente para tarefas de manipulação de dados.
Lembre-se de que, embora as funções lambda sejam poderosas, elas funcionam melhor para operações simples. Para uma lógica mais complexa, considere usar funções nomeadas regulares para manter a legibilidade e a capacidade de manutenção do código.
