探寻Python函数的魅力：从新手到大师的蜕变之旅！

妖狐艹你老母 2024-03-23 18:53 84阅读 0赞

#### 文章目录 ####

*  一 函数介绍和定义
 *  二 函数的参数
 *   *  2.1 函数的传参定义
     *  2.2 函数参数种类
     *  2.3 函数形参和实参
     *  2.4 函数实参的传递方式
 *  三 函数的返回值
 *   *  3.1 返回值详解
     *  3.2  N o n e None None类型
     *  3.3 None类型的应用场景
 *  四 函数说明文档
 *  五 函数的嵌套调用
 *   *  5.1 演示函数的嵌套使用
     *  5.2 函数执行顺序分析
 *  六 变量的作用域
 *   *  6.1 全局变量的定义
 *  七 综合案例：ATM
 *  八 函数多返回值
 *  九 匿名函数
 *   *  9.1 函数作为函数参数传递
     *  9.2 函数传参总结
     *  9.3 Lambda匿名函数
 *  十 补充：函数式编程
 *  十一 补充：Python生成器

## 一 函数介绍和定义 ##

*  函数：是组织好的，可重复使用的，用来实现特定功能的代码段。  
    使用函数的好处是：
 *  将功能封装在函数内，可供随时随地重复利用
 *  提高代码的复用性，减少重复代码，提高开发效率
 *  函数的语法如下：
    
        def function_name(parameters):
            """
            Docstring (可选): 函数的文档字符串，用于描述函数的作用和使用方法。
            """
            # 函数体：包含执行特定任务的代码块
            # 可能包含一条或多条return语句，用于返回结果（可选）
 *  `def`: 定义函数的关键字，告诉Python要定义一个新的函数。
 *  `function_name`: 函数的名称，用于在其他地方调用函数时的标识。
 *  `parameters`: 函数的参数列表，用于在函数调用时传递数据给函数。参数是可选的，可以有零个或多个。
 *  `Docstring`: 可选的，但强烈建议提供。它是对函数的描述，通常用于文档生成和代码提示。
 *  函数体：包含一系列语句的代码块，用于实现函数的功能。
 *  `return`语句（可选）：函数可以使用`return`语句返回一个值。如果函数没有`return`语句，它默认返回`None`。
 *  Python函数的例子：

def add_numbers(a, b):
        """
        计算两个数的和并返回结果。
        """
        result = a + b
        return result

*  调用这个函数并获取结果

sum_result = add_numbers(3, 5)
    print(sum_result)  # 输出：8

## 二 函数的参数 ##

*  传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据

### 2.1 函数的传参定义 ###

*  基于函数的定义语法：

def 函数名(传入参数):
    	函数体
    	return 返回值

def add(x, y, z):
        result = x + y + z
        print(f"{
          x} + {
          y} + {
          z}的计算结果是：{
          result}")

*  函数定义中，提供的x和y，称之为：形式参数（形参），表示函数声明将要使用2个参数
    
     *  参数之间使用逗号进行分隔
 *  函数调用中，提供的5和6，称之为：实际参数（实参），表示函数执行时真正使用的参数值
    
     *  传入的时候，按照顺序传入数据，使用逗号分隔
 *  传入参数的数量是不受限制的。

--------------------

### 2.2 函数参数种类 ###

*  Python函数的参数可以分为以下几种类型：

1.  位置参数（Positional Arguments）:
    
     *  **位置参数是最常见的参数类型，它们按照在函数定义中声明的顺序依次接收传入的值。**
     *  **调用函数时，传入的参数将按照位置与参数一一对应。**
    
        def add_numbers(a, b):
            return a + b
        
        result = add_numbers(3, 5)  # 3传给a，5传给b
        print(result)  # 输出：8
2.  关键字参数（Keyword Arguments）:
    
     *  **关键字参数允许在函数调用时通过参数名来指定传入的值，这样可以不必遵循参数的位置顺序。**
    
        def greet(name, message):
            return f"Hello, {
                name}! {
                message}"
        
        result = greet(name="Alice", message="How are you?")
        print(result)  # 输出：Hello, Alice! How are you?
3.  默认参数（Default Arguments）:
    
     *  **默认参数允许在函数定义时为某些参数指定默认值。如果在函数调用时没有传递对应参数的值，将使用默认值。**
    
        def power(base, exponent=2):
            return base ** exponent
        
        result1 = power(3)     # 使用默认指数值2
        result2 = power(2, 4)  # 传入指数值4
        print(result1)  # 输出：9
        print(result2)  # 输出：16
