什么是函数
定义：函数是指将一组语句的集合通过一个名字(函数名)封装起来，要执行这个函数，只需调用函数名即可。
特性：1、减少重复代码 2、使程序变得可扩展 3、使程序变得易于维护
调用函数
要调用一个函数需要知道函数的名称和参数。
绝对值函数
>>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34
调用函数的时候如果传入的参数数量和类型不对会报typeError错误
>>> abs(1, 2)
Traceback (most recent call last):
File "", line 1, in
TypeError: abs() takes exactly one argument (2 given)
>>> abs('a')
Traceback (most recent call last):
File "", line 1, in
TypeError: bad operand type for abs(): 'str'
函数名其实就是指向一个函数对象的引用，完全可以把函数名赋予一个变量，相当于给这个函数起了个别名。
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1
定义函数
在Python中，定义一个函数要使用def语句，依次写出函数的函数名、括号、括号中的参数和冒号，然后，在缩进块中编写函数体，返回值用return语句返回。
def my_abs(x):
if x >= 0:
return x
else:
return -x
函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。如果没有return语句，函数执行完毕后也会返回结果，只是结果为None，return None可以简写为return。
函数的参数
定义函数的时候把参数的名字和位置确定下来，函数的接口定义就完成了，对于函数调用者来说，只需要知道如何传递正确的参数以及函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来调用者无须了解。
Python的函数定义非常简单但灵活度却非常大，除了正常定义的必须参数外，还是可变参数，默认参数和关键字参数。
位置参数
计算一个数的平方
def power(x):
return x * x
>>> power(5)
25
>>> power(15)
225
计算一个数的n次方
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
>>> power(5, 2)
25
>>> power(5, 3)
125
传入的两个值按顺序依次赋值给x和n
默认参数
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
>>> power(5)
25
>>> power(5, 2)
25
调用函数时，如果有传入n，则计算x的n次方，如果不传入，则n=2,计算x的平方。
设置默认参数时要注意：
必选参数在前，默认参数在后，否则解释器报错
当有多个参数时，变化大的参数放前边，变化小的参数放后边。变化小的可做默认参数
有多个默认参数时，调用的时候既可按顺序提供默认参数的值也可不按顺序，但必须把参数名写上。
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
>>>enroll('Adam', 'M', city='Tianjin')
默认参数容易碰到的坑：
def add_end(L=[]):
L.append('END')
return L
#正常调用不会出现问题
>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']
#如果连续调用，使用默认参数结果就会出现错误
>>> add_end()
['END']
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']
每次调用，默认参数为空list才对，为什么函数似乎记住了上次添加的‘end’？
原因就是：Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的 []了。所以，定义默认参数要牢记一点：默认参数必须指向不变对象！
修改上边的例子可以用None来实现
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
>>> add_end()
['END']
>>> add_end()
['END']
可变参数
顾名思义，可变参数就是传入的参数个数是可变的，可以是1个，2个，。。。甚至是0个。
以计算一组数字平方的和为例子：
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
#调用时需要传入list或tuple
>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84
利用可变参数会后函数和调用是这个样子：
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
>>> calc(1, 2)
5
>>> calc()
0
可以看到：只是在定义函数时在参数前加一个*,调用时就不用以list或tuple的形式传入参数。
如果已经有了数组，想调用可变参数可以这样做：
>>> nums = [1, 2, 3]
>>> calc(*nums)
14
关键字参数
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装成为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装成为一个dict。
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
#函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数：
>>> person('Michael', 30)
name: Michael age: 30 other: {}
#也可以传入任意个数的关键字参数：
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
关键字参数可以扩展函数的功能，例如：在实现一个注册功能时，除了用户名和密码是必填项外，其他都是可选选项。利用关键字参数来定义这个函数就会满足需求。
和可变参数一样，如果已经有了一个dict,把该dict转换为关键字参数穿进去：
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
**extra表示把extra这个dict的所有key-value用关键字参数传入到函数**kw参数，kw将获得一个dict。
注意：kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
命名关键字参数
对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数，但如果想限制关键字参数的名字，就可以使用关键字参数，例如只接受city和job作为关键字参数：
def person(name, age, *, city, job):
print(name, age, city, job)
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*,*后边的参数被视为命名关键字参数。
调用：
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer
命名关键字参数必须传入参数名，这和位置参数不同，如果不传入参数名就会报错：
>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
File "", line 1, in
TypeError: person() takes 2 positional arguments but 4 were given
由于调用时缺少参数名city和job，Python解释器把这4个参数均视为位置参数，但函数只接受两个位置参数。
命名关键字可以有默认值：
def person(name, age, *, city='Beijing', job):
print(name, age, city, job)
>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer
如果函数定义中已经有了一个可变参数，后边跟着的命名关键字参数就不在需要一个特殊分隔符*了。
def person(name, age, *args, city, job):
print(name, age, args, city, job)
如果没有可变参数，务必要加分隔符，否则解释器无法分辨位置参数和关键字参数。
参数组合
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数。这5中参数都可以组合使用。
但是，参数组合的顺序必须是：必选参数-默认参数-可变参数-命名关键字参数-关键字参数！
例如：
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
调用的时候，Python解释器会自动按照参数位置和参数名把对应的参数穿进去
>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
通过一个tuple和list也可以调用：
>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}
所以，对于任意函数，都可以通过类似func(*args,**kw)的形式调用他而不管参数是如何定义的！
注：使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
递归函数
在函数内部，可以调用其他函数。如果一个函数调用自身函数，这个函数就是递归函数。
计算阶乘用递归函数：
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
>>> fact(1)
1
>>> fact(5)
120
递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
使用递归函数要注意防止栈溢出。在计算机中，函数调用是通过栈这种数据结构实现的。每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以递归调用的次数增多会导致栈溢出。
解决递归调用栈溢出的方法是通过尾递归优化。尾递归是指，在函数返回的时候调用自己本身，并且，return语句不能包含表达式。这样，解释器或编译器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出情况。
def fact(n):
return fact_iter(n, 1)
def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)
但是！！大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。