python-函数

比较函数:cmp(x,y)
x > y返回1，x=y返回0;
x < y时返回-1.
判断一个数不是整数时，给出错误提示：

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

函数可以同时返回多个值，但其实就是一个tuple。

IndentationError一般是由于缩进错误导致的。

---

默认参数

不变对象
定义默认参数要牢记一点：默认参数必须指向不变对象！

当你使用默认参数调用时，一开始结果也是对的：
如下空数列[]是个可变对象，会出现异常。

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

但是，再次调用add_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 

---

可变参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
可变参数定义时是在参数前加一个星号，调用时可以输入任意个参数包括0个。
给定一组数字a，b，c……，请计算a2 + b2 + c2 + ……。

def calc(*numbers):
    sum = 0
    for i in numbers:
        sum = sum + i*i
    return sum
s = calc(1,3,5)
print s

tuple或list调用可变参数方式，在变量名前加星号：

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

---

关键字参数

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

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

>>> 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**变量名前加两个星号**。

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

---

参数组合

必选参数、默认参数、可变参数和关键字参数，这4种参数都可以一起使用。

def func(a, b, c=0, *args, **kw):
   print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw
>>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
#最神奇的是通过一个tuple和dict，你也可以调用该函数：
>>> args = (1, 2, 3, 4)
>>> kw = {'x': 99}
>>> func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}

要注意定义可变参数和关键字参数的语法：

*args是可变参数，args接收的是一个tuple；

**kw是关键字参数，kw接收的是一个dict。

---

递归函数

我们来计算阶乘n! = 1 x 2 x 3 x … x n，用函数fact(n)表示
fact(n) = n! = 1 x 2 x 3 x … x (n-1) x n = (n-1)! x n = fact(n-1) x n
所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。

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

使用递归函数需要注意防止栈溢出。
解决递归调用栈溢出的方法是通过尾递归优化
例：

#一个参数化为两个的方法。
def fact(n):
    return fact_iter(n, 1)
#product = 1 可以理解为一个累积，类似累加sum=1.
def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)

fact(5)对应的fact_iter(5, 1)的调用如下：

===> fact_iter(5, 1)
===> fact_iter(4, 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
===> 120

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