函数参数的使用
Python函数参数的使用方法如下：
位置参数
位置参数：位置参数是指在调用函数时，按照函数定义时参数的位置顺序传递参数的方式。
例如：
def add(x, y): return x + y result = add(1, 2) print(result) # 输出3
在上面的例子中，add 函数有两个位置参数 x 和 y，在调用函数时，按照参数的位置顺序传递了两个参数，分别是 1 和 2。在使用位置参数时，需要按照函数定义时参数的位置顺序传递参数，以确保函数能够正确地执行。
关键字参数
关键字参数是指在调用函数时，使用形如 key=value 的语法显式地指定参数的名称和值。例如：
def add(x, y): return x + y result = add(y=2, x=1) print(result) # 输出3
在上面的例子中，调用 add 函数时，使用了关键字参数 x=1 和 y=2，这样可以明确指定参数的名称和值，避免了按照位置传参时可能出现的错误。关键字参数还可以与位置参数混合使用，但是必须先传递位置参数，然后再传递关键字参数.
默认参数
默认参数是指在定义函数时，给参数赋予一个默认值，如果在调用函数时没有传入该参数，则使用默认值。例如：
def add(x=0, y=0): return x + y result = add() print(result) # 输出0
在上面的例子中，add 函数有两个默认参数 x 和 y，它们的默认值都是 0。当调用 add 函数时，没有传入任何参数，因此函数使用了默认值计算结果，最终返回了 0。
可变参数
可变参数是指在函数定义时，使用 *args 的语法表示可以接收任意个数的位置参数，这些参数会被自动封装成一个元组，例如：
def add(*args): result = 0 for arg in args: result += arg return result result = add(1, 2, 3) print(result) # 输出6
在上面的例子中，add 函数使用了可变参数 *args，这样就可以接收任意个数的位置参数，这些参数会被封装成一个元组。在函数内部，使用循环遍历这个元组，计算所有参数的和，并返回结果。
关键字可变参数
关键字可变参数是指在函数定义时，使用 **kwargs 的语法表示可以接收任意个数的关键字参数，这些参数会被自动封装成一个字典，例如：
def add(**kwargs): result = 0 for key, value in kwargs.items(): result += value return result result = add(x=1, y=2, z=3) print(result) # 输出6
在上面的例子中，add 函数使用了关键字可变参数 **kwargs，这样就可以接收任意个数的关键字参数，这些参数会被封装成一个字典。在函数内部，使用循环遍历这个字典，计算所有参数的和，并返回结果。
调用 add 函数时，传入了三个关键字参数 x=1、y=2 和 z=3，这些参数被封装成一个字典 {‘x’: 1, ‘y’: 2, ‘z’: 3}，然后被传递给函数，函数计算这些参数的和并返回结果 6。
以上就是Python函数参数的使用方法。
函数的相互调用
函数的相互调用指的是，一个函数调用另一个函数，或者一个函数调用自身（递归调用)。函数的相互调用可以让程序更加模块化和可读性更高，因为可以将一个大问题拆分成多个小问题，每个小问题都由一个函数来解决。
举个栗子：
def add(x, y): return x + y def multiply(x, y): result = 0 for i in range(y): result = add(result, x) return result result = multiply(3, 4) print(result) # 输出12
在上面的例子中，add 函数用于计算两个数的和，multiply 函数用于计算两个数的乘积。在 multiply 函数内部，通过循环调用 add 函数来实现乘法运算，最终返回结果 12。
下面是一个递归调用的例子，演示了如何在函数内部调用自身：
def factorial(n): if n == 0: return 1 else: return n * factorial(n - 1) result = factorial(4) print(result) # 输出24
在上面的例子中，factorial 函数用于计算一个数的阶乘。在函数内部，使用递归调用来实现阶乘的计算，当 n 等于 0 时，返回 1，否则返回 n * factorial(n-1)。最终返回结果 24。
函数的作用域
函数的作用域指的是变量的可见范围，即变量可以被访问的区域。在 Python 中，函数的作用域分为两种，分别是全局作用域和局部作用域。
全局作用域
全局作用域指的是在函数外部定义的变量，它们可以在整个程序中被访问和修改。例如：
x = 10 def foo(): print(x) foo() # 输出10
在上面的例子中，变量 x 在函数外部定义，它的作用域是全局作用域。在 foo 函数内部，可以访问变量 x 并输出它的值。
如果在函数内部要修改全局作用域的变量，需要使用 global 关键字声明变量。例如：
x = 10 def foo(): global x x = 20 foo() print(x) # 输出20
在上面的例子中，使用 global 关键字声明变量 x，这样就可以在函数内部修改全局作用域的变量。在调用 foo 函数后，变量 x 的值被修改为 20。
局部作用域
局部作用域指的是在函数内部定义的变量，它们只能在函数内部被访问和修改。例如：
def foo(): x = 10 print(x) foo() # 输出10
数据的打包与拆包
数据打包
使用元组或列表可以实现打包操作，例如：
a = 10 b = "hello" c = [1, 2, 3] d = (a, b, c) print(d) # (10, 'hello', [1, 2, 3])
在上面的例子中，将元组d中的数据项分别赋值给变量a、b、c，这就是拆包操作。注意，拆包时变量的个数必须与元组或列表中的数据项个数相等，否则会抛出异常。
lambda函数
Lambda函数是一种匿名函数，它可以在需要一个函数的地方被使用，而不必显式地定义一个函数。Lambda函数通常用于一些简单的函数，可以在一行代码中完成。Lambda函数的语法如下:
lambda 参数: 表达式
其中，参数可以是多个，用逗号分隔，表达式是函数体，其结果就是函数的返回值。
下面举例说明Lambda函数的用法：
# 定义一个普通函数 def add(x, y): return x + y # 使用Lambda函数 f = lambda x, y: x + y # 调用函数 print(add(2, 3)) # 输出 5 print(f(2, 3)) # 输出 5
在上面的例子中，我们先定义了一个普通函数add，然后使用Lambda函数定义了一个等价的函数f。可以看到，使用Lambda函数定义函数比较简洁，而且可以直接把它赋值给一个变量。最后，我们调用了这两个函数，得到了相同的结果。
Lambda函数还可以用于函数的参数，例如：
# 使用Lambda函数作为参数 result = map(lambda x: x * x, [1, 2, 3, 4, 5]) # 输出结果 print(list(result)) # 输出 [1, 4, 9, 16, 25]
在上面的例子中，我们使用Lambda函数作为map函数的第一个参数，对列表中的每个元素求平方。注意，map函数返回的是一个迭代器，需要用list函数将其转化为列表。
递归
递归是在函数定义中使用函数自身的一种方法。递归函数通常具有两部分：基本情况和递归情况。基本情况是指在递归过程中需要结束递归的情况，递归情况是指在递归过程中需要调用函数自身的情况。递归函数的实现通常使用if语句来判断是否达到基本情况，如果达到，则直接返回结果；否则，继续调用函数自身，直到达到基本情况。
下面通过一个例子来说明递归函数的实现：
# 计算阶乘 def factorial(n): # 基本情况 if n == 0 or n == 1: return 1 # 递归情况 else: return n * factorial(n-1) # 测试 print(factorial(5)) # 输出 120
在上面的例子中，我们定义了一个函数factorial，用于计算n的阶乘。首先判断n是否为0或1，如果是，则直接返回1，这就是基本情况。否则，继续调用函数自身，计算(n-1)的阶乘，这就是递归情况。最终得到n的阶乘。