4.  可变参数（Arbitrary Arguments）:
    
     *  **可变参数允许函数接受不定数量的参数。在函数定义中，可以使用星号（\*）来表示可变参数。**
     *  **可变参数在函数体内以元组（tuple）的形式存在。**
    
        def sum_numbers(*args):
            total = sum(args)
            return total
        
        result = sum_numbers(1, 2, 3, 4, 5)
        print(result)  # 输出：15
5.  关键字可变参数（Keyword Arbitrary Arguments）:
    
     *  关键字可变参数允许函数接受不定数量的关键字参数。
     *  在函数定义中，*使用双星号（\*\*）来表示关键字可变参数。关键字可变参数在函数体内以字典（dict）的形式存在。*
    
        def print_info(**kwargs):
            for key, value in kwargs.items():
                print(f"{
                key}: {
                value}")
        
        print_info(name="Alice", age=30, city="New York")
        # 输出：
        # name: Alice
        # age: 30
        # city: New York

### 2.3 函数形参和实参 ###

*  Python函数参数分为形参（形式参数）和实参（实际参数）。

1.  形参（形式参数）：
    
     *  **形参是函数定义时声明的参数，它们用于接收外部传入的值**。形参在函数定义的括号内列出，并用于在函数体内执行操作。
     *  **形参相当于函数内部的变量，其值在函数调用时由传入的实参确定。**
    
        def add_numbers(a, b):  # a和b是形参
            return a + b
2.  实参（实际参数）：
    
     *  **实参是在函数调用时传递给函数的具体数值或数据。它们是函数调用时提供的值，用于填充函数定义中的形参。**
     *  实参可以是常量、变量、表达式或其他函数的调用结果。
    
        result = add_numbers(3, 5)  # 3和5是实参，传递给函数的值

--------------------

### 2.4 函数实参的传递方式 ###

在函数调用时，**实参的传递方式可以通过位置（位置参数）或关键字（关键字参数）指定**：

1.  位置参数传递：
    
     *  实参按照在函数定义中形参出现的顺序进行传递。位置参数是默认的传递方式，如果没有指定参数名，则按照位置顺序传递。

def greet(name, message):
        return f"Hello, {
          name}! {
          message}"
    
    result = greet("Alice", "How are you?")  # 位置参数传递

1.  关键字参数传递：
    
     *  实参通过指定参数名进行传递，不必按照函数定义中形参的顺序。使函数调用更加清晰和易读。
    
        def greet(name, message):
            return f"Hello, {
                name}! {
                message}"
        
        result = greet(name="Alice", message="How are you?")  # 关键字参数传递
2.  默认实参
    
     *  可以使用默认参数（默认实参）为形参指定默认值。在函数调用时如果没有传递相应的实参，将使用默认值。
    
        def power(base, exponent=2):  # exponent有默认值2
            return base ** exponent
        
        result1 = power(3)     # 使用默认指数值2
        result2 = power(2, 4)  # 传入指数值4

## 三 函数的返回值 ##

### 3.1 返回值详解 ###

*  返回值：**函数执行完成后返回给调用者的结果。函数可以通过`return`语句来指定要返回的值。如果函数没有显式使用`return`语句，则默认返回`None`。**
 *  函数的返回值**在调用函数时可以被捕获并赋值给一个变量，或者直接用于表达式计算或其他操作。**
 *  返回值的类型**可以是任何Python数据类型，包括整数、浮点数、字符串、列表、字典等等。**
    
        def add_numbers(a, b):
            return a + b
        
        result = add_numbers(3, 5)
        print(result)  # 输出：8
 *  函数可以返回任意类型的数据。例如，返回一个字符串：
    
        def get_greeting(name):
            return f"Hello, {
                name}!"
        
        message = get_greeting("Alice")
        print(message)  # 输出：Hello, Alice!
 *  函数可以返回更复杂的数据类型，例如列表或字典：
    
        def get_even_numbers(limit):
            evens = []
            for i in range(1, limit + 1):
                if i % 2 == 0:
                    evens.append(i)
            return evens
        
        even_numbers = get_even_numbers(10)
        print(even_numbers)  # 输出：[2, 4, 6, 8, 10]

>  *  注意：**当函数执行到`return`语句时，函数的执行将立即终止，任何在`return`语句后面的代码都不会执行。如果函数没有`return`语句，则默认返回`None`。**

