函数基础
除了可以直接使用的内置函数外，Python还支持自定义函数，即将一段有规律的、可重复使用的代码定义成函数，从而达到一次编写、多次调用的目的。
函数的本质就是一段有特定功能、可以重复使用的代码，这段代码已经被提前编写好了，并且为其起一个好听的名字。在后续编写程序过程中，如果需要同样的功能，直接通过起好的名字就可以调用这段代码。
函数的作用
- 结构化编程对代码的最基本的封装，一般按照功能组织一段代码；
- 封装的目的为了复用，减少冗余代码；
- 代码更加简洁美观、可读易懂
函数的定义
Python函数：能完成一定的功能，由若干语句组成的语句块、函数名称、参数列表构成，它是组织代码的最小单元。
语法格式
def 函数名(参数1,参数2,参数3,...):
'''注释'''
函数体
return 返回的值
需要注意的地方：
- 函数名后面必须加冒号；
- 函数名即标识符，命名规范：小写字母，多个单词用
_间隔； - 如果函数体和def不在同一行，必须缩进，约定4个空格；
- 若没有
return，则隐式返回一个None值； - 如果函数体body语句只有一行，或者可以简写为一行，则可以写在def的同行。例如：
def myfunc(x,y,z): print(x+y+z)
函数的调用
如何调用
函数声明好之后，就可以执行函数，执行函数也称为调用函数，方式为func_name(args)，例如：
myfunc(1,2,3)
调用规则
函数的使用，必须遵循原则：先定义，后调用。
若在前面调用了，后面再定义，是否会报错呢？
测试一：
def bar():
print('from bar')
def foo():
print('from foo')
bar()
foo() # 正常
测试二：
def foo():
print('from foo')
bar()
def bar():
print('from bar')
foo() # 也正常
测试三：
def foo():
print('from foo')
bar()
foo()
def bar():
print('from bar')
# 报错
NameError: name 'bar' is not defined
函数的返回值
函数返回值：
- 没有返回值：默认返回
None - 返回一个值：函数结束了且返回一个值
- 返回多个值：多个值之间用逗号隔开，接收的时候可以用一个变量接收(返回元组)，也可以用等量的多个变量接收
什么时候需要有返回值？
调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值。
通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果。
什么时候不需要有返回值？
调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值。
通常无参函数不需要有返回值。
多个返回值
Python的函数支持返回多个值。返回多个值时，默认以tuple的方式返回。例如，下面两个函数的定义是完全等价的。
def f():
return 1,2
def f():
return (1,2)
丢弃返回值
# 不进行任何赋值，将丢弃所有返回值
f()
# 可以通过索引取得某个或某几个返回值
a = f()[0]
b = f()[1]
# 使用双下划线__或更多下划线___________
# 丢弃第二个返回值
a, __ = f()
函数调用时的*和**
除了在def定义函数时，参数中可以使用*或**收集参数，在函数调用的时候也可以使用*或**分别解包元组(列表或其它对象)、字典。一定要注意区分函数定义和函数调用时的*、**，它们的用法是不通用的。
例如，解包元组：
def f(a,b,c,d):
print(a)
print(b)
print(c)
print(d)
T=(1,2,3,4)
f(*T)
*除了可以解包元组，还可以解包其它可迭代对象，例如列表。甚至是字典也能解包，只不过*解包的字典得到的是key组成的参数列表，和value无关：
D=dict(a=11,b=22,c=33,d=44)
f(*D)
# 输出：
a
b
c
d
而**解包的字典则是key=value组成的参数列表。以下是函数调用时使用**进行解包，字典D中的key名称必须和def中定义的参数名称相同：
def f(a,b,c,d):
print(a)
print(b)
print(c)
print(d)
D=dict(a=11,b=22,c=33,d=44)
f(**D)
# 输出：
11
22
33
44
在函数调用时，可以混合位置参数、关键字参数、*解包参数、**解包参数。用法非常的灵活：
def f(a,b,c,d):
print(a)
print(b)
print(c)
print(d)
f(*(1,2),**{'d':4,'c':3})
f(1,*(2,3),**{'d':4})
f(1,c=3,*(2,),**{'d':4})
f(1,*(2,3),d=4)
f(1,*(2,),c=3,**{'d':4})
# 结果如下
1
2
3
4
1
2
3
4
1
2
3
4
1
2
3
4
1
2
3
4
上面调用函数时的效果都等同于f(1,2,3,4)。
函数的参数
函数的参数其实也是变量，只不过这些变量是独属于函数的本地变量，函数外部无法访问。在函数调用的时候，会将给定的值传递给函数的参数，这实际上是变量赋值的过程。例如：
def myfunc(x,y,z):
print(x,y,z)
myfunc(1,2,3)
形参和实参
形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定。
形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用。
实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的。
参数的传递
参数的传递可以分为按指针传参、按位置传参、按关键字key=value方式传参。
按指针传参
Python中变量赋值、参数传递都是通过指针拷贝的方式进行的。都只是拷贝了源数据的一个地址，而不会拷贝内存中完整的数据对象副本。所以，如果在函数内部修改变量指向的数据对象，会影响函数外部的数据。
例如：
def f(x):
print(x+3)
a = 4
f(a)
# 输出结果
7
按位置传参
如果是多个参数，则按从左到右的顺序进行参数变量的赋值：
def f(x, y, z):
print(x)
print(y)
print(z)
f(2, 3, 4)
# 输出结果
2
3
4
调用f(2,3,4)的时候，会按照从左向右的位置方式对本地变量x、y、z赋值：x=2,y=3,z=4。
按关键字key=value方式传参
Python还支持key=value的方式设置函数调用时的参数，使用key=value的方式赋值时，顺序不重要。这种函数调用时的传值方式称为关键字传值。
例如：
def f(x, y, z):
print(x)
print(y)
print(z)
f(x=3, y="haha", z=4)
# 输出
3
haha
4
也可以打乱顺序，输出结果不变：
f(x=3, z=4, y="haha")
还可以将key=value和位置传参的方式进行混合：
f(3, "haha", z=4)
但混合按位置传参方式的时候，位置参数必须在其它传参方式的前面，不仅此处结合key=value时如此，后文中位置参数结合其它方式传参也都如此：位置参数必须在最前面。例如，下面的传参方式是错的：
f(z=4, 3, "haha")
参数默认值
在def或lambda声明函数的时候，可以通过var=default的方式指定参数的默认值。
例如：
def f(x=3):
print(x)
f(4)
f("haha")
f()
# 输出结果
4
haha
3
上面的f(4)和f("haha")都对函数f()的本地变量x进行了赋值。但是最后一个调用语句f()未赋值，而是使用参数的默认值3。
设置参数默认值时，如果函数有多个参数，则带默认值参数后面必须放在最后面。例如：
# 正确
def f(x, y, z=4)
def f(x, y=1, z=4)
# 错误
def f(x, y=4, z)
只要为参数设置了默认值，那么调用函数的时候，这个参数就是可选的，可有可无的，如果没有，则采用默认值。
def f(x, y=2, z=4):
print(x)
print(y)
print(z)
# 不采用任何默认值
f(2, 3, 4)
# 采用z的默认值
f(2, 3)
# 采用y的默认值
# 此时z必须按key=value的方式传值
f(2, z=5)
# y、z都采用默认值
f(2)
# 输出结果
2
3
4
2
3
4
2
2
5
2
2
4
位置可变参数*
对于任意长度的参数，可以在def声明的函数中使用*将各位置参数收集到一个元组中。
def f(*args):
print(args)
f(1, 2, 3, 4)
# 结果输出：(1, 2, 3, 4)
上面调用f(1, 2, 3, 4)的时候，将所有参数都收集到了一个名为args的元组中。
既然是元组，就可以对参数进行迭代遍历：
def f(*args):
for arg in args:
print(arg)
f(1,2,3,4)
# 输出结果
1
2
3
4
必须注意，*是按位置收集参数的。
def f(x, y, *args):
print(x)
print(y)
for arg in args:
print(arg)
f(1, 2, 3, 4)
按照从左向右的传参规则，首先将1赋值给x，将2赋值给y，然后将剩余所有的位置参数收集到args元组中，所以args=(3,4)。
如果*后面还有参数，则调用函数的时候，后面的参数必须使用key=value的方式传递，否则会收集到元组中，从而导致参数缺少的问题：
def f(x, *args, y):
print(x)
print(y)
for arg in args:
print(arg)
# 正确
f(1, 3, 4, y=2)
# 错误
f(1, 2, 3, 4)
上面调用f(1, 3, 4, y=2)的时候，会按照位置参数对x赋值为1，然后将所有位置参数收集到元组args中，因为y=2是非位置参数传值方式，所以args=(3, 4)。
如果为上面的y设置默认值：
def f(x, *args, y=2)
那么f(1, 2, 3, 4)会将(2, 3, 4)都收集到元组args中，然后y采用默认值2。
关键字可变参数**
除了可以使用*将位置参数收集到元组中，还可以使用**将key=value格式的参数收集到字典中。
例如：
def f(x, **args):
print(x)
print(args)
f(1, a=11, b=22, c=33, d=44)
既然是将参数收集到字典中，就可以使用字典类的工具操作这个字典。例如，遍历字典。
在**的后面不能出现任何其它类型的参数。例如，下面的都是错误的def定义方式：
def f(x, **args, y)
def f(x, **args, y=3)
def f(x, **args, *t)
只能将位置参数或者*的收集放在**的前面。
def f(x, y, **args)
def f(x, *args1, **args2)
keyword-only参数形式
keyword-only的参数传值方式表示def中如果使用了*，那么在调用函数时，它后面的参数必须只能使用关键字传值。其实在前面的内容中已经出现过几次与之相关的说明。
另外注意，*才是keyword-only开关，**不是，虽然**也有自己的一些语法限制：任意类型的参数定义都必须在**之前，包括keyword-only类型的参数。例如：
def f(a, *b, c):
print(a, b, c)
按照keyword-only的规则，被*b收集的位置参数不包括c，这个c必须只能使用关键字的方式传值，否则就被当作位置参数被收集到元组b中。
# 正确
f(1, 2, 3, c=4)
# 错误
f(1, 2, 3, 4)
# 错误
f(1, c=4, 2, 3)
其中最后一个错误和如何def的定义无关，而是函数调用时的语法错误，前面已经解释过：位置参数必须放在最前面。
还可以直接使用*而非*args的方式，这表示不收集任何参数，但却要求它后面的参数必须按照关键字传值的方式。
def f(a, *, b, c):
print(a, b, c)
以下是正确和错误的调用方式示例：
# 正确
f(1, b=2, c=3)
f(1, c=3, b=2)
f(b=2, c=3, a=1)
# 错误
f(1, 2, 3)
f(1, 2, c=3)
f(1, b=2, 3)
不过，keyword-only后面的参数可以使用参数默认值。
def f(a, *, b, c=3)
那么c是可选的，但如果给定，则必须按关键字方式传值。