函数的特点：
（1）、使用 def 关键字定义，有函数名。使用 lambda 定义的函数除外。
（2）、一个函数通常执行一个特定任务，可多次调用，因此函数是代码利用的重要手段。
（3）、函数调用时可以传递0个或多个参数。
（4）、函数有返回值。
一、 函数基础
函数是 Python 程序的重要组成单位，一个 Python 程序可以由多个函数组成。
1、 理解函数
在定义函数时，至少需要清楚下面3点：
（1）、函数有几个需要动态变化的数据，这些数据应该被定义成函数的参数。
（2）、函数需要返回几个重要的数据，这些数据应该被定义成返回值。
（3）、函数的内部实现过程。
函数的定义要比函数的调用难很多。对于实现复杂的函数，定义本身就很费力，所以有时实现不出来也正常。
2、 定义函数和调用函数
函数定义语法格式如下：
1 def function_name(arg1, arg2, ...):
2 # 函数体（由0条或多条代码组成）
3 [return [返回值]]
语法格式说明如下：
（1）、函数声明必须使用 def 关键字。
（2）、函数名是一个合法的标识符，不要使用 Python 保留的关键字；函数名可由一个或多个有意义的单词连接而成，单词之间用下划线分隔，单词的字母全部用小写。
（3）、形参列表，用于定义该函数可以接收的参数。形参列表由多个形参名组成，形参之间用英文逗号分隔。在定义函数指定了形参，调用该函数时必须传入对应的参数值，即谁调用函数，谁负责为形参赋值。
函数被调用时，既可以把调用函数的返回值赋值给指定变量，也可以将函数的返回值传给另一个函数，作为另一个函数的参数。
函数中 return 语句可以显式地返回一个值，return 语句返回的值既可是有值的变量，也可是一个表达式。
3、 为函数提供文档
Python 有内置的 help() 函数可查看其他函数的帮助文档。在编写函数时，把一段字符串放在函数声明之后、函数体之前，这段字符串将被作为函数的一部分，这个文档就是函数的说明文档。
函数可通过 help() 函数查看函数的说明文档，也可通过函数的 __doc__ 属性访问函数的说明文档。示例如下：
1 def max_num(x, y):
2 """
3 获取两个数值中较大数的函数
4 max_num(x, y)
5 返回x、y两个参数之间较大的那个数
6 """
7 return x if x > y else y
8 # 使用 help() 函数和 __doc__ 属性查看 max_num 的帮助文档
9 help(max_num)
10 print(max_num.__doc__)
运行这段代码时，可以看到输出的帮助文档信息。
4、 多个返回值
如果函数有多个返回值，可将多个值包装成列表或字典后返回。也可直接返回多个值，这时 Python 会自动将多个返回值封装成元组。
1 # 定义函数
2 def foo(x, y)
3 return x + y, x - y
4 # 调用函数
5 a1 = foo(10, 5) # 函数返回的是一个元组，变量a1 也就是一个元组
也可使用 Python 提供的序列解包功能，直接用多个变量接收函数返回的多个值，例如：
a2, a3 = foo(10, 5)
5、 递归函数
在函数体内调用它自身，被称为函数递归。函数递归包含一种隐式的循环，它会重复执行某段代码，这种重复执行无须循环控制。
现假设有一个数列，f(0)=1, f(1)=4, f(n+2)=2*f(n+1)+f(n)，n是大于0的整数，求f(10)的值。这道题用递归函数计算，代码如下：
1 def f(n):
2 if n == 0:
3 return 1
4 elif n == 1:
5 return 4
6 else:
7 # 在函数体内调用其自身，就是递归函数
8 return 2 * f(n - 1) + f(n - 2)
9
10 print(f(10)) # 输出：10497
在这段代码中，f() 函数体中再次调用了 f() 函数，就是递归函数。调用形式是：
return 2 * f(n - 1) + f(n - 2)
对于 f(10)等于 2*f(9)+f(8)，其中f(9)又等于2*f(8)+f(7)······，以此类推，最终计算到 f(2)等于2*f(1)+f(0)，即f(2)是可计算的，这样递归的隐式循环就有结束的时候，然后一路反算回去最后得到 f(10) 的值。
在上面这个递归函数中，必须在某个时刻函数的返回值是确定的，即不再调用它自身；否则，这种递归就变成了无穷递归，类似于死循环。所以，在定义递归时的一条重要规定是：递归一定要向已知的方向进行。
现在将这个数列的已知条件改为这样，已知：f(20)=1, f(21)=4, f(n+2)=2*f(n+1)+f(n)，其中n是大于0的整数，求f(10)的值。此时f()函数体就应该改为如下形式：
1 def f(n):
2 if n == 20:
3 return 1
4 elif n == 21:
5 return 4
6 else:
7 return f(n + 2) - 2 * f(n + 1)
8 print(f(10)) # 输出：-3771
在这次的 f() 函数中，要计算 f(10) 的值时，f(10)等于f(12)-2*f(11)，而 f(11)等于f(13)-2*f(12)······，以此类推，直到 f(19)等于f(21)-2*f(20)，此时得到 f(19)的值，然后依次反算到f(10)的值。
递归在编程中非常有用，例如程序要遍历某个路径下的所有文件，但这个路径下的文件夹的深度是未知的，此时就可用递归来实现这个需求。
总结：在一个函数的函数体中调用自身，就是递归函数。递归一定要向已知的方向进行。
二、 函数的参数
1、关键字（keyword）参数
按照形参位置传入的参数称为位置参数。如果根据位置参数的方式传入参数值，则必须严格按照定义函数时指定的顺序来传入参数值；也
可根据参数名来传入参数值，此时无须遵守定义形参的顺序，这种方式就是关键字（keyword）参数。示例如下：
1 # 定义一个计算周长的函数 girth，接收两个形参
2 def girth(length, width):
3 print("length:", length)
4 print("", width)
5 return 2 * (length + width)
6 # 传统调用函数方式，根据位置传入参数值
7 print(girth(3, 5.5))
8 # 根据关键字参数传入参数值，使用关键字时，参数位置可以交换
9 print(girth(width=5.5, length=3))
10 # 部分用关键字，部分用位置参数，位置参数必须在关键字参数前面
11 print(girth(3, width=5.5))
在使用关键字参数调用函数时要注意，在调用函数时同时使用位置参数和关键字参数时，位置参数必须位于关键字参数的前面。也就是
关键字参数后面只能是关键字参数。
2、 参数默认值
在定义函数时，可以为一个或多个形参指定默认值，这样在调用函数时可以省略为该形参传入参数值，直接使用该形参的默认值。示例如下：
1 # 为参数指定默认值
2 def say_hi(name='michael', message="欢迎学习使用Python！"):
3 print("hello,", name)
4 print("消息是：", message, sep="")
5 # 第一次调用：使用默认参数调用函数
6 say_hi()
7 # 第二次调用：传入1个位置参数时，默认传给第一个参数
8 say_hi('jack')
9 # 第三次调用：传入2个位置参数
10 say_hi('stark', '欢迎使用 C 语言！')
11 # 使用关键字参数指明要传给哪个参数
12 say_hi(message="欢迎使用 Linux 系统！")
13
14 输出如下所示：
15 hello, michael
16 消息是：欢迎学习使用Python！
17 hello, jack
18 消息是：欢迎学习使用Python！
19 hello, stark
20 消息是：欢迎使用 C 语言！
21 hello, michael
22 消息是：欢迎使用 Linux 系统！
从这个程序可知，当只传入一个位置参数时，由于该参数位于第一位，系统会将该参数值传给 name 参数。
在Python 中，关键字参数必须位于位置参数后面，所以下面把关键字参数放在前面是错误的做法：
say_hi(name='stark', '欢迎使用 C 语言！')
这样调用函数时，报 “positional argument follows keyword argument” 错误。
在调用函数时，也不能简单的交换两个参数的位置，下面对函数的调用方式同样是错误的：
say_hi('欢迎使用 C 语言！', name='stark')
因为第一个字符串没有指定关键字参数，因此使用位置参数为 name 参数传入参数值，第二个参数使用关键字参数的形式再次为 name 参数传入参数值，这样造成两个参数值都会传给 name 参数，程序为 name 参数传入了多个参数值。因此错误提示：say_hi() got multiple values for argument 'name'。
Python 要求在调用函数时关键字参数必须位于位置参数后面，因此在定义函数时指定默认值的参数（关键字参数）必须在没有默认值的参数之后。例如：
1 def foo(a, b=10): pass # 有默认值的参数在没有默认值的参数后面
2 下面这些调用函数的方法都是正确的：
3 foo(5)
4 foo(a=5, b=4)
5 foo(5, 4)
6 foo(a='python')
3、 参数收集（个数可变的参数）
在定义函数时，形参前面加一个星号（*）表示该参数可接收多个参数值，多个参数值被当成元组传入。示例如下：
1 def my_test(a, *args):
2 """测试支持参数收集的函数"""
3 print(args)
4 # args 参数被当成元组处理
5 for s in args:
6 print(s)
7 print(a)
8 my_test(123, 'python', 'linux', 'C')
9
10 输出如下所示：
11 ('python', 'linux', 'C')
12 python
13 linux
14 C
15 123
从输出可知，在调用 my_test() 函数时，args 参数可以传入多个字符串作为参数值，参数收集的本质就是一个元组，将传给 args 的多个值收集成一个元组。
对于个数可变的形参可以处于形参列表的任意位置，但是函数最多只能有一个“普通”参数收集的形参。例如下面这样：
def my_test(*args, a): pass
在定义函数时，把个数可变的形参放在前面。那么在调用该函数时，如果要给后面的参数传入参数值，就必须使用关键字参数；否则，程序会把所传入的多个值都当成是传给 args 参数的。
另外，Python 还可以将关键字参数收集成字典，这时在定义函数时，需要在参数前面加两个星号（**）。一个函数可同时包含一个支持“普通”参数收集的参数和一个支持关键字参数收集的参数。示例如下：
1 def bar(a, b, c=5, *args, **kwargs): pass
2 bar(1, 2, 3, "python", "linux", name=stark, age=30)
在调用 bar() 函数时，前面的1、2、3会传给普通参数a、b、c；后面紧跟的两个参数由 args 收集成元组；最后的两个关键字参数被kwargs 收集成字典。这个 bar() 函数中，c 参数的默认值基本上不能发挥作用。要使 c 参数的默认起作用，可用下面方式调用函数：
bar(1, 2, name=stark, age=30)
4、 逆向参数收集
逆向参数收集指的是在程序中将已有的列表、元组、字典等对象，将其拆分后传给函数的参数。逆向参数收集需要在传入的列表、元组等参数之前添加一个星号，在字典参数之前添加两个星号。示例如下：
1 def bar(s1, s2):
2 print(s1)
3 print(s2)
4 s = 'ab'
5 bar(*s)
6 ss = ("python", "linux")
7 bar(*ss)
8 ss_dict = {"s1": "michael", "s2": 25}
9 bar(**ss_dict)
在这个 bar() 函数中，定义时声明了两个形参，在调用函数时，使用一个星号拆分序列（字符串、列表、元组）时，拆分出来的个数也应和形参的个数一样多。使用两个星号传递字典参数时，则要求字典的键与函数的形参名保持一致，并且字典的键值对与函数的形参个数也要一致。
即使支持收集的参数，如果要将一个字符串或元组传给该参数，同样也需要使用逆向收集。示例如下：
1 def bar(s1, *s2):
2 print(s1)
3 print(s2)
4 s = 'abcd'
5 bar("py", *s)
6 ss = ("python", "linux")
7 bar("java", *ss)
这次的函数调用中，可以使用一个星号拆分序列，序列的元素个数可以有多个。但是不能使用两个星号拆分字典后向其传参数。实际上，在调用函数时，只传递一个拆分后的序列参数也是可以的，例如：
bar(*s)
这时程序会将 s 进行逆向收集，其中字符串的第一个元素传给 s1 参数，后面的元素传给 s2 参数。如果不使用逆向收集（不在序列参数前使用星号），则会将整个序列作为一个参数，而不是将序列的元素作为多个参数。例如：
bar(s)
这次调用没有使用逆向收集，因此 s 整体作为参数值传给 s1 参数。
字典也支持逆向收集，字典以关键字参数的形式传入。这要求字典的键与函数的形参名一致，并且字典的键值对数量与函数的形参数量一样多。示例在前面已提到。
5、 函数的参数传递机制
Python 中函数的参数传递机制都是“值传递”，就是将实际参数值的副本（复制品）传入函数，而参数本身不会受到任何影响。示例如下：
1 def swap(a, b):
2 a, b = b, a
3 print("在swap函数里，a的值是%s; b 的值是%s" % (a, b))
4 a = 10
5 b = 20
6 swap(a, b)
7 print("变换结束后，变量 a 的值是%s；变量 b 的值是%s。" % (a, b))
8
9 运行代码，输出如下：
10 在swap函数里，a的值是20; b 的值是10
11 变换结束后，变量 a 的值是10；变量 b 的值是20。
在这段代码中，swap() 函数中交换了变量a、b 的值，在函数内输出的是交换后的值，在函数外部仍然是未交换时的值。由此可知，程序中实际定义的变量 a 和 b，并不是 swap() 函数里的 a 和 b。在 swap() 函数里的 a 和 b 是主程序中变量 a 和 b 的复制品。
在主程序中调用 swap() 函数时，系统分别为主程序和 swap() 函数分配两块栈区，用于保存它们的局部变量。将主程序中的 a、b 变量作为参数值传入 swap() 函数，实际上是在 swap() 函数栈区中重新产生了两个变量 a、b，并将主程序栈区的 a、b 变量的值分别赋值给 swap() 函数栈区中的 a、b 参数。此时系统存在两个 a 变量、两个 b 变量，只是存在于不同的栈区中。
参数值传递实质：当系统开始执行函数时，系统对形参执行初始化，就是把实参变量的值赋给函数的形参变量，在函数中操作的并不是实际的实参变量。
要注意的是，如果参数本身是可变对象（比如列表、字典等），此时同样也是采用的值传递方式，但是在函数中变量存储的是可变对象的内存地址，因此在函数中对可变对象进行修改时，修改结果会反应到原始的可变对象上。
关于参数传递机制的总结：
（1）、不管什么类型的参数，在 Python 函数中对参数直接使用 “=” 符号赋值是没用的，直接使用 “=” 符号赋值并不能改变参数。
（2）、如果要让函数修改某些数据，则可以通过把这些数据包装成列表、字典等可变对象，然后把列表、字典等可变对象作为参数传入函数，在函数中通过列表、字典的方法修改它们。这样才能改变这些数据。
6、 变量作用域
程序中定义的变量有作用范围，叫做作用域。变量分为两种：
（1）、局部变量：在函数中定义的变量，包括参数，都被称为局部变量。
（2）、全局变量：在函数外面、全局范围内定义的变量，被称为全局变量。
函数在执行时，系统为函数分配一块临时内存空间，所有局部变量被保存在这块临时空间内。函数执行完成后，这块临时内存空间就被释放，同时局部变量就失效。所以离开函数后，就不能访问局部变量。
全局变量可以在所有函数内被访问到。不管是局部变量还是全局变量，变量和它们的值就像一个“看不见”的字典，变量名是 key，变量值是字典的 value。Python 提供下面三个工具函数来获取指定范围内的“变量字典”：
（1）、globals()：返回全局范围内所有变量组成的“变量字典”。
（2）、locals()：返回当前局部范围内所有变量组成的“变量字典”。
（3）、vars(object)：获取在指定对象范围内所有变量组成的“变量字典”。不传入 object 参数，vars() 和 locals() 作用完全相同。
globals()和locals()的区别与联系：
（1）、locals() 总是获取当前局部范围内所有变量组成的“变量字典”。因此，在全局范围内（在函数之外）调用locals() 函数，同样会获取全局范围内所有变量组成的“变量字典”；而globlas() 无论在哪里执行，总是获取全局范围内所有变量组成的“变量字典”。
（2）、通常使用 locals()和globals()获取的“变量字典”只应该被访问，不应该被修改。实际上不管使用globlas()还是locals()获取的全局范围内的“变量字典“，都可以被修改，则这种修改会真正修改全局变量本身；但通过locals()获取的局部范围内的”变量字典“，即使对它修改也不会影响局部变量。
下面用代码理解 locals() 和 globlas() 函数的使用：
1 def test():
2 name = 'michael'
3 print(name) # 输出：michael
4 # 访问函数局部范围内的”变量字典“
5 print(locals()) # 输出：{'name': 'michael'}
6 # 通过函数局部范围内的”变量数组“访问 name 变量
7 print(locals()['name']) # 输出：michael
8 # 通过 locals() 函数修改局部变量的值，即使修改了也不会对局部变量有什么影响
9 locals()['name'] = 'stark'
10 # 再次访问 name 变量的值
11 print("modify: ", locals()['name']) # 输出：modify: michael
12 # 通过 globlas() 函数修改全局变量 x 的值
13 globals()['x'] = 10
14 x = 1
15 y = 2
16 # 在全局范围内调用 globals() 函数和 locals() 函数，访问的是全局变量的”变量字典"，两个函数输出的结果一样
17 print(globals()) # 输出：{..., 'x': 1, 'y': 2}
18 print(locals()) # 输出：{..., 'x': 1, 'y': 2}
19 # 在全局范围内直接使用 globlas 和 locals 函数访问全局变量
20 print(globals()['x']) # 输出：1
21 print(locals()['x']) # 输出：1
22 # 在全局范围地内使用 globlas 和 locals 函数修改全局变量的值
23 globals()['x'] = 30
24 locals()['y'] = 20
25 # 从输出可知，在全局范围内，使用 globlas 和 locals 函数修改全局变量的值都会修改成功
26 print("modify: ", globals()['x']) # modify: 30
27 print("modify: ", locals()['y']) # modify: 20
28
29 test() # 在函数内部使用 globals 函数修改全局变量的值也会修改成功
30 print("modify two: ", globals()['x']) # modify two: 10
从函数输出可知，locals() 函数用于访问特定范围内的所有变量组成的”变量字典“，但是不能修改特定范围内”变量字典“中变量的值。在全局范围不管使用 locals() 函数还是 globals() 函数都可以修改全局范围内”变量字典“中变量的值。globals() 函数在特定范围内也可以修改全局范围内”变量字典“中变量的值。
全局变量可以在所有函数内被访问，但是在函数内定义了与全局变量同名的变量时，此时全局变量会被局部变量遮蔽。示例如下：
1 name = 'michael'
2 def test():
3 # 直接访问 name 的全局变量
4 print(name)
5 name = 'stark'
6 test()
运行这段代码，此时程序会报错，错误信息是：UnboundLocalError: local variable 'name' referenced before assignment。错误信息提示在函数内访问的 name 变量还未定义，这是由于在 test() 函数中增加了 ”name='start'“ 这行代码造成的。
Python 语法规定：在函数内部对不存在的变量赋值时，默认就是重新定义新的局部变量。因此这行 ”name='start'“ 相当于重新定义了 name 局部变量，这样 name 全局变量就被遮蔽了，所以代码会报错。为了让程序不报错，可用两种方式修改上面代码。
第一种方式：访问被遮蔽的全局变量
在 test() 函数中希望 print 语句仍然能访问 name 全局变量，并且要在 print 语句之后重新定义 name 局部变量，也就是在函数中可能访问被遮蔽的全局变量，此时可通过 globals() 函数来实现。代码修改如下：
1 name = 'michael'
2 def test():
3 # 直接访问 name 的全局变量
4 print(globals()['name']) # 输出：michael
5 name = 'stark' # 定义局部变量
6 test()
7 print(name) # 输出：michael
第二种方式：在函数中声明全局变量
为避免在函数中对全局变量赋值（不是重新定义局部变量），可使用 globals 语句来声明全局变量。代码可修改为如下形式：
1 name = 'michael'
2 def test():
3 # 先声明 name 是全局变量，后面的赋值语句不会重新定义局部变量，而是直接修改全局变量
4 global name
5 # 直接访问 name 全局变量
6 print(name) # 输出：michael
7 name = 'stark' # 修改全局变量
8 test()
9 print(name) # 输出：stark
在test() 函数中的”global name“ 声明 name 为全局变量，后面对 name 赋值的语句只是对全局变量赋值，不是重新定义局部变量。
三、 局部函数
Python 支持在函数体内定义函数，这种放在函数体内定义的函数称为局部函数。默认情况下，局部函数对外部是隐藏的，局部函数只能在其封闭（enclosing）函数内有效，其封闭函数也可以返回局部函数，以便程序在其他作用域中使用局部函数。局部函数示例：
1 def foo(type, nn):
2 """定义一个函数，该函数包含局部函数"""
3 def square(n):
4 """定义一个计算平方的局部函数"""
5 return n * n
6 def cube(n):
7 """定义一个计算立方的局部函数"""
8 return n * n * n
9 def factorial(n):
10 """定义一个计算阶乘的局部函数"""
11 result = 1
12 for i in range(2, n + 1):
13 result *= i
14 return result
15 # 调用局部函数
16 if type == 'square':
17 return square(nn)
18 elif type == 'cube':
19 return cube(nn)
20 else:
21 return factorial(nn)
22 print(foo('square', 5)) # 输出：25
23 print(foo('cube', 3)) # 输出：27
24 print(foo('', 3)) # 输出：6
这里的 foo() 函数体内定义了3个局部函数，foo() 函数根据参数选择调用不同的局部函数。如果封闭函数（foo()）没有返回局部函数，那么局部函数只能在封闭函数内部调用。例如上面的 foo() 函数。
另一种情况是，封闭函数将局部函数返回，且程序使用变量保存了封闭函数的返回值，那么这些局部函数的作用域就会被扩大，程序可通过该变量自由的调用它们，就像它们是全局函数一样。
局部函数内的变量也会遮蔽它所在函数内的局部变量。示例如下：
1 def foo():
2 # 局部变量 name
3 name = 'michael'
4 def bar():
5 # 访问 bar 函数所在 foo 函数内的 name 局部变量
6 print(name) # michael
7 name = 'stark'
8 bar()
9 foo()
运行这段代码，出现错误提示“UnboundLocalError: local variable 'name' referenced before assignment”。这错误是由于局部变量遮蔽局部变量导致的，在 bar() 函数中定义的 name 局部变量遮蔽了它所在 foo() 函数内的 name 局部变量，因此导致程序中 print 语句代码报错。
为了使 bar() 函数内的“name = 'stark'” 赋值语句不是定义新的局部变量，只是访问它所在 foo() 函数内的 name 局部变量，可使用Python 提供的 nonlocal 关键字，通过 nonlocal 语句即可声明访问赋值语句只是访问该函数所在函数内的局部变量。示例如下：
1 def foo():
2 # 局部变量 name
3 name = 'michael'
4 def bar():
5 # 访问 bar 函数所在 foo 函数内的 name 局部变量
6 nonlocal name
7 print(name) # michael
8 name = 'stark'
9 bar()
10 foo()
在 foo() 函数内增加 “nonlocal name” 语句后，在 bar() 函数中的 “name = 'stark'” 就不再是定义新的局部变量，而是访问它所在函数（foo()）内的 name 局部变量。
nonlocal 的功能和 global 功能大致相似，区别是 global 用于声明全局变量，而 nonlocal 用于声明访问当前函数所在函数内的局部变量。