def no_return():
        print("This function has no return statement.")
    
    result = no_return()
    print(result)  # 输出：None

### 3.2  N o n e None None类型 ###

*  `None`是**一个特殊的数据类型，表示空值或缺失值。**
 *  它是Python的一个内置常量，用于表示一个不存在或未定义的对象。

`None`有以下特点：

1.  表示空值：`None`用于表示变量没有赋予具体的值或函数没有返回明确的结果。
2.  类型为`NoneType`：`None`是Python中唯一的`NoneType`对象，表示不指向任何有效的内存地址。
3.  单例对象：在Python中，`None`是一个单例对象，即在程序中只有一个`None`对象。因此，可以使用`is`运算符来检查一个变量是否为`None`，而不是使用相等运算符`==`。

*  标示空值演示：
    
        def my_function():
            # 这个函数没有返回值，即返回None
            print("This function does not return anything.")
        
        result = my_function()
        print(result)  # 输出：None
 *  单例对象演示：
    
        x = None
        y = None
        
        # 使用 is 运算符检查是否为 None
        if x is None:
            print("x is None")
        
        if y is None:
            print("y is None")
        
        # 输出：
        # x is None
        # y is None
 *  `None`通常用于表示函数没有返回值或在某些情况下作为函数的默认返回值。在编程过程中，当需要一个特殊值来表示缺失或无效的情况时，通常使用`None`。然而，需要注意的是，`None`并不等同于空字符串`''`或零`0`，它们是不同的数据类型。
 *  **None可以主动使用return返回，效果等同于不写return语句**

# 无return语句的函数返回值
    def say_hi():
        print("你好呀")
    
    result = say_hi()
    print(f"无返回值函数，返回的内容是：{
          result}")
    print(f"无返回值函数，返回的内容类型是：{
          type(result)}")
    
    # 主动返回None的函数
    def say_hi2():
        print("你好呀")
        return None
    
    result = say_hi2()
    print(f"无返回值函数，返回的内容是：{
          result}")
    print(f"无返回值函数，返回的内容类型是：{
          type(result)}")

### 3.3 None类型的应用场景 ###

None作为一个特殊的字面量，用于表示：空、无意义，其有非常多的应用场景。

1.  用在函数无返回值上
2.  用在if判断上
    
     *  在if判断中，None等同于False
     *  一般用于在函数中主动返回None，配合if判断做相关处理
3.  用于声明无内容的变量上
    
     *  定义变量，但暂时不需要变量有具体值，可以用None来代替

name=None

## 四 函数说明文档 ##

*  函数说明文档（函数文档字符串）：**一个用于描述函数功能和使用方法的文本字符串。它通常位于函数定义的第一行，紧跟在`def`语句后面，用三引号（`"""`）或单引号（`'''`）括起来。**

函数说明文档的作用如下：

1.  提供函数的目的和功能：函数说明文档应该清楚地描述函数的作用，它解决了什么问题，以及它执行了什么任务。
2.  描述函数的参数：文档应该列出函数接受的参数及其含义，包括每个参数的名称、数据类型、范围等信息。
3.  解释函数的返回值：文档应该描述函数的返回值类型以及可能的返回值。
4.  提供示例和用法：文档可以包含函数的使用示例，以及调用函数的方法和常见用例。
5.  帮助自动化文档生成：函数说明文档通常由文档生成工具（例如Sphinx）用来自动生成文档。

*  示例：

# 定义函数，进行文档说明
    def add(x, y):
        """
        add函数可以接收2个参数，进行2数相加的功能
        :param x: 形参x表示相加的其中一个数字
        :param y: 形参y表示相加的另一个数字
        :return: 返回值是2数相加的结果
        """
        result = x + y
        print(f"2数相加的结果是：{
          result}")
        return result
    add(5, 6)

*  使用`help()`函数来查看函数的说明文档。
    
        help(add)
    
     *  这将显示函数`add_numbers`的说明文档，以及其他信息（如果有的话）。
    
        Help on function add in module __main__:
        
        add(x, y)
            add函数可以接收2个参数，进行2数相加的功能
        
            :param x: 形参x表示相加的其中一个数字
            :param y: 形参y表示相加的另一个数字
            :return: 返回值是2数相加的结果
 *  **编写函数说明文档是一种良好的编程习惯，它有助于提高代码的可读性和可维护性，并方便其他开发人员使用你的函数。**

## 五 函数的嵌套调用 ##

