Комментарии (1)
🐱
claude-haiku-4.5PrepBro AI23 мар. 2026 г.(ред.)
Ответ сгенерирован нейросетью и может содержать ошибки
Lambda функции: примеры и когда их использовать
Lambda (анонимные функции) полезны для простых преобразований данных. Я приведу примеры от простых до сложных.
1. Простые примеры Lambda
# Базовые примеры
square = lambda x: x ** 2
print(square(5)) # 25
add = lambda x, y: x + y
print(add(3, 4)) # 7
# С условиями
is_even = lambda x: x % 2 == 0
print(is_even(4)) # True
print(is_even(5)) # False
# С условным выражением
abs_value = lambda x: x if x >= 0 else -x
print(abs_value(-5)) # 5
2. Lambda с filter(), map(), sorted()
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Filter: оставить только чётные
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # [2, 4, 6, 8, 10]
# Map: возвести в квадрат
squared = list(map(lambda x: x ** 2, numbers))
print(squared) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# Sorted: сортировка по сложному ключу
users = [
{'name': 'Alice', 'age': 25},
{'name': 'Bob', 'age': 20},
{'name': 'Charlie', 'age': 30}
]
sorted_by_age = sorted(users, key=lambda u: u['age'])
print(sorted_by_age) # Отсортировано по возрасту
# Reverse sort
sorted_by_name_desc = sorted(users, key=lambda u: u['name'], reverse=True)
3. Сложная Lambda: обработка данных
# Преобразование строк в объекты
data = ['name:Alice,age:25', 'name:Bob,age:30', 'name:Charlie,age:28']
users = list(map(
lambda line: dict(
item.split(':') for item in line.split(',')
),
data
))
print(users)
# [
# {'name': 'Alice', 'age': '25'},
# {'name': 'Bob', 'age': '30'},
# {'name': 'Charlie', 'age': '28'}
# ]
# Фильтрация и трансформация одновременно
# Оставить только пользователей старше 25, извлечь только имена
names = list(map(
lambda u: u['name'],
filter(lambda u: int(u['age']) > 25, users)
))
print(names) # ['Bob', 'Charlie']
4. Lambda в reduce() — агрегирование данных
from functools import reduce
numbers = [1, 2, 3, 4, 5]
# Сумма
total = reduce(lambda acc, x: acc + x, numbers)
print(total) # 15
# Произведение
product = reduce(lambda acc, x: acc * x, numbers, 1)
print(product) # 120
# Найти максимум
maximum = reduce(lambda acc, x: acc if acc > x else x, numbers)
print(maximum) # 5
# Собрать словарь
users = [
{'id': 1, 'name': 'Alice'},
{'id': 2, 'name': 'Bob'},
{'id': 3, 'name': 'Charlie'}
]
user_dict = reduce(
lambda acc, u: {**acc, u['id']: u['name']},
users,
{}
)
print(user_dict) # {1: 'Alice', 2: 'Bob', 3: 'Charlie'}
5. Сложная Lambda: вложенная обработка списков
# Список заказов с товарами
orders = [
{
'id': 1,
'user': 'Alice',
'items': [
{'name': 'Laptop', 'price': 1000, 'qty': 1},
{'name': 'Mouse', 'price': 25, 'qty': 2}
]
},
{
'id': 2,
'user': 'Bob',
'items': [
{'name': 'Keyboard', 'price': 100, 'qty': 1}
]
}
]
# Найти всех пользователей, которые потратили > 500
big_spenders = list(map(
lambda o: o['user'],
filter(
lambda o: sum(
map(lambda item: item['price'] * item['qty'], o['items'])
) > 500,
orders
)
))
print(big_spenders) # ['Alice']
# Более читаемо с использованием list comprehension:
big_spenders_v2 = [
o['user']
for o in orders
if sum(item['price'] * item['qty'] for item in o['items']) > 500
]
print(big_spenders_v2) # ['Alice']
6. Сложная Lambda: сортировка по нескольким критериям
# Сортировка students по GPA (descending), потом по имени (ascending)
students = [
{'name': 'Alice', 'gpa': 3.9, 'year': 3},
{'name': 'Bob', 'gpa': 3.9, 'year': 2},
{'name': 'Charlie', 'gpa': 3.7, 'year': 3},
{'name': 'David', 'gpa': 3.9, 'year': 2},
]
sorted_students = sorted(
students,
key=lambda s: (-s['gpa'], s['name']) # -gpa для descending
)
print(sorted_students)
# [
# {'name': 'Alice', 'gpa': 3.9, 'year': 3},
# {'name': 'Bob', 'gpa': 3.9, 'year': 2},
# {'name': 'David', 'gpa': 3.9, 'year': 2},
# {'name': 'Charlie', 'gpa': 3.7, 'year': 3}
# ]
7. Сложная Lambda: обработка текста
import re
# Преобразовать текст в слова, отфильтровать, привести в нижний регистр
text = "Python is AWESOME! Lambda functions are POWERFUL!"
words = list(map(
lambda w: w.lower(),
filter(
lambda w: len(w) > 2 and re.match(r'^[a-z]', w.lower()),
map(
lambda w: w.replace('!', '').replace('.', ''),
text.split()
)
)
))
print(words)
# ['python', 'awesome', 'lambda', 'functions', 'are', 'powerful']
# Но это менее читаемо! Лучше use list comprehension:
words_v2 = [
word.lower()
for word in text.replace('!', '').replace('.', '').split()
if len(word) > 2
]
print(words_v2)
8. Lambda с default аргументами — опасная ловушка!
# ПЛОХО: функция использует переменную из внешней области видимости
multiplier = 2
multiply_by_two = lambda x: x * multiplier
multiplier = 5 # Изменили multiplier!
print(multiply_by_two(10)) # 50, а не 20! Неожиданно!
# ХОРОШО: передать как default аргумент
multiply_by_two = lambda x, m=2: x * m
print(multiply_by_two(10)) # 20
# Или лучше использовать обычную функцию
def make_multiplier(factor):
return lambda x: x * factor
multiply_by_two = make_multiplier(2)
multiply_by_five = make_multiplier(5)
print(multiply_by_two(10)) # 20
print(multiply_by_five(10)) # 50
9. Lambda в словаре (диспетчер команд)
# Реализация калькулятора через lambda
calc = {
'+': lambda x, y: x + y,
'-': lambda x, y: x - y,
'*': lambda x, y: x * y,
'/': lambda x, y: x / y if y != 0 else None,
'%': lambda x, y: x % y if y != 0 else None,
}
print(calc['+'](5, 3)) # 8
print(calc['*'](5, 3)) # 15
print(calc['/'](10, 2)) # 5.0
print(calc['%'](10, 3)) # 1
Когда НЕ использовать Lambda?
❌ Lambda становится слишком сложной
# ПЛОХО: lambda становится нечитаемым
result = list(map(
lambda o: {
'total': sum(item['price'] * item['qty'] for item in o['items']),
'avg': sum(item['price'] * item['qty'] for item in o['items']) / len(o['items']),
'items_count': len(o['items']),
'user': o['user']
},
orders
))
# ХОРОШО: используй обычную функцию
def calculate_order_stats(order):
total = sum(item['price'] * item['qty'] for item in order['items'])
avg = total / len(order['items'])
return {
'total': total,
'avg': avg,
'items_count': len(order['items']),
'user': order['user']
}
result = list(map(calculate_order_stats, orders))
❌ Lambda имеет side effects
# ПЛОХО: lambda с побочным эффектом (логирование, изменение состояния)
results = list(map(
lambda x: (print(f'Processing {x}'), x * 2)[1], # Хак для side effect!
numbers
))
# ХОРОШО: используй обычную функцию
def process_number(x):
print(f'Processing {x}')
return x * 2
results = list(map(process_number, numbers))
Best Practices для Lambda
# ✅ Используй lambda для простых преобразований (1-2 строки)
squares = list(map(lambda x: x ** 2, numbers))
# ✅ Используй lambda для сортировки с custom key
sorted_by_name = sorted(users, key=lambda u: u['name'])
# ✅ Используй lambda в фильтрации
evens = list(filter(lambda x: x % 2 == 0, numbers))
# ❌ Не используй lambda для сложной логики
# ❌ Не используй lambda с побочными эффектами
# ❌ Не используй lambda когда непонятна семантика
# ✅ Когда в сомнениях, напиши def функцию вместо lambda
Чем лучше lambda?
# Часто list/dict comprehension более читаемы:
# Lambda + map
squares = list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))
# List comprehension (лучше читается)
squares = [x ** 2 for x in [1, 2, 3, 4, 5]]
# Lambda + filter
evens = list(filter(lambda x: x % 2 == 0, numbers))
# List comprehension (лучше читается)
evens = [x for x in numbers if x % 2 == 0]
Вывод
Lambda полезна для:
- ✅ Простых одноразовых преобразований данных
- ✅ Сортировки с custom key
- ✅ Фильтрации data
- ✅ Диспетчеров (словари функций)
Но избегай:
- ❌ Сложных многострочных логик (используй def)
- ❌ Побочных эффектов (логирование, изменение состояния)
- ❌ Переложенной сложности в читаемость
Золотое правило: Если lambda более чем в одну строку или если её сложно прочитать, преврати её в обычную функцию.