LabEx
登录免费加入

如何在 Python 中创建内联函数

PythonBeginner
立即练习

导言

在 Python 编程的世界里，内联函数提供了一种强大而简洁的方式，用于创建小的、单表达式函数，而无需正式的函数定义。这些内联函数，在 Python 中被称为 lambda 函数，特别适用于简单的操作和函数式编程技术。本教程将指导你创建和使用 lambda 函数，以编写更优雅、更高效的 Python 代码。

这是一个实验（Guided Lab），提供逐步指导来帮助你学习和实践。请仔细按照说明完成每个步骤，获得实际操作经验。根据历史数据，这是一个 中级 级别的实验，完成率为 71%。获得了学习者 100% 的好评率。

理解 Lambda 函数基础

什么是 Lambda 函数

在 Python 中，lambda 函数是使用 lambda 关键字定义的小型匿名函数，而不是使用标准的 def 语句。它们被称为“匿名”函数，因为它们不像传统函数那样需要名称。

lambda 函数的基本语法是：

lambda arguments: expression

Lambda 函数仅限于单个表达式，并自动返回该表达式的结果。

创建你的第一个 Lambda 函数

让我们创建并测试一些简单的 lambda 函数：

  1. 在你的代码编辑器中打开一个新的 Python 文件。在 WebIDE 中点击“File” > “New File”，并将其保存为 /home/labex/project 目录下的 lambda_basics.py。

  2. 添加以下代码来创建你的第一个 lambda 函数：

## 一个简单的 lambda 函数，用于计算一个数的平方
square = lambda x: x * x

## 测试 lambda 函数
result = square(5)
print(f"5 的平方是：{result}")
  1. 通过打开终端（如果尚未打开）并执行以下命令来运行你的代码：
python3 ~/project/lambda_basics.py

你应该看到输出：

5 的平方是：25

Lambda 函数 vs. 常规函数

让我们比较一下 lambda 函数及其等效的常规函数：

  1. 将以下代码添加到你的 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)}")
  1. 再次运行你的代码：
python3 ~/project/lambda_basics.py

你现在应该看到：

5 的平方是：25
常规函数：3 + 5 = 8
Lambda 函数：3 + 5 = 8

何时使用 Lambda 函数

Lambda 函数在以下情况下最有用：

  • 你需要一个简单的函数，且使用时间较短
  • 函数逻辑可以用一行代码表示
  • 你想将一个函数作为参数传递给另一个函数

让我们再创建一个包含多个参数的示例：

  1. 将以下代码添加到你的 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}")
  1. 运行你更新后的代码：
python3 ~/project/lambda_basics.py

你应该看到额外的输出：

2 * 3 + 4 = 10
5 * 2 + 1 = 11

Lambda 基础总结

Lambda 函数非常适合创建简单的、单行函数。当你不需要完整的函数定义时，它们提供了一种简洁的编写代码的方式。在下一步中，我们将探讨如何将 lambda 函数与 Python 的内置函数一起使用，以进行更强大的操作。

将 Lambda 与内置函数一起使用

当与 Python 的内置函数（如 map()、filter() 和 sorted()）结合使用时，lambda 函数会变得特别强大。这些组合允许你编写用于数据转换和操作的高效代码。

map() 函数与 Lambda

map() 函数将给定的函数应用于可迭代对象（如列表）中的每个项目，并返回一个包含结果的 map 对象。

  1. 在 /home/labex/project 目录中创建一个名为 lambda_builtin.py 的新文件。

  2. 添加以下代码来演示如何将 map() 与 lambda 一起使用：

## 使用 map() 和 lambda 函数来计算列表中每个数字的平方
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))

print("原始数字：", numbers)
print("平方后的数字：", squared_numbers)
  1. 运行你的代码：
python3 ~/project/lambda_builtin.py

你应该看到：

原始数字：[1, 2, 3, 4, 5]
平方后的数字：[1, 4, 9, 16, 25]

filter() 函数与 Lambda

filter() 函数创建一个新 的可迭代对象，其中包含满足条件的元素（函数返回 True）。

  1. 将以下代码添加到你的 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)
  1. 运行你更新后的代码：
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 函数对可迭代对象进行排序，lambda 函数在这里非常有用。

  1. 将以下代码添加到你的 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)
  1. 运行你更新后的代码：
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 函数链式或组合多个操作：

  1. 将以下代码添加到你的 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)
  1. 运行你更新后的代码：
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 函数的更多实际应用。