*  函数的嵌套使用指的是**在一个函数的函数体内定义另一个函数**。这种做法允许我们在一个函数内部创建一个独立的子函数，以便更好地组织代码和实现复杂的功能。
 *  **嵌套函数的定义遵循普通函数的语法，它可以在外部函数的作用域内使用，但不能在外部函数之外的地方调用。**

### 5.1 演示函数的嵌套使用 ###

def outer_function():
        print("这是外部函数。")
    
        def inner_function():
            print("这是内部函数。")
    
        inner_function()
    
    outer_function()
    # 这是外部函数。
    # 这是内部函数。

*  内部函数可以访问外部函数的变量，但不能在外部函数的作用域之外使用。
    
     *  例如，在内部函数中使用外部函数的参数或局部变量：
    
        def outer_function(x):
            def inner_function(y):
                return x + y
        
            return inner_function
        
        add_five = outer_function(5)
        result = add_five(3)  # 等同于调用 inner_function(3)
        print(result)  # 输出：8
    
     *  `outer_function`返回了内部函数`inner_function`，内部函数捕获了外部函数的参数`x`，并在返回时保留了这个参数。我们可以在之后调用`add_five`函数，并将参数`3`传递给它，它会返回`5 + 3`的结果。
 *  案例详解

1.  首先，我们定义了一个外部函数 `outer_function(x)`，它接收一个参数 x。
2.  在`outer_function` 中，我们定义了一个内部函数 `inner_function(y)`，它接收一个参数 y。
3.  内部函数 `inner_function(y)` 的返回值是`x + y`，也就是参数 x 和 y 的和。
4.  在外部函数 `outer_function` 的最后，我们返回了内部函数 `inner_function`。这意味着当我们调用 `outer_function(x)` 时，它将返回内部函数 inner\_function。
5.  然后，我们在 `add_five = outer_function(5)`这一行中调用了 `outer_function`，将 5 作为参数传递给 x。这个调用返回了内部函数 `inner_function` 并将其赋值给变量 `add_five`。
6.  接着，我们在 `result = add_five(3)` 这一行中调用了 `add_five`，将 3 作为参数传递给 y。由于 `add_five` 实际上是内部函数 `inner_function`，它在调用时将使用之前传递给外部函数的参数 5（作为 x）和传递给内部函数的参数 3（作为 y）。因此，这个调用等同于执行 `inner_function(3)`。
7.  最后，`inner_function(3)` 的返回值是 `5 + 3`，即 8，这个结果被赋值给变量 `result`。

*  函数的嵌套使用是一种强大的技术，它允许我们创建更复杂的功能和模块化的代码结构。通过合理使用嵌套函数，我们可以提高代码的可读性、可维护性和重用性。

### 5.2 函数执行顺序分析 ###

*  如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

![在这里插入图片描述][737d6585a22f4bbc99d8ece9206dd6fa.png]

## 六 变量的作用域 ##

*  变量的作用域（Scope）指的是变量在程序中的可见性和访问性。作用域决定了在哪些地方可以访问变量以及变量的生命周期。
 *  Python中有以下几种变量作用域：

1.  全局作用域（Global Scope）：
    
     *  全局作用域中的变量在整个程序中都可见，可以在程序的任何地方进行访问。
     *  在函数之外定义的变量属于全局作用域。全局作用域中的变量在程序开始运行时创建，在程序结束时销毁。
    
        global_var = 10  # 全局变量，在全局作用域中
        
        def my_function():
            print(global_var)  # 可以在函数中访问全局变量
        
        my_function()  # 输出：10
2.  局部作用域（Local Scope）：
    
     *  局部作用域中的变量只在特定的代码块或函数内部可见。在函数内部定义的变量属于局部作用域。
     *  局部作用域中的变量在函数被调用时创建，在函数执行完毕后销毁。
    
        def my_function():
            local_var = 5  # 局部变量，在局部作用域中
            print(local_var)
        
        my_function()  # 输出：5
        # print(local_var)  # 这里会引发NameError，因为局部变量不在全局作用域中
3.  嵌套作用域（Enclosing Scope）：
    
     *  嵌套作用域是指在一个函数内部定义了另一个函数，内部函数可以访问外部函数的变量。**外部函数中的变量对于内部函数来说就属于嵌套作用域。**
     *  **嵌套作用域允许内部函数访问外部函数中的局部变量。**
    
        def outer_function():
            outer_var = 20  # 外部函数中的局部变量，在嵌套作用域中
        
            def inner_function():
                print(outer_var)  # 内部函数可以访问外部函数的变量
        
            inner_function()  # 输出：20
        
        outer_function()
