В мире программирования на Python встроенные функции предоставляют мощный и лаконичный способ создания небольших функций, состоящих из одного выражения, без необходимости формального определения функции. Эти встроенные функции, известные в Python как lambda-функции, особенно полезны для простых операций и методов функционального программирования. Этот учебник проведет вас через создание и использование lambda-функций для написания более элегантного и эффективного кода на Python.
В Python lambda-функции — это небольшие анонимные функции, определяемые с использованием ключевого слова lambda вместо стандартного оператора def. Они называются "анонимными", потому что не требуют имени, как традиционные функции.
Основной синтаксис для lambda-функции:
lambda arguments: expressionLambda-функции ограничены одним выражением и автоматически возвращают результат этого выражения.
Давайте создадим и протестируем несколько простых lambda-функций:
Откройте новый файл Python в вашем редакторе кода. Нажмите "File" > "New File" в WebIDE и сохраните его как lambda_basics.py в каталоге /home/labex/project.
Добавьте следующий код для создания вашей первой lambda-функции:
## Простая lambda-функция, которая возводит число в квадрат
square = lambda x: x * x
## Тестирование lambda-функции
result = square(5)
print(f"Квадрат 5 равен: {result}")python3 ~/project/lambda_basics.pyВы должны увидеть вывод:
Квадрат 5 равен: 25Давайте сравним lambda-функции с их эквивалентными обычными функциями:
lambda_basics.py:## Обычная функция, которая складывает два числа
def add_regular(a, b):
return a + b
## Эквивалентная lambda-функция
add_lambda = lambda a, b: a + b
## Тестирование обеих функций
print(f"Обычная функция: 3 + 5 = {add_regular(3, 5)}")
print(f"Lambda-функция: 3 + 5 = {add_lambda(3, 5)}")python3 ~/project/lambda_basics.pyТеперь вы должны увидеть:
Квадрат 5 равен: 25
Обычная функция: 3 + 5 = 8
Lambda-функция: 3 + 5 = 8Lambda-функции наиболее полезны, когда:
Давайте создадим еще один пример с несколькими параметрами:
lambda_basics.py:## Lambda-функция с несколькими параметрами
calculate = lambda x, y, z: x * y + z
## Тестирование с разными значениями
result1 = calculate(2, 3, 4)
result2 = calculate(5, 2, 1)
print(f"2 * 3 + 4 = {result1}")
print(f"5 * 2 + 1 = {result2}")python3 ~/project/lambda_basics.pyВы должны увидеть дополнительный вывод:
2 * 3 + 4 = 10
5 * 2 + 1 = 11Lambda-функции идеально подходят для создания простых однострочных функций. Они предоставляют лаконичный способ написания кода, когда вам не нужно полное определение функции. На следующем шаге мы рассмотрим, как использовать lambda-функции со встроенными функциями Python для более мощных операций.
Lambda-функции становятся особенно мощными при сочетании со встроенными функциями Python, такими как map(), filter() и sorted(). Эти комбинации позволяют писать эффективный код для преобразования и обработки данных.
map() с LambdaФункция map() применяет заданную функцию к каждому элементу итерируемого объекта (например, списка) и возвращает объект map с результатами.
Создайте новый файл с именем lambda_builtin.py в каталоге /home/labex/project.
Добавьте следующий код, чтобы продемонстрировать использование map() с lambda:
## Использование map() с lambda-функцией для возведения в квадрат каждого числа в списке
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print("Исходные числа:", numbers)
print("Квадраты чисел:", squared_numbers)python3 ~/project/lambda_builtin.pyВы должны увидеть:
Исходные числа: [1, 2, 3, 4, 5]
Квадраты чисел: [1, 4, 9, 16, 25]filter() с LambdaФункция filter() создает новый итерируемый объект с элементами, удовлетворяющими условию (функция возвращает True).
lambda_builtin.py:## Использование filter() с lambda-функцией для поиска четных чисел
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print("Все числа:", numbers)
print("Четные числа:", even_numbers)
## Использование filter() для поиска имен, начинающихся с 'J'
names = ["Alice", "Bob", "John", "Jane", "Michael", "Jessica"]
j_names = list(filter(lambda name: name.startswith('J'), names))
print("Все имена:", names)
print("Имена, начинающиеся с J:", j_names)python3 ~/project/lambda_builtin.pyВы должны увидеть дополнительный вывод:
Все числа: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Четные числа: [2, 4, 6, 8, 10]
Все имена: ['Alice', 'Bob', 'John', 'Jane', 'Michael', 'Jessica']
Имена, начинающиеся с J: ['John', 'Jane', 'Jessica']sorted() с LambdaФункция sorted() позволяет сортировать итерируемые объекты, используя пользовательскую ключевую функцию (key function), где lambda-функции очень полезны.
lambda_builtin.py:## Использование sorted() с lambda для сортировки по второму элементу кортежей
pairs = [(1, 5), (3, 2), (5, 7), (2, 9), (4, 1)]
sorted_by_second = sorted(pairs, key=lambda pair: pair[1])
print("Исходные пары:", pairs)
print("Отсортировано по второму элементу:", sorted_by_second)
## Использование sorted() с lambda для сортировки строк по длине
words = ["apple", "banana", "cherry", "date", "elderberry", "fig"]
sorted_by_length = sorted(words, key=lambda word: len(word))
print("Исходные слова:", words)
print("Отсортировано по длине:", sorted_by_length)python3 ~/project/lambda_builtin.pyВы должны увидеть дополнительный вывод:
Исходные пары: [(1, 5), (3, 2), (5, 7), (2, 9), (4, 1)]
Отсортировано по второму элементу: [(4, 1), (3, 2), (1, 5), (5, 7), (2, 9)]
Исходные слова: ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig']
Отсортировано по длине: ['fig', 'date', 'apple', 'cherry', 'banana', 'elderberry']Вы также можете объединять или комбинировать несколько операций, используя lambda-функции:
lambda_builtin.py:## Комбинирование map и filter с lambda-функциями
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
## Сначала возвести числа в квадрат, затем отфильтровать значения больше 20
result = list(filter(lambda x: x > 20, map(lambda x: x**2, numbers)))
print("Исходные числа:", numbers)
print("Квадраты чисел > 20:", result)python3 ~/project/lambda_builtin.pyВы должны увидеть дополнительный вывод:
Исходные числа: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Квадраты чисел > 20: [25, 36, 49, 64, 81, 100]Lambda-функции со встроенными функциями, такими как map(), filter() и sorted(), предоставляют мощный способ обработки данных с минимальным количеством кода. На следующем шаге мы рассмотрим более практические применения lambda-функций.
В этом шаге мы рассмотрим некоторые практические применения лямбда-функций, включая их использование с условной логикой и способы применения в реальных сценариях.
Лямбда-функции могут включать условные выражения, используя синтаксис тернарного оператора Python: x if условие else y.
Создайте новый файл с именем lambda_practical.py в каталоге /home/labex/project.
Добавьте следующий код для демонстрации условных лямбда-функций:
## Лямбда-функция с условным выражением
get_status = lambda score: "Pass" if score >= 60 else "Fail"
## Тестирование функции с различными оценками
scores = [45, 90, 60, 30, 75]
for score in scores:
status = get_status(score)
print(f"Оценка: {score}, Статус: {status}")python3 ~/project/lambda_practical.pyВы должны увидеть:
Оценка: 45, Статус: Fail
Оценка: 90, Статус: Pass
Оценка: 60, Статус: Pass
Оценка: 30, Статус: Fail
Оценка: 75, Статус: PassЛямбда-функции идеально подходят для создания простых утилитных функций, таких как калькулятор:
lambda_practical.py:## Создание калькулятора с использованием лямбда-функций
operations = {
'add': lambda x, y: x + y,
'subtract': lambda x, y: x - y,
'multiply': lambda x, y: x * y,
'divide': lambda x, y: x / y if y != 0 else "Деление на ноль невозможно"
}
## Тестирование калькулятора
a, b = 10, 2
for operation, func in operations.items():
result = func(a, b)
print(f"{a} {operation} {b} = {result}")
## Тестирование деления на ноль
print(f"10 divide 0 = {operations['divide'](10, 0)}")python3 ~/project/lambda_practical.pyВы должны увидеть дополнительный вывод:
10 add 2 = 12
10 subtract 2 = 8
10 multiply 2 = 20
10 divide 2 = 5.0
10 divide 0 = Деление на ноль невозможноЛямбда-функции отлично подходят для преобразования структур данных:
lambda_practical.py:## Обработка списка словарей с помощью лямбда-функций
employees = [
{'name': 'Alice', 'salary': 90000, 'department': 'Engineering'},
{'name': 'Bob', 'salary': 75000, 'department': 'Marketing'},
{'name': 'Charlie', 'salary': 60000, 'department': 'Engineering'},
{'name': 'David', 'salary': 85000, 'department': 'HR'},
{'name': 'Eve', 'salary': 120000, 'department': 'Engineering'}
]
## Поиск сотрудников отдела Engineering и сортировка по зарплате
engineering_employees = sorted(
filter(lambda emp: emp['department'] == 'Engineering', employees),
key=lambda emp: emp['salary'],
reverse=True
)
print("Сотрудники отдела Engineering (сначала с наибольшей зарплатой):")
for employee in engineering_employees:
print(f" {employee['name']}: ${employee['salary']}")
## Вычисление средней зарплаты
average_salary = sum(map(lambda emp: emp['salary'], employees)) / len(employees)
print(f"\nСредняя зарплата: ${average_salary:.2f}")
## Поиск сотрудников с зарплатой выше средней
above_average = list(filter(lambda emp: emp['salary'] > average_salary, employees))
print(f"\nСотрудники с зарплатой выше средней:")
for employee in above_average:
print(f" {employee['name']}: ${employee['salary']} ({employee['department']})")python3 ~/project/lambda_practical.pyВы должны увидеть дополнительный вывод:
Сотрудники отдела Engineering (сначала с наибольшей зарплатой):
Eve: $120000
Alice: $90000
Charlie: $60000
Средняя зарплата: $86000.00
Сотрудники с зарплатой выше средней:
Alice: $90000 (Engineering)
Eve: $120000 (Engineering)Лямбда-функции часто используются в качестве обработчиков событий в приложениях с графическим интерфейсом. Давайте создадим простое приложение Tkinter для демонстрации этого:
lambda_gui.py в каталоге /home/labex/project:sudo apt update
sudo apt install python3-tk -y## ... (код калькулятора)python3 ~/project/lambda_gui.py
Теперь вы увидели, как лямбда-функции могут применяться в различных практических сценариях, от простой обработки данных до более сложных приложений, таких как графические интерфейсы и преобразование данных.
На этом заключительном шаге мы рассмотрим некоторые продвинутые методы использования lambda-функций, включая вложенные lambda, замыкания и функции высшего порядка.
Lambda-функции могут быть созданы и возвращены из других функций, что позволяет динамически создавать функции:
Создайте новый файл с именем lambda_advanced.py в каталоге /home/labex/project.
Добавьте следующий код:
## Функция, которая возвращает lambda-функцию
def create_multiplier(factor):
"""Возвращает функцию, которая умножает свой вход на заданный множитель."""
return lambda x: x * factor
## Создать конкретные функции умножения
double = create_multiplier(2)
triple = create_multiplier(3)
quadruple = create_multiplier(4)
## Протестировать функции умножения
number = 10
print(f"Исходное число: {number}")
print(f"Удвоенное: {double(number)}")
print(f"Утроенное: {triple(number)}")
print(f"Учетверенное: {quadruple(number)}")python3 ~/project/lambda_advanced.pyВы должны увидеть:
Исходное число: 10
Удвоенное: 20
Утроенное: 30
Учетверенное: 40Мы можем составлять функции, используя lambda, чтобы создать конвейер операций:
lambda_advanced.py:## Композиция функций с использованием lambda
def compose(f, g):
"""Возвращает функцию, которая применяет f после g."""
return lambda x: f(g(x))
## Создать компоненты функций
square = lambda x: x * x
increment = lambda x: x + 1
decrement = lambda x: x - 1
## Создать составные функции
square_then_increment = compose(increment, square)
increment_then_square = compose(square, increment)
complex_operation = compose(square, compose(increment, square))
## Протестировать составные функции
value = 5
print(f"\nИсходное значение: {value}")
print(f"square_then_increment: {square_then_increment(value)}") ## (5² = 25) + 1 = 26
print(f"increment_then_square: {increment_then_square(value)}") ## (5 + 1)² = 36
print(f"complex_operation: {complex_operation(value)}") ## ((5² = 25) + 1)² = 676python3 ~/project/lambda_advanced.pyВы должны увидеть дополнительный вывод:
Исходное значение: 5
square_then_increment: 26
increment_then_square: 36
complex_operation: 676Создание истинных рекурсивных lambda-функций является сложной задачей в Python из-за способа определения lambda. Однако мы можем использовать трюк с Y combinator, чтобы создать рекурсивные lambda-функции:
lambda_advanced.py:## Y combinator для создания рекурсивных lambda-функций
Y = lambda f: (lambda x: x(x))(lambda y: f(lambda *args: y(y)(*args)))
## Создание рекурсивной функции факториала с использованием lambda и Y combinator
factorial = Y(lambda f: lambda n: 1 if n <= 0 else n * f(n - 1))
## Протестировать рекурсивную функцию факториала
for i in range(6):
print(f"factorial({i}) = {factorial(i)}")
## Создание рекурсивной функции Фибоначчи с использованием lambda и Y combinator
fibonacci = Y(lambda f: lambda n: n if n <= 1 else f(n-1) + f(n-2))
## Протестировать рекурсивную функцию Фибоначчи
print("\nПоследовательность Фибоначчи:")
for i in range(10):
print(f"fibonacci({i}) = {fibonacci(i)}")python3 ~/project/lambda_advanced.pyВы должны увидеть дополнительный вывод:
factorial(0) = 1
factorial(1) = 1
factorial(2) = 2
factorial(3) = 6
factorial(4) = 24
factorial(5) = 120
Последовательность Фибоначчи:
fibonacci(0) = 0
fibonacci(1) = 1
fibonacci(2) = 1
fibonacci(3) = 2
fibonacci(4) = 3
fibonacci(5) = 5
fibonacci(6) = 8
fibonacci(7) = 13
fibonacci(8) = 21
fibonacci(9) = 34Частичное применение функции позволяет создавать новые функции, предварительно заполняя некоторые аргументы существующих функций:
lambda_advanced.py:from functools import partial
## Исходная функция с несколькими параметрами
def power(base, exponent):
return base ** exponent
## Создание специализированных функций с использованием partial и lambda
square = partial(power, exponent=2)
cube = partial(power, exponent=3)
## Альтернативный подход с использованием lambda
square_lambda = lambda x: power(x, 2)
cube_lambda = lambda x: power(x, 3)
## Протестировать оба подхода
number = 4
print(f"\nИсходное число: {number}")
print(f"square (partial): {square(number)}")
print(f"cube (partial): {cube(number)}")
print(f"square (lambda): {square_lambda(number)}")
print(f"cube (lambda): {cube_lambda(number)}")
## Частичное применение с несколькими предварительно заполненными аргументами
def format_string(prefix, content, suffix):
return f"{prefix}{content}{suffix}"
## Создать специализированные форматировщики
html_paragraph = partial(format_string, "<p>", suffix="</p>")
html_div = partial(format_string, "<div>", suffix="</div>")
## Протестировать специализированные форматировщики
content = "Hello, World!"
print(f"\nИсходное содержимое: {content}")
print(f"HTML paragraph: {html_paragraph(content)}")
print(f"HTML div: {html_div(content)}")python3 ~/project/lambda_advanced.pyВы должны увидеть дополнительный вывод:
Исходное число: 4
square (partial): 16
cube (partial): 64
square (lambda): 16
cube (lambda): 64
Исходное содержимое: Hello, World!
HTML paragraph: <p>Hello, World!</p>
HTML div: <div>Hello, World!</div>Эти продвинутые методы демонстрируют гибкость и мощь lambda-функций в Python. Комбинируя lambda-функции с функциями высшего порядка, функциональной композицией и частичным применением, вы можете создавать лаконичные и элегантные решения сложных задач.
В этой лабораторной работе вы узнали, как создавать и использовать встроенные функции (lambda-функции) в Python, переходя от базовых концепций к продвинутым методам.
Вот чего вы достигли:
Базовые Lambda-функции - Вы изучили синтаксис и базовое использование lambda-функций, сравнили их с обычными функциями и поняли, когда их следует использовать.
Lambda с встроенными функциями - Вы изучили, как объединять lambda-функции со встроенными функциями Python, такими как map(), filter() и sorted(), для эффективного выполнения мощных преобразований данных.
Практическое применение Lambda - Вы реализовали практические примеры, включая условные выражения, простой калькулятор и методы преобразования данных для обработки коллекций данных.
Продвинутые методы Lambda - Вы изучили функции высшего порядка, композицию функций, рекурсивные lambda-функции с использованием Y combinator и частичное применение функций для решения сложных задач лаконично.
Lambda-функции — мощный инструмент в программировании на Python, позволяющий использовать лаконичный функциональный стиль программирования. Хотя они лучше всего подходят для простых операций, их способность передаваться в качестве аргументов и возвращаться из функций делает их невероятно универсальными для широкого спектра приложений.
Освоив lambda-функции, вы добавили важный инструмент в свой инструментарий программирования на Python, который поможет вам писать более элегантный и эффективный код.
