调用函数

平时我们可以很方便的调用Python的内置函数。
[Python文档]https://docs.python.org/3.5/library/index.html
注意TypeError和数据类型转换。

定义函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
定义函数的时候，我们把函数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来，调用者无需了解。

空函数

定义一个什么事也不做的函数，可以在函数体内写pass语句（相当于一个占位符，没想好怎么写这部分的代码，但是又想先让代码运行起来）。

参数检查

以对参数做检查，只允许整数和浮点数类型的参数。数据类检查可以用内置函数isinstance()实现：

def my_abs(x):
    if not isinstance(x,(int,float)):
        raise TypeError('bad operand type')
    if  x>=0:
        return x
    else:
        return -x

函数返回多个值

实际上返回值是一个tuple，但是在语法上返回一个tuple可以省略括号。

函数的参数

位置参数

调用函数时，传入参数的值按照顺序依次赋值给位置参数

默认参数（降低调用函数的难度）

注意：
必选参数在前，默认参数在后，变化小的参数可以作为默认参数
定义默认参数的时候要牢记：默认参数必须指向不变对象

可变参数

可变参数就是传入参数的个数是可变的。

    def calc(numbers):
        sum = 0
        for n in numbers:
            sum = sum + n * n
        renturn sum
calc([1,2,3]) 

    def calc(* numbers):
        sum = 0
        for n in numbers:
            sum = sum + n * n
        return sum
calc(1,2,3)

可以看出定义一个list/tuple参数与定义一个可变参数相比，仅仅在参数前面加了一个*号，在函数内部，参数收到的是一个tuple，代码完全不变。
已经有了一个list/tuple，调用一个可变参数。

nums = [1,2,3]
calc(*nums)

*nums表示将nums这个list中所有元素作为可变参数传进去。

关键字参数(可以扩展函数的功能)

关键字参数允许传入一个或任意个含参数名的参数，这些关键字参数在函数内自动组装成为一个dict。

def person(name,age,**kw):
    print('name:',name,'age:',age,'other:',kw)
#传入任意个关键字参数
person('Bob',31,city='Nanjing',job='teacher')

如果事先已经有了dict：

extra = {'city':'Beijing','job':'teacher'}
person('Jack',19,**exact)

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)
#特殊情况：函数定义中已经有了一个可变参数，后面的命名关键字参数就不需要在加一个特殊的分隔符‘*’了。
def person(name,age,*arg,city,job):
    print(name,age,arg,city,job)

参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

递归函数(所有的递归函数都可以写成循环的方式)

我们知道在函数内部是可以调用其它函数的。那么如果一个函数在内部调用自身本身，这个函数就是递归函数。
如阶乘：

def fact(n):
    if n==1:
        return 1
    else:
        return n*fact(n-1)

使用递归函数要防止栈溢出。在计算机中，函数调用是通过栈（stack）的数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回就会减少一层栈帧。由于栈帧不是无限的，所以递归调用的次数过多，会导致栈溢出。
解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。
尾递归是指，在函数返回的时候，调用自身本身，并且，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解释器并没有对尾递归做优化！！！因此任何递归函数都存在栈溢出的问题。