4.  内置作用域（Built-in Scope）：
    
     *  内置作用域是指Python解释器中预定义的变量和函数，它们是内置的全局变量和函数，可以在程序的任何地方访问。
     *  例如：`print()`函数，`len()`函数等都属于内置作用域。
    
        print(len([1, 2, 3]))  # 输出：3

*  作用域规则的一般原则是：**在当前作用域内找不到变量时，会继续向上一级作用域查找，直到找到为止。如果在全局作用域中也找不到，则会引发`NameError`。** 因此，在编写代码时，要注意变量的作用域，确保正确访问变量并避免出现意外的错误。

### 6.1 全局变量的定义 ###

*  在Python中，全局变量是在程序的顶层定义的变量，它们在整个程序中都可见，包括在函数内部。
 *  全局变量在全局作用域中声明，也就是在函数之外或模块的最顶层定义的变量。全局变量可以在程序的任何地方访问和修改。

全局变量的定义遵循以下规则：

1.  在函数内部如果要修改全局变量的值，需要使用`global`关键字进行声明，告诉Python解释器这个变量是全局的，而不是局部的。
2.  如果在函数内部使用赋值语句给全局变量赋新值，而没有使用`global`关键字声明，Python会将其视为局部变量，而不是修改全局变量。

*  演示了全局变量的定义和使用：

global_var = 10  # 这是一个全局变量，在全局作用域中定义
    
    def my_function():
        # 试图修改全局变量，但没有使用 global 关键字
        global_var = 20  # 这将会创建一个新的局部变量，而不是修改全局变量
        print("Inside the function, global_var =", global_var)
    
    my_function()  # 输出：Inside the function, global_var = 20
    
    print("Outside the function, global_var =", global_var)  # 输出：Outside the function, global_var = 10

*  在函数内部试图修改全局变量 `global_var` 的值，但没有使用 `global` 关键字。这导致在函数内部创建了一个新的局部变量 `global_var`，而全局变量 `global_var` 的值没有改变。
 *  如果想要在函数内部修改全局变量，需要使用 `global` 关键字，如下所示：

global_var = 10  # 这是一个全局变量，在全局作用域中定义
    
    def my_function():
        global global_var
        global_var = 20  # 使用 global 关键字修改全局变量
        print("Inside the function, global_var =", global_var)
    
    my_function()  # 输出：Inside the function, global_var = 20
    
    print("Outside the function, global_var =", global_var)  # 输出：Outside the function, global_var = 20

*  在函数内部使用 `global` 关键字声明了 `global_var`，这样在函数内部对它的修改也会影响全局变量。

## 七 综合案例：ATM ##

*  定义一个全局变量：money，用来记录银行卡余额（默认5000000）
 *  定义一个全局变量：name，用来记录客户姓名（启动程序时输入）
 *  定义如下的函数：
    
     *  查询余额函数
     *  存款函数
     *  取款函数
     *  主菜单函数
 *  要求：
    
     *  程序启动后要求输入客户姓名
     *  查询余额、存款、取款后都会返回主菜单
     *  存款、取款后，都应显示一下当前余额
     *  客户选择退出或输入错误，程序会退出，否则一直运行

![在这里插入图片描述][f9bc4f965f9a485daa814a221eafb80f.png]

"""
    演示函数综合案例开发
    """
    
    # 定义全局变量money name
    money = 5000000
    name = None
    # 要求客户输入姓名
    name = input("请输入您的姓名：")
    # 定义查询函数
    def query(show_header):
        if show_header:
            print("-------------查询余额------------")
        print(f"{
          name}，您好，您的余额剩余：{
          money}元")
    
    
    # 定义存款函数
    def saving(num):
        global money    # money在函数内部定义为全局变量
        money += num
        print("-------------存款------------")
        print(f"{
          name}，您好，您存款{
          num}元成功。")
    
        # 调用query函数查询余额
        query(False)
    
    # 定义取款函数
    def get_money(num):
        global money
        money -= num
        print("-------------取款------------")
        print(f"{
          name}，您好，您取款{
          num}元成功。")
    
        # 调用query函数查询余额
        query(False)
    # 定义主菜单函数
    def main():
        print("-------------主菜单------------")
        print(f"{
          name}，您好，欢迎来到黑马银行ATM。请选择操作：")
        print("查询余额\t[输入1]")
        print("存款\t\t[输入2]")
        print("取款\t\t[输入3]")    # 通过\t制表符对齐输出
        print("退出\t\t[输入4]")
        return input("请输入您的选择：")
    
    # 设置无限循环，确保程序不退出
    while True:
        keyboard_input = main()
        if keyboard_input == "1":
            query(True)
            continue    # 通过continue继续下一次循环，一进来就是回到了主菜单
        elif keyboard_input == "2":
            num = int(input("您想要存多少钱？请输入："))
            saving(num)
            continue
        elif keyboard_input == "3":
            num = int(input("您想要取多少钱？请输入："))
            get_money(num)
            continue
        else:
            print("程序退出啦")
            break       # 通过break退出循环

