介绍
function 是一个执行动作的指令块，一旦定义，就可以重用。 函数使代码更加模块化，允许您一遍又一遍地使用相同的代码。
Python 有许多您可能熟悉的内置函数，包括：
print()将对象打印到终端int()将字符串或数字数据类型转换为整数数据类型len()返回对象的长度
函数名称包括括号，并且可能包括参数。
在本教程中，我们将介绍如何定义您自己的函数以在您的编码项目中使用。
先决条件
您应该在您的计算机或服务器上安装 Python 3 并设置编程环境。 如果您没有设置编程环境，您可以参考本地编程环境或服务器上的编程环境适合您的操作的安装和设置指南系统（Ubuntu、CentOS、Debian 等）
定义函数
让我们从翻经典的“Hello, World!”开始吧。 将 编程到一个函数中。
我们将在我们选择的文本编辑器中创建一个新的文本文件，并调用程序 hello.py。 然后，我们将定义函数。
通过使用 def 关键字定义函数，后跟您选择的名称，后跟一组括号，其中包含函数将采用的任何参数（它们可以为空），并以冒号结尾。
Info: 要跟随本教程中的示例代码，请通过运行 python3 命令在本地系统上打开 Python 交互式 shell。 然后，您可以通过在 >>> 提示符后添加示例来复制、粘贴或编辑示例。
在这种情况下，我们将定义一个名为 hello() 的函数：
你好.py
def hello():
这设置了用于创建函数的初始语句。
从这里开始，我们将添加带有 4 个空格缩进的第二行，以提供函数功能的说明。 在这种情况下，我们将 Hello, World! 打印到控制台：
你好.py
def hello():
print("Hello, World!")
我们的函数现在已经完全定义好了，但是如果我们此时运行程序，什么都不会发生，因为我们没有调用函数。
所以，在我们定义的函数块之外，让我们用 hello() 调用函数：
你好.py
def hello():
print("Hello, World!")
hello()
现在，让我们运行程序：
python hello.py
您应该收到以下输出：
OutputHello, World!
函数可以比我们上面定义的 hello() 函数更复杂。 例如，我们可以在功能块中使用 for 循环 、 条件语句 等。
例如，下面定义的函数利用条件语句检查 name 变量的输入是否包含元音，然后使用 for 循环遍历 [ 中的字母X206X] 字符串。
名称.py
# Define function names()
def names():
# Set up name variable with input
name = str(input('Enter your name: '))
# Check whether name has a vowel
if set('aeiou').intersection(name.lower()):
print('Your name contains a vowel.')
else:
print('Your name does not contain a vowel.')
# Iterate over name
for letter in name:
print(letter)
# Call the function
names()
我们上面定义的 names() 函数设置了一个条件语句和一个 for 循环，展示了如何在函数定义中组织代码。 但是，根据我们对程序的意图以及我们希望如何设置代码，我们可能希望将条件语句和 for 循环定义为两个独立的函数。
在程序中定义函数使我们的代码模块化和可重用，这样我们就可以调用相同的函数而无需重写它们。
使用参数
到目前为止，我们已经研究了带有空括号且不带参数的函数，但是我们可以在函数定义中的括号内定义参数。
parameter 是函数定义中的命名实体，指定函数可以接受的参数。
让我们创建一个小程序，接收参数 x、y 和 z。 我们将创建一个函数，将参数添加到不同的配置中。 这些总和将由函数打印。 然后我们将调用该函数并将数字传递给该函数。
add_numbers.py
def add_numbers(x, y, z):
a = x + y
b = x + z
c = y + z
print(a, b, c)
add_numbers(1, 2, 3)
我们将数字 1 传递给 x 参数，2 传递给 y 参数， 3 传递给 z 参数。 这些值按照给定的顺序与每个参数对应。
该程序本质上是根据我们传递给参数的值进行以下数学运算：
a = 1 + 2 b = 1 + 3 c = 2 + 3
该函数还打印 a、b 和 c，根据上面的数学，我们期望 a 等于 [X135X ]，b 为 4，c 为 5。 让我们运行程序：
python add_numbers.py
Output3 4 5
当我们将 1、2 和 3 作为参数传递给 add_numbers() 函数时，我们会收到预期的输出。
参数是通常在函数定义中定义为变量的参数。 当您运行方法时，可以为它们赋值，将参数传递给函数。
关键字参数
除了按顺序调用参数外，还可以在函数调用中使用关键字参数，调用者通过参数名称来识别参数。
当您使用关键字参数时，您可以乱序使用参数，因为 Python 解释器将使用提供的关键字将值与参数匹配。
让我们创建一个函数，向我们显示用户的个人资料信息。 我们将以 username（作为字符串）和 followers（作为整数）的形式向它传递参数。
配置文件.py
# Define function with parameters
def profile_info(username, followers):
print("Username: " + username)
print("Followers: " + str(followers))
在函数定义语句中，username 和 followers 包含在 profile_info() 函数的括号中。 该函数块使用两个参数将有关用户的信息打印为字符串。
现在，我们可以调用该函数并为其分配参数：
配置文件.py
def profile_info(username, followers):
print("Username: " + username)
print("Followers: " + str(followers))
# Call function with parameters assigned as above
profile_info("sammyshark", 945)
# Call function with keyword arguments
profile_info(username="AlexAnglerfish", followers=342)
在第一个函数调用中，我们使用 sammyshark 的用户名和 945 的用户名填写信息，在第二个函数调用中，我们使用关键字参数，为参数变量赋值。
让我们运行程序：
python profile.py
OutputUsername: sammyshark Followers: 945 Username: AlexAnglerfish Followers: 342
输出向我们显示了两个用户的用户名和关注者数量。
这也允许我们修改参数的顺序，就像在这个具有不同调用的同一程序的示例中一样：
配置文件.py
def profile_info(username, followers):
print("Username: " + username)
print("Followers: " + str(followers))
# Change order of parameters
profile_info(followers=820, username="cameron-catfish")
当我们再次使用 python profile.py 命令运行程序时，我们将收到以下输出：
OutputUsername: cameron-catfish Followers: 820
因为函数定义维护 print() 语句的相同顺序，如果我们使用关键字参数，我们将它们传递给函数调用的顺序无关紧要。
默认参数值
我们还可以为其中一个或两个参数提供默认值。 让我们为 followers 参数创建一个默认值，其值为 1：
配置文件.py
def profile_info(username, followers=1):
print("Username: " + username)
print("Followers: " + str(followers))
现在，我们可以只分配用户名函数来运行该函数，并且关注者的数量将自动默认为 1。 如果我们愿意，我们仍然可以更改关注者的数量。
配置文件.py
def profile_info(username, followers=1):
print("Username: " + username)
print("Followers: " + str(followers))
profile_info(username="JOctopus")
profile_info(username="sammyshark", followers=945)
当我们使用 python profile.py 命令运行程序时，我们将收到以下输出：
OutputUsername: JOctopus Followers: 1 Username: sammyshark Followers: 945
为默认参数提供值可以让我们跳过为每个已经具有默认值的参数定义值。
返回值
可以将参数值传递给函数，函数也可以产生值。
函数可以使用 return 语句生成一个值，该语句将退出函数，并且 可选地 将表达式传递回调用者。 如果使用不带参数的 return 语句，函数将返回 None。
到目前为止，我们在函数中使用了 print() 语句而不是 return 语句。 让我们创建一个程序，而不是打印将返回一个变量。
在一个名为 square.py 的新文本文件中，我们将创建一个对参数 x 求平方并返回变量 y 的程序。 我们发出调用以打印 result 变量，该变量是通过运行 square() 函数并传入 3 形成的。
正方形.py
def square(x):
y = x ** 2
return y
result = square(3)
print(result)
我们可以运行程序并接收输出：
python square.py
Output9
整数 9 作为输出返回，这就是我们要求 Python 求 3 的平方时所期望的结果。
为了进一步了解 return 语句的工作原理，我们可以将程序中的 return 语句注释掉：
正方形.py
def square(x):
y = x ** 2
# return y
result = square(3)
print(result)
现在，让我们再次运行程序：
python square.py
OutputNone
此处不使用 return 语句，程序无法返回值，因此该值默认为 None。
再举一个例子，在上面的 add_numbers.py 程序中，我们可以将 print() 语句换成 return 语句。
add_numbers.py
def add_numbers(x, y, z):
a = x + y
b = x + z
c = y + z
return a, b, c
sums = add_numbers(1, 2, 3)
print(sums)
在函数之外，我们将变量 sums 设置为等于函数获取 1、2 和 3 的结果，就像我们上面所做的那样。 然后我们调用了 sums 变量的打印。
现在让我们再次运行程序，因为它有 return 语句：
python add_numbers.py
Output(3, 4, 5)
我们收到与之前使用函数中的 print() 语句收到的相同数字 3、4 和 5 作为输出。 这次它作为 tuple 传递，因为 return 语句的 表达式列表 至少有一个逗号。
函数在遇到 return 语句时立即退出，无论它们是否返回值。
return_loop.py
def loop_five():
for x in range(0, 25):
print(x)
if x == 5:
# Stop function at x == 5
return
print("This line will not execute.")
loop_five()
在 for 循环中使用 return 语句结束函数，因此循环外的行将不会运行。 相反，如果我们使用了 break 语句，那么此时只有循环会退出，最后的 print() 行会运行。
return 语句退出函数，并在发出参数时可能返回一个值。
使用 main() 作为函数
虽然在 Python 中你可以调用程序底部的函数并且它会运行（正如我们在上面的示例中所做的那样），但许多编程语言（如 C++ 和 Java）需要一个 main 函数才能运行执行。 包含一个 main() 函数，虽然不是必需的，但可以以一种合乎逻辑的方式构建我们的 Python 程序，将程序中最重要的组件放入一个函数中。 它还可以让非 Python 程序员更容易阅读我们的程序。
我们将从在上面的 hello.py 程序中添加一个 main() 函数开始。 我们将保留我们的 hello() 函数，然后定义一个 main() 函数：
你好.py
def hello():
print("Hello, World!")
def main():
在 main() 函数中，让我们包含一个 print() 语句，让我们知道我们在 main() 函数中。 此外，让我们在 main() 函数中调用 hello() 函数：
你好.py
def hello():
print("Hello, World!")
def main():
print("This is the main function")
hello()
最后，在程序的底部，我们将调用 main() 函数：
你好.py
def hello():
print("Hello, World!")
def main():
print("This is the main function.")
hello()
main()
此时，我们可以运行我们的程序：
python hello.py
我们将收到以下输出：
OutputThis is the main function. Hello, World!
因为我们在 main() 中调用了 hello() 函数，然后只调用了 main() 来运行，所以 Hello, World! 文本只打印了一次，在告诉我们的字符串之后在主要功能中。
接下来我们将使用多个函数，因此值得回顾一下全局变量和局部变量的变量范围。 如果您在功能块中定义变量，您将只能在该功能中使用该变量。 如果您想跨函数使用变量，最好声明一个全局变量。
在 Python 中，'__main__' 是顶级代码将执行的范围的名称。 当程序从标准输入、脚本或交互式提示符运行时，其 __name__ 设置为等于 '__main__'。
因此，有一个约定使用以下结构：
if __name__ == '__main__':
# Code to run when this is the main program here
这允许使用程序文件：
- 作为主程序并运行
if语句之后的内容 - 作为一个模块，而不是运行
if语句之后的内容。
任何未包含在此语句中的代码都将在运行时执行。 如果您将程序文件用作模块，则不在此语句中的代码也将在运行辅助文件时在其导入时执行。
让我们扩展上面的 names.py 程序，并创建一个名为 more_names.py 的新文件。 在这个程序中，我们将声明一个全局变量并修改我们原来的 names() 函数，以便指令在两个离散函数中。
第一个函数 has_vowel() 将检查 name 字符串是否包含元音。
第二个函数 print_letters() 将打印 name 字符串的每个字母。
more_names.py
# Declare global variable name for use in all functions
name = str(input('Enter your name: '))
# Define function to check if name contains a vowel
def has_vowel():
if set('aeiou').intersection(name.lower()):
print('Your name contains a vowel.')
else:
print('Your name does not contain a vowel.')
# Iterate over letters in name string
def print_letters():
for letter in name:
print(letter)
有了这个设置，让我们定义 main() 函数，它将包含对 has_vowel() 和 print_letters() 函数的调用。
more_names.py
# Declare global variable name for use in all functions
name = str(input('Enter your name: '))
# Define function to check if name contains a vowel
def has_vowel():
if set('aeiou').intersection(name.lower()):
print('Your name contains a vowel.')
else:
print('Your name does not contain a vowel.')
# Iterate over letters in name string
def print_letters():
for letter in name:
print(letter)
# Define main method that calls other functions
def main():
has_vowel()
print_letters()
最后，我们将在文件底部添加 if __name__ == '__main__': 结构。 出于我们的目的，由于我们已将所有想要执行的函数放在 main() 函数中，因此我们将在 if 语句之后调用 main() 函数。
more_names.py
# Declare global variable name for use in all functions
name = str(input('Enter your name: '))
# Define function to check if name contains a vowel
def has_vowel():
if set('aeiou').intersection(name.lower()):
print('Your name contains a vowel.')
else:
print('Your name does not contain a vowel.')
# Iterate over letters in name string
def print_letters():
for letter in name:
print(letter)
# Define main method that calls other functions
def main():
has_vowel()
print_letters()
# Execute main() function
if __name__ == '__main__':
main()
我们现在可以运行程序：
python more_names.py
该程序将显示与 names.py 程序相同的输出，但这里的代码更有条理，无需修改即可以模块化方式使用。
如果您不想声明 main() 函数，您也可以像这样结束程序：
more_names.py
...
if __name__ == '__main__':
has_vowel()
print_letters()
使用 main() 作为函数和 if __name__ == '__main__': 语句可以以逻辑方式组织您的代码，使其更具可读性和模块化。
结论
函数是在程序中执行操作的指令代码块，有助于使我们的代码可重用和模块化。
要了解有关如何使代码更加模块化的更多信息，您可以阅读我们关于 如何在 Python 3 中编写模块 的指南。
