51工具盒子Python 函数是一个返回特定任务的语句块,其理念是将一些常用或重复的任务放在一起，创建一个函数，这样我们就可以通过调用函数来重用其中的代码，而不是为不同的输入一遍又一遍地编写相同的代码。这篇文章，我们将详细地分析 Python函数。
使用函数的一些好处：
- 增加代码可读性
- 增加代码重用性
函数声明 {#函数声明}
Python中，声明函数的语法如下图：
函数类型 {#函数类型}
Python的函数主要包含 2种类型：
- 内置库函数：这些是 Python 中可用的标准函数。
- 用户定义函数：我们可以根据需求创建自己的函数。
创建函数 {#创建函数}
我们可以使用 def 关键字在 Python 中定义一个函数。我们可以根据需要向其添加任何类型的功能和属性。通过以下示例，我们可以理解如何在 Python 中编写函数。通过这种方式，我们可以使用 def 关键字创建 Python 函数定义。
|---------------|----------------------------------------------------------|
| 1 2 3 | # 一个简单的 Python 函数 def fun(): print("欢迎来到 猿Java") |
在 Python 中调用函数 {#在-Python-中调用函数}
在 Python 中创建函数后，我们可以通过使用函数名后跟包含该特定函数参数的括号来调用它。以下是调用 def 函数 Python 的示例。
|---------------------|----------------------------------------------------------------------------|
| 1 2 3 4 5 6 | # 一个简单的 Python 函数 def fun(): print("欢迎来到 猿Java") # 调用函数的驱动代码 fun() |
输出：
|-----------|--------------------|
| 1 | 欢迎来到 猿Java |
带参数的 Python 函数 {#带参数的-Python-函数}
如果你有 C/C++ 或 Java 的经验，那么你一定会想到函数的返回类型和参数的数据类型。这在 Python 中也是可能的（特别是对于 Python 3.5 及以上版本）。
带参数的 Python 函数语法
|-----------------|----------------------------------------------------------------------------------------------|
| 1 2 3 4 | def function_name(parameter: data_type) -> return_type: """文档字符串""" # 函数体 return 表达式 |
以下示例使用了参数和参数，如果不理解，你可以稍后再回来学习。
|---------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 | def add(num1: int, num2: int) -> int: """添加两个数字""" num3 = num1 + num2 return num3 # 驱动代码 num1, num2 = 5, 15 ans = add(num1, num2) print(f"{num1} 和 {num2} 的和是 {ans}。") |
输出：
|-----------|------------------------|
| 1 | 5 和 15 的和是 20。 |
注意：以下示例是使用语法 1 定义的，尝试将它们转换为语法 2 进行练习。
|------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | # 一些更多的函数 def is_prime(n): if n in [2, 3]: return True if (n == 1) or (n % 2 == 0): return False r = 3 while r * r <= n: if n % r == 0: return False r += 2 return True print(is_prime(78), is_prime(79)) |
输出：
|-----------|--------------------|
| 1 | False True |
Python 函数参数 {#Python-函数参数}
参数是传递给函数括号内的值。一个函数可以有任意数量的参数，用逗号分隔。
在这个例子中，我们将创建一个简单的 Python 函数来检查传递给函数的数字是偶数还是奇数。
|------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 | # 一个简单的 Python 函数来检查 x 是偶数还是奇数 def evenOdd(x): if (x % 2 == 0): print("偶数") else: print("奇数") # 调用函数的驱动代码 evenOdd(2) evenOdd(3) |
输出：
|-------------|---------------|
| 1 2 | 偶数 奇数 |
Python 函数参数的类型 {#Python-函数参数的类型}
Python 支持多种类型的参数，可以在函数调用时传递。在 Python 中，我们有以下几种函数参数类型：
- 默认参数
- 关键字参数（命名参数）
- 位置参数
- 任意参数（可变长度参数 *args 和 **kwargs）
让我们详细讨论每种类型。
默认参数 {#默认参数}
默认参数是如果在函数调用中没有为该参数提供值，则该参数假定的默认值。以下示例说明了在 Python 中使用默认参数来编写函数。
|-----------------------|----------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 | # 展示默认参数的 Python 程序 def myFun(x, y=50): print("x: ", x) print("y: ", y) # 驱动代码（我们只用一个参数调用 myFun()） myFun(10) |
输出：
|-------------|-----------------------|
| 1 2 | x: 10 y: 50 |
与 C++ 的默认参数类似，函数中的任何数量的参数都可以有默认值。但是，一旦我们有了一个默认参数，其右侧的所有参数也必须有默认值。
关键字参数 {#关键字参数}
这个想法是允许调用者使用值指定参数名，这样调用者就不需要记住参数的顺序。
|-----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 | # 展示关键字参数的 Python 程序 def student(firstname, lastname): print(firstname, lastname) # 关键字参数 student(firstname='Geeks', lastname='Practice') student(lastname='Practice', firstname='Geeks') |
输出：
|-------------|---------------------------------------|
| 1 2 | Geeks Practice Geeks Practice |
位置参数 {#位置参数}
我们在函数调用期间使用位置参数，这样第一个参数（或值）被分配给 name，第二个参数（或值）被分配给 age。通过更改位置，或者如果你忘记了位置的顺序，值可能会被用在错误的位置，如下面的 Case-2 示例所示，其中 27 被分配给 name，而 Suraj 被分配给 age。
|------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 | def nameAge(name, age): print("Hi, I am", name) print("My age is ", age) # 你会得到正确的输出，因为参数是按顺序给出的 print("Case-1:") nameAge("Suraj", 27) # 你会得到不正确的输出，因为参数不按顺序 print("\nCase-2:") nameAge(27, "Suraj") |
输出：
|---------------------|-----------------------------------------------------------------------------------|
| 1 2 3 4 5 6 | Case-1: Hi, I am Suraj My age is 27 Case-2: Hi, I am 27 My age is Suraj |
任意关键字参数 {#任意关键字参数}
在 Python 中，任意关键字参数 *args 和 **kwargs 可以使用特殊符号向函数传递可变数量的参数。有两个特殊符号：
- *args 在 Python 中（非关键字参数）
- **kwargs 在 Python 中（关键字参数）
示例 1：可变长度非关键字参数
|---------------------|----------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 | # 展示 *args 用于可变数量的参数的 Python 程序 def myFun(*argv): for arg in argv: print(arg) myFun('Hello', 'Welcome', 'to', 'GeeksforGeeks') |
输出：
|-----------------|----------------------------------------|
| 1 2 3 4 | Hello Welcome to GeeksforGeeks |
示例 2：可变长度关键字参数
|-----------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 | # 展示 **kwargs 用于可变数量的关键字参数的 Python 程序 def myFun(**kwargs): for key, value in kwargs.items(): print("%s == %s" % (key, value)) # 驱动代码 myFun(first='Geeks', mid='for', last='Geeks') |
输出：
|---------------|-------------------------------------------------|
| 1 2 3 | first == Geeks mid == for last == Geeks |
文档字符串 {#文档字符串}
函数后的第一个字符串称为文档字符串，简称 Docstring。它用于描述函数的功能。函数中使用文档字符串是可选的，但被认为是一种良好的实践。
以下语法可用于打印出函数的文档字符串。
语法：print(function_name.__doc__)
示例：向函数添加文档字符串
|---------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 | # 一个简单的 Python 函数，用于检查 x 是偶数还是奇数 def evenOdd(x): """检查数字是偶数还是奇数的函数""" if (x % 2 == 0): print("偶数") else: print("奇数") # 调用函数的驱动代码 print(evenOdd.__doc__) |
输出：
|-----------|------------------------|
| 1 | 检查数字是偶数还是奇数的函数 |
Python 函数中的函数
在另一个函数中定义的函数称为内部函数或嵌套函数。嵌套函数可以访问封闭范围的变量。使用内部函数的目的是将它们与外部发生的一切隔离开来。
|---------------------------------|-------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 9 10 11 | # 展示访问嵌套函数的变量的 Python 程序 def f1(): s = '我爱 GeeksforGeeks' def f2(): print(s) f2() # 驱动代码 f1() |
输出：
|-----------|--------------------------|
| 1 | 我爱 GeeksforGeeks |
Python 中的匿名函数 {#Python-中的匿名函数}
在 Python 中，匿名函数意味着没有名字的函数。我们已经知道 def 关键字用于定义普通函数，而 lambda 关键字用于创建匿名函数。
|-----------------------|-----------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 | # 使用 lambda 函数演示求一个数的立方 def cube(x): return x*x*x cube_v2 = lambda x : x*x*x print(cube(7)) print(cube_v2(7)) |
输出：
|-------------|-----------------|
| 1 2 | 343 343 |
Python 中的递归函数 {#Python-中的递归函数}
Python 中的递归指的是函数调用自身。在许多情况下，我们需要构建递归函数来解决数学和递归问题。
使用递归函数时应谨慎，因为递归函数可能会变成类似于无限循环的情况。在创建递归函数时，最好检查退出条件。
|-----------------------|-----------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 | def factorial(n): if n == 0: return 1 else: return n * factorial(n - 1) print(factorial(4)) |
输出：
|-----------|------------|
| 1 | 24 |
这里我们创建了一个递归函数来计算数字的阶乘。你可以看到这个函数的结束条件是当 n 等于 0 时。
Python 函数中的返回语句 {#Python-函数中的返回语句}
函数返回语句用于退出函数并返回到函数调用者，并将指定的值或数据项返回给调用者。返回语句的语法是：
|-----------|----------------------------------|
| 1 | return [expression_list] |
返回语句可以包含一个变量、一个表达式或一个常量，这些在函数执行结束时返回。如果没有上述任何内容与返回语句一起出现，则返回一个 None 对象。
示例：Python 函数返回语句
|---------------------|-----------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 | def square_value(num): """此函数返回输入数字的平方值""" return num**2 print(square_value(2)) print(square_value(-4)) |
输出：
|-------------|--------------|
| 1 2 | 4 16 |
按引用传递和按值传递 {#按引用传递和按值传递}
需要注意的一件重要事情是，在 Python 中，每个变量名都是一个引用。当我们将变量传递给函数时，会创建一个到对象的新引用。在 Python 中参数传递与 Java 中的引用传递相同。
|-------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 | # 这里 x 是对同一个列表 lst 的新引用 def myFun(x): x[0] = 20 # 驱动代码（注意函数调用后 lst 被修改） lst = [10, 11, 12, 13, 14, 15] myFun(lst) print(lst) |
输出：
|-----------|----------------------------------|
| 1 | [20, 11, 12, 13, 14, 15] |
当我们传递一个引用并将接收到的引用更改为其他内容时，传递和接收参数之间的连接就会断开。例如，考虑以下程序：
|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 | def myFun(x): # 下面这行代码将 x 与之前的对象的链接断开。一个新对象被分配给 x。 x = [20, 30, 40] # 驱动代码（注意函数调用后 lst 没有被修改） lst = [10, 11, 12, 13, 14, 15] myFun(lst) print(lst) |
输出：
|-----------|----------------------------------|
| 1 | [10, 11, 12, 13, 14, 15] |
另一个示例演示了如果我们在函数内部分配一个新值，引用链接将被断开。
|-------------------------|--------------------------------------------------------------------------------------------------------------------|
| 1 2 3 4 5 6 7 8 | def myFun(x): # 下面这行代码将 x 与之前的对象的链接断开。一个新对象被分配给 x。 x = 20 # 驱动代码（注意函数调用后 x 没有被修改） x = 10 myFun(x) print(x) |
输出：
|-----------|------------|
| 1 | 10 |
常见问题 {#常见问题}
Python 中的函数是什么？ {#Python-中的函数是什么？}
Python 函数是一个代码块，仅在被调用时运行。它被编程来返回特定任务。你可以在函数中传递称为参数的值。它有助于执行重复的任务。
Python 中的函数有哪 4 种类型？ {#Python-中的函数有哪-4-种类型？}
Python 中的主要函数类型是：
- 内置函数
- 用户定义函数
- Lambda 函数
- 递归函数
如何在 Python 中编写函数？ {#如何在-Python-中编写函数？}
要在 Python 中编写函数，你可以使用 def 关键字，然后编写函数名。你可以在使用 : 后提供函数代码。定义函数的基本语法是：
|-------------|-----------------------------------|
| 1 2 | def function_name(): # 语句 |
Python 中函数的参数是什么？ {#Python-中函数的参数是什么？}
Python 中的参数是调用函数时传递的值所接收的变量。一个函数可以有任意数量的参数。你还可以在 Python 中为参数设置默认值。
Python 主函数是什么？ {#Python-主函数是什么？}
Python 主函数是指 Python 程序的入口点。通常使用 if __name__ == "__main__": 结构来定义，以确保某些代码仅在脚本直接运行时执行，而不是在作为模块导入时执行。
总结 {#总结}
Python函数是一种代码块，用于执行特定任务或计算。函数通过def关键字定义，包含函数名、参数列表和函数体。调用函数时，可以传递参数，函数将返回结果。函数提高代码重用性和可读性，支持默认参数、可变参数和关键字参数。内置函数如print()、len()常用，用户也可自定义函数。函数支持嵌套、递归及匿名函数（lambda）。使用文档字符串（docstring）可为函数添加说明。函数是Python编程中的核心概念，有助于组织和简化代码。