## 八 函数多返回值 ##

*  在Python中，函数可以返回多个返回值，这是通过将多个值打包为一个元组（或其他可迭代对象）来实现的。
 *  在函数体中，可以使用`return`语句返回包含多个值的元组，然后在函数调用时可以解包并获取这些值。

--------------------

*  以下是一个简单的示例，演示函数返回多个值：
    
        def get_name_and_age():
            name = "Alice"
            age = 30
            return name, age
        
        result = get_name_and_age()
        print(result)  # 输出：('Alice', 30)
        
        name, age = get_name_and_age()
        print(name)  # 输出：Alice
        print(age)   # 输出：30
    
     *  在例子中，函数`get_name_and_age()`返回了一个包含两个值的元组：`('Alice', 30)`。在函数调用时，我们可以将返回值赋值给一个变量，Python会自动将元组中的每个值分配给对应的变量，这称为解包。
 *  除了使用元组，函数还可以返回其他类型的可迭代对象，如列表、集合或字典。解包的过程与元组类似，只需确保在函数调用时正确匹配变量数量和类型即可。
    
     *  使用列表返回多个值：
    
        def get_numbers():
            return [1, 2, 3, 4, 5]
        
        numbers_list = get_numbers()
        print(numbers_list)  # 输出：[1, 2, 3, 4, 5]
    
     *  使用字典返回多个值：
    
        def get_person_info():
            return {
              "name": "Alice", "age": 30, "city": "New York"}
        
        person_info = get_person_info()
        print(person_info)  # 输出：{'name': 'Alice', 'age': 30, 'city': 'New York'}
 *  通过返回多个值，我们可以更方便地从函数中获取多个相关的结果，并且可以利用这些结果进行后续的处理。

## 九 匿名函数 ##

### 9.1 函数作为函数参数传递 ###

*  在Python中，函数是一等公民，这意味着函数可以作为参数传递给其他函数。这种能力称为高阶函数（Higher-order functions）。
 *  通过将函数作为参数传递，我们可以实现更加灵活和动态的功能，使代码更加简洁和可复用。
 *  函数作为参数传递的常见用途是在高阶函数中使用，例如`map()`、`filter()`、`reduce()`等内置函数，以及其他自定义的高阶函数。这些函数接受一个或多个函数作为参数，并对其进行操作。
 *  下面是一个简单的示例，演示如何将函数作为参数传递给另一个函数：
    
        def add(x, y):
            return x + y
        
        def subtract(x, y):
            return x - y
        
        def calculate(operation, x, y):
            return operation(x, y)
        
        result1 = calculate(add, 3, 5)       # 调用calculate函数，传递add函数作为参数
        result2 = calculate(subtract, 10, 4)  # 调用calculate函数，传递subtract函数作为参数
        
        print(result1)  # 输出：8
        print(result2)  # 输出：6
 *  定义了三个函数：`add`用于相加，`subtract`用于相减，以及`calculate`作为高阶函数接收一个操作函数作为参数，并在内部调用该操作函数进行计算。
 *  当我们调用`calculate(add, 3, 5)`时，它会执行`add(3, 5)`，返回`8`。同样，调用`calculate(subtract, 10, 4)`会执行`subtract(10, 4)`，返回`6`。
 *  通过函数作为参数传递，我们可以在运行时动态选择不同的操作函数，从而实现更加灵活和通用的功能。这在处理列表、数据集合、排序和过滤等任务时非常有用。

### 9.2 函数传参总结 ###