实用的 Lambda 应用

在本步骤中，我们将探索 Lambda 函数的一些实际应用，包括其在条件逻辑中的使用以及如何在实际场景中使用它们。

带条件表达式的 Lambda

Lambda 函数可以使用 Python 的三元运算符语法包含条件表达式：x if condition else y。

  1. 在 /home/labex/project 目录中创建一个名为 lambda_practical.py 的新文件。

  2. 添加以下代码以演示带条件的 Lambda 函数：

## 带条件表达式的 Lambda
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}")
  1. 运行你的代码：
python3 ~/project/lambda_practical.py

你应该看到：

分数: 45, 状态: Fail
分数: 90, 状态: Pass
分数: 60, 状态: Pass
分数: 30, 状态: Fail
分数: 75, 状态: Pass

使用 Lambda 创建简单的计算器

Lambda 函数非常适合创建简单的实用函数，例如计算器：

  1. 将以下代码添加到你的 lambda_practical.py 文件中：
## 使用 Lambda 函数创建计算器
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 除以 0 = {operations['divide'](10, 0)}")
  1. 运行你的代码：
python3 ~/project/lambda_practical.py

你应该看到额外的输出：

10 add 2 = 12
10 subtract 2 = 8
10 multiply 2 = 20
10 divide 2 = 5.0
10 除以 0 = 无法除以零

使用 Lambda 进行数据转换

Lambda 函数非常适合转换数据结构：

  1. 将以下代码添加到你的 lambda_practical.py 文件中：
## 使用 Lambda 处理字典列表
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_employees = sorted(
    filter(lambda emp: emp['department'] == 'Engineering', employees),
    key=lambda emp: emp['salary'],
    reverse=True
)

print("工程部门员工（按薪资从高到低）：")
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']})")
  1. 运行更新后的代码：
python3 ~/project/lambda_practical.py

你应该看到额外的输出：

工程部门员工（按薪资从高到低）：
  Eve: $120000
  Alice: $90000
  Charlie: $60000

平均薪资: $86000.00

薪资高于平均值的员工：
  Alice: $90000 (Engineering)
  Eve: $120000 (Engineering)

Lambda 作为 Tkinter 的事件处理程序

Lambda 函数常用于 GUI 应用程序中的事件处理程序。让我们创建一个简单的 Tkinter 应用程序来演示这一点：

  1. 将以下代码添加到名为 lambda_gui.py 的新文件中，该文件位于 /home/labex/project 目录中：
sudo apt update
sudo apt install python3-tk -y
import tkinter as tk

## 创建一个简单的计算器 GUI
def create_calculator():
    ## 创建主窗口
    window = tk.Tk()
    window.title("Lambda 计算器")
    window.geometry("300x200")

    ## 创建输入字段
    num1_label = tk.Label(window, text="第一个数字：")
    num1_label.pack(pady=5)
    num1_entry = tk.Entry(window)
    num1_entry.pack(pady=5)

    num2_label = tk.Label(window, text="第二个数字：")
    num2_label.pack(pady=5)
    num2_entry = tk.Entry(window)
    num2_entry.pack(pady=5)

    result_label = tk.Label(window, text="结果： ")
    result_label.pack(pady=10)

    ## 创建按钮框架
    button_frame = tk.Frame(window)
    button_frame.pack(pady=10)

    ## 使用 Lambda 函数创建操作按钮
    operations = ['+', '-', '*', '/']

    for op in operations:
        ## 使用 Lambda 作为按钮点击处理程序
        ## 使用默认参数以避免后期绑定问题
        button = tk.Button(
            button_frame,
            text=op,
            width=3,
            command=lambda op=op: calculate(op, num1_entry, num2_entry, result_label)
        )
        button.pack(side=tk.LEFT, padx=5)

    window.mainloop()

def calculate(operation, num1_entry, num2_entry, result_label):
    try:
        num1 = float(num1_entry.get())
        num2 = float(num2_entry.get())

        ## 使用 Lambda 函数创建操作字典
        operations = {
            '+': lambda x, y: x + y,
            '-': lambda x, y: x - y,
            '*': lambda x, y: x * y,
            '/': lambda x, y: x / y if y != 0 else "无法除以零"
        }

        result = operations[operation](num1, num2)
        result_label.config(text=f"结果： {result}")
    except ValueError:
        result_label.config(text="请输入有效数字")
    except Exception as e:
        result_label.config(text=f"错误： {str(e)}")

