微信公众号：码农充电站pro
个人主页：https://codeshellme.github.io
测试只能证明程序有错误，而不能证明程序没有错误。
—— Edsger Dijkstra
目录
本节我们来介绍函数，在前边的章节我们已经接触了挺多函数了，比如print()，len() 等。
函数是编程语言中非常重要的概念，函数是一段可重复利用的，提供特定功能的代码段。
函数是一种模块化的手段，可提高代码的利用率，避免重复代码，便于使用，便于维护。
Python 中，不仅提供了许多现成可用的内建函数，用户还可以根据自己的需求，定义自己的函数。
在Python 中，内建函数用builtin_function_or_method 表示，自定义函数用function 表示。
函数也属于一种数据类型，可用type() 查看：
>>> type(len) # len() 是内建函数
<class \'builtin_function_or_method\'>
>>>
>>> type(print) # print() 是内建函数
<class \'builtin_function_or_method\'>
>>>
>>> def test(): pass # 自定义函数 test()，并没有实质功能
...
>>>
>>> type(test) # test() 是自定义函数
<class \'function\'>
提示：
内建函数就是Python 原生支持，自带的函数（比如print()），用于区分用户自定函数。
1，函数的定义
函数定义的格式如下：
def fun_name(参数列表...):
# 函数体
...
首先，定义函数需要用到def 关键字，后跟函数名，然后是参数列表，参数列表写在小括号()内，再往后是一个冒号:，函数体一般写在下一行，注意要有缩进。
例如，我们定义一个简单的函数：
def hello_python():
print(\'hello python.\')
该函数值输出一个字符串hello python.，其中：
hello_python为函数名- 参数列表为空，调用该函数时，不需要任何参数
- 函数体只有一句代码
print(\'hello python.\')
文档字符串
我们可以在函数体的第一行，写一段该函数的说明，此说明用三引号\'\'\' 或 """ 引住，这被称为文档字符串。如下：
def hello_python():
\'\'\'这是函数的一段说明\'\'\'
print(\'hello python.\')
要想查看这段说明，可以使用格式函数名.__doc__ 来访问，如下：
>>> hello_python.__doc__
\'这是函数的一段说明\'
我们也可以访问内建函数的文档字符串，比如len() 函数：
>>> len.__doc__
\'Return the number of items in a container.\'
2，调用函数
调用函数时，只需要用函数名和参数列表就行，比如上面的函数，调用如下：
hello_python() # 输出 hello python.
其实，在Python 中，函数也是一种类型，函数名就是一个函数类型的变量。
因此，可以将一个函数名赋值给一个变量，如下：
abc = hello_python
print(type(abc)) # 输出 <class \'function\'>
abc() # 就像调用 hello_python() 一样
3，函数参数
定义函数时，可以传给函数一些数据，这些数据叫做函数参数。
定义一个带参数的函数，如下：
def hello(string):
print(\'hello %s.\' % string)
其中的string 就是函数参数，函数参数可以有多个，这里我们只写了一个参数。
此时，调用该函数时，就需要给函数传递参数了，如下：
hello(\'python\') # 输出 hello python.
hello(\'java\') # 输出 hello java.
hello(\'html\') # 输出 hello html.
如果参数传递出现错误，则会出现TypeError 异常，参数传递错误包括：
- 参数个数不对
- 参数类型不适用
4，默认参数
定义参数时，可以包含默认参数，默认参数可以有多个。
默认参数就是，这个参数可以传递，也可以不传递：
- 传递时，该参数就是你传递的值
- 不传递时，该参数有默认值
如下，我们定义了一个带有默认参数的函数：
def sum(a, b=0, c=1):
n = a + b + c
print(n)
默认参数必须写在普通参数的后边，默认参数后边不能再有普通参数。
其中，参数a 是普通参数，参数b 和c都是默认参数，用赋值语句 赋予了它们默认值。
参数b的默认值是0，参数c 的默认值是1 。
当没有传递b 时，b 为0，当没有传递c 时，c 为 1。
我们可以这样调用sum 函数：
sum(2) # 只传递了 a，b 和 c 都是默认值
sum(2, 3) # 传递了 a 和 b，c 是默认值
sum(2, 3, 5) # a，b，c 都传递了
sum(a=2, b=5) # 传递参数时，普通参数和默认参数都可以加上参数名
sum(2, c=7) # 传递了a 和 c，b 是默认值
sum(2, b=2, c=7) # 传递默认参数时，可以加上参数名
sum(c=2, a=2, b=7) # 传递参数时，如果有参数名，参数的顺序可以随意
需要注意的是：
- 传递参数时，普通参数和默认参数都可以加上参数名
- 传递参数时，如果有写参数名，参数的顺序可以随意
- 传递参数时，如果没有写参数名，参数的顺序必须按照函数定义的顺序来写
默认参数不要是可变类型
默认参数可以是任意类型的数据，但是建议不要是可变类型数据，否则容易出现不可预料的结果。
比如代码：
def test(l=[]):
l.append(1)
return l
当调用该函数时，如果传递了参数，这种情况下一般不会出现什么问题：
>>> test([])
[1]
>>> test([2])
[2, 1]
但是，如果没有传递参数，而是使用的默认参数，结果可能不是你想象的：
>>> test()
[1]
>>> test()
[1, 1]
>>> test()
[1, 1, 1]
如上代码，我们连续调用了三次test()，都使用的是默认参数。
第一次调用似乎还是正常的，但后两次的结果显示，函数返回的结果，应该是累计了前边调用。
这是因为，当使用默认参数时，函数记录了默认参数的一开始的变量地址，这个变量地址始终是不会改变的，但是如果这个变量类型是可变类型的数据（比如例子中的列表类型），那么其中的值是有可能改变的。
这就是出现以上情况的原因，所以，建议在使用默认参数时，不要使用可变类型的参数，容易出问题。
5，不定长参数
当你不知道函数的参数有几个的时候，你可以使用不定长参数。
不定长参数的格式，是在普通参数之前加一个星号*，如下：
def print_num(*num):
print(num)
此时，在函数内部，num 实际上是一个元组类型。所以，我们以元组的方式来操作num 即可。
我们可以给该函数传递不同个数的参数：
print_num(1) # 传递了 1 个参数，num = (1)
print_num(1, 2) # 传递了 2 个参数，num = (1, 2)
print_num(1, 2, 3) # 传递了 3 个参数，num = (1, 2, 3)
有名参数
不定长的有名参数，是在普通参数之前加两个星号**，如下：、
def print_num(**num):
print(num)
此时，在函数内部，num 实际上是一个字典类型。所以，我们以字典的方式来操作num 即可。
我们可以给该函数传递不同个数的有名参数，参数名被解析成了字符串类型：
print_num(a=1) # 传递了 1 个参数，num = {\'a\': 1}
print_num(a=1, b=2) # 传递了 2 个参数，num = {\'a\': 1, \'b\': 2}
各种参数的顺序
如果一个函数中各种参数都有的话，它们的顺序是有要求的：如下：
def 函数名(普通参数，默认参数，不定长参数，不定长有名参数):
# 函数体
...
建议：
不要使用太多的参数组合，不便于理解
6，函数作为参数
由于函数 也是一种数据类型，所以函数也可以作为函数参数传递给函数，然后在函数内部，再调用该函数。
def sum(a, b):
return a + b
def test(fun):
n = fun(1, 2)
print(n)
test(sum)
上面代码中，sum 与 test 都是函数。
sum() 函数，计算两个参数之和，并将结果返回。
test() 函数，接收一个参数 fun，该参数是一个函数类型。在函数体内，用代码n = fun(1, 2) 进行调用。
代码test(sum)，将函数sum 作为参数传递给test()。
以上就是函数作为函数参数的用法。
7，函数返回值
函数可以有返回值，也可以没有返回值。
函数的返回值，需要用到return 关键字，当函数的执行遇到return 时，函数的执行就会结束，并且返回一个值。
如果一个函数没有调用return，那么在函数执行完毕后，会默认返回None：
def test():
print(\'hello python.\')
# 没有使用 return
ret = test() # ret 为 None
如果一个函数调用了return，但是return 后边没有值，那么此时的含义是，表示函数立马返回，且返回值为None：
def test():
print(\'hello python.\')
return
# return 后边的语句永远不会被执行到
print(\'hello java.\')
ret = test() # ret 为 None
你可以在return 后边跟一个任意类型的值，作为函数的返回值：
def test(flag):
if flag:
return True # 返回 True
else:
return False # 返回 False
ret = test(True) # ret 为 True
ret = test(False) # ret 为 False
函数返回多个值
函数不仅可以返回一个值，也可以返回多个值：
def test(a, b, c):
return a, b, c
实际上这个时候，a, b, c 被自动打包到了一个元组里边，我们用一个变量去接收返回值：
ret = test(1, 2, 3)
print(ret) # ret 为 (1, 2, 3)
print(type(ret)) # <class \'tuple\'>
我们也可以用三个变量去接收这个返回值，这时返回值会被自动解包：
a, b, c = test(1, 2, 3)
# a 为 1
# b 为 2
# c 为 3
自动解包时，如果变量的个数与返回值的个数不同，会抛出ValueError异常：
a, b = test(1, 2, 3) # 变量少于返回值，抛出异常
a, b, c, d = test(1, 2, 3) # 变量多于返回值，抛出异常
8，匿名函数
Python 中的匿名函数使用 lambda 关键字，也称为lambda 表达式。
lambda 表达式虽然也是函数，但是一般只包含简单的逻辑，它是普通函数的一种简写形式。一般常作为函数参数，传递给函数。
格式如下：
lambda 参数列表 : 表达式
lambda 后跟一个参数列表，然后是一个冒号:，最后是一个表达式，表达式的计算结果会作为匿名函数的返回值（不需要用return）。
可以将lambda 表达式赋值给一个变量，格式如下：
变量名 = lambda 参数列表 : 表达式
示例：
sum = lambda x, y : x + y
该匿名函数接收两个参数x，y，然后计算结果 x + y，并将结果返回。
通过type(sum) 查看其类型：
>>> type(sum)
<class \'function\'>
上面这个lambda 表达式就相当于如下函数：
def sum(x, y):
return x + y
我们可以像调用普通函数一样，调用该lambda 表达式：
>>> sum(1, 2) # 返回 1 + 2
3
>>> sum(2, 3) # 返回 2 + 3
5
匿名函数的应用场景
在介绍Python 列表的时候，我们介绍过一个L.sort() 函数，该函数的原型如下：
L.sort(key=None, reverse=False) -> None
其中的key 参数就是一个函数类型参数，这种情况下就可以使用匿名函数。如下：
>>> l.sort(key = lambda x: x[0])
>>> l
[(\'a\', 3), (\'b\', 2), (\'c\', 1)]
>>>
>>> l.sort(key = lambda x: x[1])
>>> l
[(\'c\', 1), (\'b\', 2), (\'a\', 3)]
（完。）
推荐阅读：
Python 简明教程 --- 14，Python 数据结构进阶
欢迎关注作者公众号，获取更多技术干货。