1.  **函数本身是可以作为参数，传入另一个函数中进行使用的**。
2.  **将函数传入的作用在于：传入计算逻辑，而非传入数据。**
    
     *  将函数作为参数传入的主要作用是传入计算逻辑，而非传入具体的数据。这种做法使**得代码更加灵活和通用，能够适应不同的情况和需求。**
     *  通过将计算逻辑作为参数传入，我们可以实现更加通用的高阶函数，让这些函数能够适用于不同的数据集合或具体的需求，而不需要重复编写相似的功能。
     *  例如，在上面的示例中，`calculate`函数接受一个操作函数作为参数，这个操作函数可以是`add`、`subtract`或其他函数，它们执行不同的计算逻辑。而`calculate`函数本身不关心具体的计算细节，只是负责调用传入的操作函数，从而完成相应的计算。
     *  **这样的设计使得代码更加模块化和可维护。当需要新增或修改特定的计算逻辑时，我们只需定义新的函数，并将其传递给高阶函数，而不需要修改高阶函数的实现。**

*  这种函数作为参数传递的特性在函数式编程中非常常见，它允许我们使用更抽象、更灵活的方式来编写代码，提高了代码的可复用性和扩展性。这也是Python等动态语言的优势之一。

### 9.3 Lambda匿名函数 ###

*  匿名函数也被称为lambda函数，是一种简单的函数定义方式，用于创建一次性的、简短的函数。
 *  匿名函数使用`lambda`关键字定义，它可以只包含一个表达式，并且返回该表达式的结果。
 *  匿名函数的语法如下：
    
        lambda arguments: expression
    
     *  `arguments`是函数的参数列表，可以包含零个或多个参数，用逗号分隔。
     *  `expression`是函数体，是一个单行表达式（只能写一行，无法写多行代码），用于计算并返回结果。
 *  匿名函数的简单例子：

add = lambda x, y: x + y
    print(add(3, 5))  # 输出：8

"""
    演示lambda匿名函数
    """
    
    
    # 定义一个函数，接受其它函数输入
    def test_func(compute):
        result = compute(1, 2)
        print(f"结果是:{
          result}")
    
    
    # 通过lambda匿名函数的形式，将匿名函数作为参数传入
    def add(x, y):
        return x + y
    
    
    test_func(add)
    test_func(lambda x, y: x + y)

*  使用def和使用lambda，定义的函数功能完全一致，只是lambda关键字定义的函数是匿名的，无法二次使用
 *  匿名函数通常**用于传递简单的功能（如排序或过滤函数）作为参数给其他高阶函数，以便在不需要定义完整函数的情况下实现特定功能**。然而，由于匿名函数的表达式限制在单行内，所以它的功能通常相对简单，**复杂的逻辑最好使用普通函数来实现。**

## 十 补充：函数式编程 ##

**函数式编程认识**

*  **函数式编程（Functional Programming）是一种编程范式**，它*将计算视为函数之间的数学运算，强调使用纯函数（Pure Functions）和避免改变状态和可变数据。*
 *  ***在函数式编程中，函数被视为一等公民，可以作为参数传递给其他函数，也可以作为返回值返回。***

**函数式编程的主要特点**

1.  **纯函数（Pure Functions）**：纯函数是指具有以下两个特性的函数：
    
     *  相同的输入总是产生相同的输出，即不会受到除输入参数以外的任何状态或数据的影响。
     *  不会修改任何外部状态或数据，即没有副作用（Side Effects）。

*  纯函数的使用可以简化代码的推理和测试，因为它们不会引入隐藏的状态变化和依赖关系。
    
     *  纯函数示例：
    
        # 纯函数：相同的输入总是产生相同的输出，没有副作用
        def add(x, y):
            return x + y
        
        result = add(3, 5)
        print(result)  # 输出：8

1.  **不可变性（Immutability）**：在函数式编程中，数据通常是不可变的，即一旦创建就不能被修改。如果需要修改数据，应该创建一个新的副本，而不是直接修改原始数据。
    
     *  不可变性示例：
    
        # 不可变性：使用元组表示不可变数据
        person = ("Alice", 30, "New York")
        name, age, city = person
        print(name)  # 输出：Alice
        
        # 尝试修改元组的值会引发 TypeError
        # person[1] = 35  # 报错：'tuple' object does not support item assignment
2.  **高阶函数（Higher-order Functions）**：函数可以作为参数传递给其他函数，也可以作为返回值返回。高阶函数可以接受函数作为参数，并使用它们来实现通用的操作。
    
     *  高阶函数示例：