## 运行计算器
if __name__ == "__main__":
    create_calculator()
  1. 让我们在 LabEx 桌面界面中运行代码，因为 Tkinter 是一个 GUI 库，我们无法在 VS Code 终端中运行它。
python3 ~/project/lambda_gui.py
Lambda 计算器 GUI 示例

现在你已经了解了如何在各种实际场景中应用 Lambda 函数，从简单的 数据处理到更复杂的应用程序，例如 GUI 和数据转换。

高级 Lambda 技术

在最后一步中，我们将探讨一些使用 lambda 函数的高级技术，包括嵌套 lambda、闭包和高阶函数。

从函数返回 Lambda 函数

Lambda 函数可以从其他函数创建和返回，从而允许动态函数创建：

  1. 在 /home/labex/project 目录中创建一个名为 lambda_advanced.py 的新文件。

  2. 添加以下代码：

## 返回 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:{double(number)}")
print(f"Triple:{triple(number)}")
print(f"Quadruple:{quadruple(number)}")
  1. 运行你的代码：
python3 ~/project/lambda_advanced.py

你应该看到：

原始数字：10
Double：20
Triple：30
Quadruple：40

使用 Lambda 进行函数组合

我们可以使用 lambda 组合函数来创建一系列操作：

  1. 将以下代码添加到你的 lambda_advanced.py 文件中：
## 使用 lambda 进行函数组合
def compose(f, g):
    """返回一个在 g 之后应用 f 的函数。"""
    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)² = 676
  1. 运行你更新后的代码：
python3 ~/project/lambda_advanced.py

你应该看到额外的输出：

原始值：5
square_then_increment：26
increment_then_square：36
complex_operation：676

递归 Lambda 函数

由于 lambda 的定义方式，在 Python 中创建真正的递归 lambda 函数具有挑战性。但是，我们可以使用 Y 组合子 的技巧来创建递归 lambda 函数：

  1. 将以下代码添加到你的 lambda_advanced.py 文件中：
## 用于创建递归 lambda 函数的 Y 组合子
Y = lambda f: (lambda x: x(x))(lambda y: f(lambda *args: y(y)(*args)))

## 使用 lambda 和 Y 组合子创建递归阶乘函数
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 组合子创建递归斐波那契函数
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)}")
  1. 运行你更新后的代码：
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 与部分函数应用

部分函数应用允许你通过预先填充现有函数的一些参数来创建新函数：

  1. 将以下代码添加到你的 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)}")
  1. 运行你更新后的代码：
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 函数与高阶函数、函数组合和部分应用相结合，你可以为复杂问题创建简洁而优雅的解决方案。

总结

在这个实验中，你已经学习了如何在 Python 中创建和使用内联函数（lambda 函数），从基本概念到高级技术，逐步深入。

以下是你已经完成的内容：

  1. 基本 Lambda 函数 - 你学习了 lambda 函数的语法和基本用法，将它们与常规函数进行了比较，并理解了何时使用它们。

  2. Lambda 与内置函数 - 你探索了如何将 lambda 函数与 Python 的内置函数（如 map()、filter() 和 sorted()）结合使用，以高效地执行强大的数据转换。

  3. 实际的 Lambda 应用 - 你实现了实际的例子，包括条件表达式、一个简单的计算器和数据转换技术，以处理数据集合。

  4. 高级 Lambda 技术 - 你探索了高阶函数、函数组合、使用 Y 组合子的递归 lambda 函数以及部分函数应用，以简洁地解决复杂问题。

Lambda 函数是 Python 编程中的一个强大工具，它允许简洁的、函数式的编程风格。虽然它们最适合简单的操作，但它们作为参数传递和从函数返回的能力使它们在广泛的应用中具有令人难以置信的多功能性。

通过掌握 lambda 函数，你已经为你的 Python 编程工具包添加了一个重要的工具，这将帮助你编写更优雅和高效的代码。

相关 Python 课程
Python 快速入门

Python 快速入门

python
Python 速查表

Python 速查表

python
Python 实践挑战

Python 实践挑战

python