python语法-def（）详细介绍（特别全）

1. 什么是函数

在 Python 中，函数是一种可重用的代码块，用于执行特定的任务或操作。函数可以接受输入参数，并返回输出结果，从而实现模块化和封装性编程的目的。Python 中定义函数的语法如下：

1. def function_name(parameters):
2. """
3. Function documentation string.
4. """
5. # Function body goes here.
6. return [expression]

其中，def 是定义函数的关键字，function_name 是函数的名称，parameters 是函数的参数列表，用圆括号包裹，多个参数之间用逗号分隔，如果没有参数，则留空即可。函数名称和参数列表组成了函数的签名（signature），用于唯一识别和调用该函数。

函数的主体部分由冒号和缩进的代码块组成，通常包含一些语句和表达式来完成具体的计算或操作。函数的文档字符串（documentation string）是一个可选的字符串，用于描述函数的作用、参数、返回值等信息，可以通过内置函数 help() 来查看。

函数执行完毕后，可以使用 return 语句来返回一个值（expression），也可以不返回任何值，此时默认返回 None。

下面是一个简单的示例，演示如何定义和调用一个函数：

1. def add_numbers(a, b):
2. """
3. Add two numbers and return the result.
4. """
5. return a + b
7. x = 3
8. y = 4
9. z = add_numbers(x, y)
10. print(z) # Output: 7

上面的示例中，我们定义了一个函数 add_numbers，它接受两个参数 a 和 b，并返回它们的和。然后，我们将 x 和 y 的值分别设置为 3 和 4，并调用 add_numbers 函数来计算它们的和，最后将结果赋给变量 z 并输出。

2. 函数参数

Python 中的函数可以接受多个参数，其中包括位置参数、默认参数、可变参数和关键字参数等不同类型的参数。下面一一进行介绍：

2.1 位置参数

位置参数是指按照参数的位置顺序传递的参数，也称为必选参数。当函数被调用时，需要按照函数定义中的参数列表依次传递相应数量的位置参数。例如：

1. def greet_user(name):
2. """
3. Greet the user with a personalized message.
4. """
5. print(f"Hello, {name}!")
7. greet_user("Alice") # Output: Hello, Alice!
8. greet_user("Bob") # Output: Hello, Bob!

在上面的示例中，我们定义了一个函数 greet_user，它接受一个位置参数 name，用于向用户发送个性化的问候消息。然后，我们分别调用 greet_user 函数，并传递不同的参数值，从而输出不同的问候消息。

2.2 默认参数

默认参数是指在函数定义时给定的固定参数值，它们可以被省略或者使用默认值。当函数被调用时，如果没有提供对应的参数，则会使用默认值代替。例如：

1. def greet_user(name, message="How are you doing?"):
2. """
3. Greet the user with a personalized message.
4. """
5. print(f"Hello, {name}! {message}")
7. greet_user("Alice") # Output: Hello, Alice! How are you doing?
8. greet_user("Bob", "Nice to meet you")# Output: Hello, Bob! Nice to meet you

在上面的示例中，我们修改了函数 greet_user 的定义，增加了一个默认参数 message，并设置其默认值为 "How are you doing?"。

然后，我们分别调用 greet_user 函数，并传递不同的参数值。第一个调用只提供了必选参数 name，因此使用了默认值 "How are you doing?" 来代替缺失的参数值。第二个调用则显式地提供了两个参数值，从而覆盖了默认值。在函数定义中，默认参数必须放在位置参数之后。

2.3 可变参数

可变参数是指能够接受任意数量的参数的函数，也称为不定长参数。在 Python 中，有两种类型的可变参数：*args 和 **kwargs。

*args 表示接受任意数量的位置参数，参数会被打包成一个元组（tuple），并传递给函数。例如：

1. def add_numbers(*nums):
2. """
3. Add any number of numbers and return the result.
4. """
5. total = 0
6. for num in nums:
7. total += num
8. return total
10. sum1 = add_numbers(1, 2, 3) # Output: 6
11. sum2 = add_numbers(4, 5, 6, 7, 8) # Output: 30

在上面的示例中，我们定义了一个函数 add_numbers，它使用可变参数 *nums 接受任意数量的位置参数，然后对它们进行求和并返回结果。注意，在函数内部使用循环对所有参数进行处理时，需要先将它们打包成一个元组。