# 高阶函数：接受函数作为参数的函数
    def apply_operation(func, x, y):
        return func(x, y)
    
    def add(x, y):
        return x + y
    
    def subtract(x, y):
        return x - y
    
    result1 = apply_operation(add, 3, 5)       # 调用apply_operation函数，传递add函数作为参数
    result2 = apply_operation(subtract, 10, 4)  # 调用apply_operation函数，传递subtract函数作为参数
    
    print(result1)  # 输出：8
    print(result2)  # 输出：6

1.  **递归（Recursion）**：函数式编程鼓励使用递归来解决问题，而不是使用循环。
    
     *  递归示例：
    
        # 递归：计算阶乘
        def factorial(n):
            if n == 0:
                return 1
            else:
                return n * factorial(n - 1)
        
        result = factorial(5)
        print(result)  # 输出：120
2.  **延迟计算（Lazy Evaluation）**：函数式编程支持延迟计算，即只在需要时才计算表达式的值。
    
     *  延迟计算示例：
    
        # 延迟计算：使用生成器表达式计算平方数
        numbers = [1, 2, 3, 4, 5]
        
        # 使用生成器表达式计算平方数，只在需要时计算
        squares = (x * x for x in numbers)
        # 打印squares，注意squares是一个生成器对象
        print(squares)  # 输出：<generator object <genexpr> at 0x...>
        
        # 转换为列表来获取计算结果
        squares_list = list(squares)
        print(squares_list)  # 输出：[1, 4, 9, 16, 25]
    
     *  解释：
     *  生成器表达式，它类似于列表推导式，但是返回一个生成器对象而不是列表。生成器表达式用圆括号括起来，并且以类似于列表推导式的形式定义了一个表达式`(x * x)`，其中x是来自`numbers`列表的每个元素。生成器表达式在这里用于计算每个元素的平方数，但并没有立即计算，而是在需要时才进行计算。

--------------------

*  函数式编程的**优势在于它能够提高代码的清晰性、可读性和可维护性。它避免了许多副作用和共享状态带来的复杂性，从而减少了bug的产生。**
 *  **函数式编程也适合于并行和并发编程，因为没有共享状态可以避免竞争条件。**
 *  Python支持函数式编程，虽然它不是一种纯粹的函数式编程语言，但你仍然可以在Python中使用函数式编程的思想和技巧来编写更加优雅和健壮的代码。

## 十一 补充：Python生成器 ##

*  Python生成器（Generator）是一种特殊类型的迭代器，它允许在需要时按需生成值，而不是提前生成所有值并保存在内存中。
 *  生成器使用函数中的`yield`关键字来定义，每次调用生成器函数时，它会执行到`yield`语句处，并返回一个值。然后，生成器会在`yield`处暂停执行，并保留当前的状态，等待下一次调用继续执行。

生成器的特点：

1.  延迟计算：生成器是按需计算的，每次调用生成器函数时，它才会执行一部分代码并生成一个值。这样可以节省内存，特别在处理大型数据集时非常有用。
2.  状态保留：生成器会保留其内部状态，即生成器函数中的局部变量的值。每次调用生成器函数时，它会从上一次暂停的地方继续执行。
3.  只能遍历一次：由于生成器是一种迭代器，它们只能遍历一次。一旦生成器的所有值都被访问过，或者生成器函数执行完毕，就无法再次遍历。

*  下面是一个生成器示例，展示了如何定义和使用生成器：
    
        def squares_generator(n):
            for i in range(n):
                yield i * i
        
        # 创建生成器对象
        squares = squares_generator(5)
        
        # 遍历生成器并输出每个值
        for square in squares:
            print(square)
        
        # 由于生成器只能遍历一次，再次遍历将没有输出
        for square in squares:
            print(square)  # 没有输出
 *  上面的例子中，定义了一个生成器函数`squares_generator(n)`，它会生成 0 0 0到 n − 1 n-1 n−1之间的整数的平方数。在生成器函数中，我们使用`yield`语句生成每个平方数，并在生成器暂停执行时保留当前状态。然后，我们创建了一个生成器对象`squares`，并使用`for`循环遍历生成器，并输出每个平方数。
 *  注意：**由于生成器只能遍历一次，再次遍历将不会有输出，因为生成器已经执行完毕。如果要再次使用生成器，需要重新创建一个新的生成器对象。**

[737d6585a22f4bbc99d8ece9206dd6fa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/fda6b7e43b794132bd168e8ada390752.png
[f9bc4f965f9a485daa814a221eafb80f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0a59eac439cd4553ab19c771ed0c529c.png