Python函数

函数定义：

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

In [3]: def sum(a,b):
   ...:     return a + b
   ...:

In [4]: sum(1,2)
Out[4]: 3

定义一个空函数：

In [6]: def no():
   ...:     pass
In [8]: no()

返回多个值：实际上返回的就是一个tuple

In [10]: def cal(x,y):
   ....:     sum = x+y
   ....:     re = x-y
   ....:     return sum,re
   ....:

In [11]: cal(1,2)
Out[11]: (3, -1)

　默认参数：在定义函数的同时给参数赋值

如：　

In [6]: def sum(x,n = 2):
   ...:     while n >0 :
   ...:         a = x
   ...:         x = a + x
   ...:         n = n-1
   ...:     return x

In [7]: sum(3)

但要注意默认参数必须指向不变对象！

如：传入一个list

In [8]: def sum (L = []):
   ...:     L.append('a')
   ...:     return L

In [12]: sum([1,2,3])
Out[12]: [1, 2, 3, 'a']

In [13]: sum([1])
Out[13]: [1, 'a']

In [14]: sum([1])
Out[14]: [1, 'a']

In [9]: sum()
Out[9]: ['a']

In [10]: sum()
Out[10]: ['a', 'a']

这时不使用默认参数时，这里传入的是不可变的对象，函数调用完不会保存，但是如果是可变的对象，就会将该对象保存下来

具体的原因解释：

原因解释如下：

Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

这样就相当于是下面这样子，就是引用调用

In [17]: L  = [1,2,3,4]

In [18]: sum(L)
Out[18]: [1, 2, 3, 4, 'a']

这里也可以认为多线程使用同一个资源，需要加锁，所以可以用下面的方法给它加锁

In [37]: def sum(L = None):
   ....:     if(L == None):
   ....:         L = []
   ....:     L.append('a')
   ....:     return L
   ....:

In [38]: sum()
Out[38]: ['a']

In [39]: sum()
Out[39]: ['a']

可变参数：就是说的是参数的个数不能确定，可以用list或tuple

In [41]: def sum(array):
   ....:     a = 0
   ....:     for i in array:
   ....:         a = a + i
   ....:     return a
   ....:

In [42]: sum([1,2,3])
Out[42]: 6

如果想要想直接输入变量，可以这样

In [41]: def sum(*array):
   ....:     a = 0
   ....:     for i in array:
   ....:         a = a + i
   ....:     return a
   ....:

In [42]: sum(1,2,3)
Out[42]: 6

递归函数：在内部调用自身本身，这个函数就是递归函数。实质是通过栈实现的

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