一、def 创建函数

1. #----------------------------------------------------------------------  
2. def hello(name):  
3.     """test""" 
4.     return 'hello, ' + name + '!' 
5.  
6. print hello('wisp') 
7.  
8. 结果为：
9. hello, wisp!

二、关键字参数

传递参数的时候指定形参，可以不分顺序地向函数传入参数，在创建函数的时候使用关键字也可以成为该参数的默认值。

1. >>> def hello(greeting,name):  
2.     print '%s,%s!' % (greeting,name)  
3. >>> hello('hello','wisp')  
4. hello,wisp!  
5. >>> hello(greeting='hello',name='wisp')  
6. hello,wisp! 

使用关键字提供默认值：

1. >>> def hello_new(greeting='hello',name='wisp'):  
2.     print '%s,%s!' % (greeting,name)  
3.  
4. >>> hello_new()  
5. hello,wisp! 

三、任意长度的参数

在形参前面加"*"号，这样所有的参数会放在同一个元组中，然后使用，如果不提供任何参数，形参就是一个空元组

1. >>> def print_params(*params):  
2.     print params  
3.  
4. >>> print_params('Testing')  
5. ('Testing',)  
6. >>> print_params(1,2,3)  
7. (1, 2, 3) 

** 号收集关键字

1. >>> def print_params_3(**params):  
2.     print params  
3. >>> print_params_3(x=1,y=2,z=3)  
4. {'y': 2, 'x': 1, 'z': 3} 

四、反转过程

把元组或者字典分解成参数传给函数

* 分解元组

** 分组字典

1. >>> def add(x,y):  
2.     return x + y  
3.  
4. >>> params = (1,2)  
5. >>> add(*params)  
6. 3 
7.  
8. >>> def hello_new(greeting='hello',name='wisp'):  
9.     print '%s,%s!' % (greeting,name)  
10. >>> params = {'name':'wisp','greeting':'hello'}  
11. >>> hello_new(**params)  
12. hello,wisp! 

五、作用域

每个函数调用都会创建一个新的作用域，函数内的变量称为局部变量，函数内部可以用globals()[] 调用全局变量，函数内部也可以用global 来定义全局变量

1. >>> x = 1 
2. >>> def change_global():  
3.     global x  
4.     x = x + 1 
5.  
6. >>> change_global()  
7. >>> x  
8. 2 

6、递归

递归，就是引用自身。

当函数直接返回值时有基本实例

递归实例，包括一个或者多个问题最小部分的递归调用

1. def factorial(n):  
2.     """by wisp""" 
3.     if n == 1:  
4.         return 1 
5.     else:  
6.         return n * factorial(n-1)  
7.  
8. print factorial(10)  
9.  
10. 3628800 

二元查找算法：

1. def search(sequence, number, lower, upper):  
2.     """by wisp""" 
3.     if lower == upper:  
4.         assert number == sequence[upper]  
5.         return upper  
6.     else:  
7.         middle = (lower + upper) // 2 
8.         if number > sequence[middle]:  
9.             return search(sequence, number, middle+1, upper)  
10.         else:  
11.             return search(sequence, number, lower, middle)  
12.  
13.  
14. print search(range(1,100),37)