**kwargs 表示接受任意数量的关键字参数，参数会被打包成一个字典（dict），并传递给函数。例如：

1. def print_info(**kwargs):
2. """
3. Print out the key-value pairs of any number of keyword arguments.
4. """
5. for key, value in kwargs.items():
6. print(f"{key}: {value}")
8. print_info(name="Alice", age=23, gender="female")
9. # Output:
10. # name: Alice
11. # age: 23
12. # gender: female

在上面的示例中，我们定义了一个函数 print_info，它使用可变参数 **kwargs 接受任意数量的关键字参数，然后依次输出每个参数的名称和值。

2.4 关键字参数

关键字参数是指按照形参名称显式地传递的参数，也称为命名参数。在函数调用时，可以使用形参名称来标识和传递对应的参数值。例如：

1. def greet_user(name, message="How are you doing?"):
2. """
3. Greet the user with a personalized message.
4. """
5. print(f"Hello, {name}! {message}")
7. greet_user(name="Alice") # Output: Hello, Alice! How are you doing?
8. greet_user(message="Nice to meet you", name="Bob") # Output: Hello, Bob! Nice to meet you

在上面的示例中，我们分别使用形参名称来指定要传递的参数值，从而更加清晰地表示了参数的含义和顺序。这在接口复杂或者参数数量较多的情况下尤为有用。

3. 函数作用域

在 Python 中，函数具有自己的作用域（scope），也就是变量和对象的访问范围。在函数内部定义的变量属于局部变量，只能在函数内部使用；而在函数外部定义的变量属于全局变量，可以在函数内部和外部使用。例如：

1. x = 10 # Global variable
3. def print_x():
4. """
5. Print out the value of global variable x.
6. """
7. print(x)
9. print_x() # Output: 10

在上面的示例中，我们定义了一个全局变量 x，然后在函数 print_x 中输出了它的值。由于 x 是全局变量，在函数内部可以直接访问和使用。

但是，如果我们试图在函数内部修改全局变量的值，则会出现错误。为了在函数内部修改全局变量的值，需要使用 global 关键字来声明：

1. x = 10 # Global variable
3. def modify_x():
4. """
5. Modify the value of global variable x.
6. """
7. global x
8. x = 20
10. modify_x()
11. print(x) # Output: 20

在上面的示例中，我们定义了一个全局变量 x，然后在函数 modify_x 中使用 global 关键字来声明 x 是全局变量，从而可以修改它的值。经过函数调用后，x 的值已经被修改为 20。

注意，在 Python 中，局部变量和全局变量的名称不能重复，否则会出现命名冲突和作用域错误。如果要在函数内部使用全局变量的值而不修改它，则可以使用 global 关键字来引用它，或者将其作为参数传递给函数。

4. 匿名函数

Python 中的匿名函数（lambda 函数）是一种特殊类型的函数，它没有名称，通常只包含一个表达式，并且可以接受任意数量的参数。匿名函数的语法如下：

lambda parameters: expression

其中，lambda 是关键字，parameters 是参数列表，多个参数之间用逗号分隔，如果没有参数，则留空即可。expression 是函数体，用于执行具体的计算或操作，并返回结果。

例如，下面是一个使用 lambda 函数来计算两个数的和的示例：

1. add_numbers = lambda x, y: x + y
3. sum1 = add_numbers(3, 4) # Output: 7
4. sum2 = add_numbers(-5, 10) # Output: 5

在上面的示例中，我们定义了一个匿名函数 add_numbers，它使用两个参数 x 和 y 来计算它们的和，并返回结果。然后，我们分别调用 add_numbers 函数，并传递不同的参数值，从而输出不同的结果。

匿名函数通常用于简单的、一次性的操作或者作为其他函数的参数传递。由于匿名函数没有名称，因此可以节省代码量并提高可读性。

5. 总结

在 Python 中，函数是一种可重用的代码块，用于执行特定的任务或操作。函数可以接受输入参数，并返回输出结果，从而实现模块化和封装性编程的目的。Python 中的函数有多种类型的参数，包括位置参数、默认参数、可变参数和关键字参数等。函数还具有自己的作用域，局部变量和全局变量的名称不能重复，需要使用 global 关键字来声明并修改全局变量的值。最后，Python 还支持匿名函数（lambda 函数），它通常用于简单的、一次性的操作或者作为其他函数的参数传递。

依旧是你们的萧萧吖！

点个关注吖！！