调用函数

函数名，参数，参数类型和个数要和定义时一样，如

abs(-9)#-9的绝对值
cmp(1,2)#比较1和2，1<2返回-1，1>2返回1，1=2返回0

数据类型转换

>>> int('123')#把字符串'123'转换成int
123
>>> int(12.34)#把浮点型12.34转换成int
12
>>> float('12.34')#把字符串'12.34转换成浮点型
12.34
>>> str(1.23)#把浮点型1.23转换成字符串
'1.23'
>>> unicode(100)#把整型100转换成unicode字符串
u'100'
>>> bool(1)#把整形1转换成bool
True
>>> bool('')#把空字符串转换成bool型
False

函数名其实是一个函数对象的引用，可以把函数名赋值给一个变量，相当于给函数起了一个别名：

>>> a = abs#变量a指向abs函数
>>> a (-2)通过a调用abs函数
2

定义函数

定义函数：
def 函数名([参数,[参数...]]):
参数可选，在缩进块中编写函数体，函数返回值使用return返回
定义

def my_abs(x):
    if x>0
        return x
    else:
        return -x

如果没有return语句，函数执行完毕后也会返回结果，会返回None，return None也可以简写成return
空函数：一个什么事也不做的函数，可以使用pass语句：

def nop():
    pass

pass可以用来作为占位符，如果还没想好函数体的代码，可以先使用pass语句让代码运行起来
pass还可以用在其他语句中，如：

if age >= 18
    pass

参数检查

调用函数时，函数参数个数不对，Python解释器会自动检查出来，抛出TypeError的错误，如果参数类型不对就只会报错不会提示

函数isinstance()：检查数据类型，如：
isinstance(x,(int,float)) #如果x的类型是int或者float返回True，否则返回False

返回多个值的函数

比如在游戏中需要从一个点移动到另一个点，给出坐标、位移、角度就可以计算出新坐标：

import math

def move(x, y, step, angle = 0):
    nx = x + step * math.cos(angle)
    ny = y + step * math.sin(angel)
    return nx, ny

这样我们就可以同时获得两个返回值

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print x, y
151,961524227 70.0

其实这是一种假象，python返回的仍然是一个单一值

>>> r = move(100, 100, 60, math.pi / 6)
>>> print r
(151,961524227,70.0)

返回值是一个tuple。在语法上，返回一个tuple可以省略括号。多个变量同时接收一个tuple时，按位置赋给对应的值。

函数的参数

三种参数：默认参数、可变参数和关键字参数
默认参数
定义一个函数，计算任意数的n次方，默认为2次方

def power(x, n = 2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

当调用power(5)时，相当于调用power(5,2)，对于n!=2的情况，就必须要传入参数了

设置默认参数时，必选参数放前边，默认参数放后边，否则会报错（如果必选参数放后边，传入值一个值后解释器会认为你传入的值是给默认参数的，那样必选参数就没有值了）还要注意，当函数有多个参数时，要把参数变化大的放前边，变化小的放后边，变化小的参数就可以作为默认参数了

使用默认参数可以降低调用函数的难度：
定义一个小学生注册的函数，需要传入name和gender两个必选参数，还有age，city两个默认参数，默认值为age=6，city='Beijing'：

def enroll(name, gender, age = 6, city='Beijing'):
    print 'name:', name
    print 'gender:', gender
    print 'age:', age
    print 'city:', city

这样大多数学生注册时必须要提供年龄和城市就可以注册

>>> enroll('Sarah', 'F')
name: Sarah
gender: F
age: 6
city: Beijing

当年龄或城市和默认参数不同时，在传入这两个参数
enroll('Bob', 'M', 7)
enroll('Adam', 'M', city = 'Tianjin')
当有多个默认参数时，可以按顺序提供默认参数，不用写参数名。如果不按顺序提供，就要写上参数名了，要不python解释器就不知道你要传入哪个参数了

默认参数有个坑

python函数定义时，如果默认参数是可变的对象，就先计算出来，每次调用玩函数后如果改变了默认参数的值，那么下次计算时就会使用改变过的值：

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']

所以定义默认参数时一定要使用不可变的对象

要修改上面的例子，我们可以用None这个不变对象来实现：

def add_end(L=None): 
    if L is None: 
        L = [] 
    L.append('END') 
    return L

现在，无论调用多少次，都不会有问题：

>>> add_end()
['END']
>>> add_end()
['END']

为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

可变参数

可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个
如果没有可变参数，我们可以把list或tuple当函数参数传入

def calc(numbers): 
    sum = 0 
    for n in numbers: 
        sum = sum + n * n 
    return sum

调用：

>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84

这样可以实现可变参数，但是在调用时必须传入一个list或tuple，很不方便，所以可以使用可变参数，其实可变参数的实现也是使用的list和tuple

def calc(*numbers): 
    sum = 0 
    for n in numbers: 
        sum = sum + n * n 
    return sum

只是在参数前加了个'*'。这样，调用时就可以直接传入参数，而不需要传入一个list或者tuple：

>>> calc(1, 2)
5
>>> calc()
0

如果想传入一个已有的list或者tuple，可以这样：

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

调用时在参数名前加上一个'*'就可以了

关键字参数

关键字参数和可选参数类似，也是允许传入0个或多个参数，不同的是这些参数传入时是以key-value的形式传入的，函数内部会自动组装成一个dict。定义时用'**'放到参数名前边表示，如：

def person(name, age, **kw)
    print 'name:', name, 'age:', age, 'other:', kw

函数除了必选参数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再传入：

>>> kw = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **kw)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

参数组合

在python的函数中，可以使用必选参数、默认参数、可选参数、关键字参数这四种参数，这四种参数可以一起使用或者只使用其中的某些，但是参数定义的顺序必须是：必选参数->默认参数->可变参数->关键字参数
比如定义一个函数，包含以上四种参数：

def func(a, b, c=0, *agrs, **kw):
    print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw

调用时可以这样：

>>> func(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}

还有一种调用方式：

>>> args = (1, 2, 3, 4)
>>> kw = {'x': 99}
>>> func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}

通过一个list和一个tuple调用，把前边的必选参数、可选参数和可变参数组装成一个tuple，后边的关键字参数组装成一个dict传入进行调用：

>>> args = (1, 2, 3, 4)
>>> kw = {'x': 99}
>>> func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}

*python中对于任意的函数，都可以使用类似func(args, kw)的形式调用，无论他的参数是如何定义的

使用args和*kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

递归函数

在函数内部，可以调用其他函数，如果一个函数在内部调用自身本身，这个函数就是递归函数
比如，计算n! = 1 * 2 * 3 * ... *n

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

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意要防止栈溢出。，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。如fact(1000)就会产生栈溢出

解决递归栈溢出的问题可是使用尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：

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)

可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和num * product在函数调用前就会被计算，不影响函数调用。

尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。

end