不带参数函数定义：
In [9]: def f3():
...: x = 90
...: print x
...:
In [10]: f3()
90
带参数函数定义：
In [1]: def f1(x,y):
...: print x + y
...:
In [2]: f1(5,6)
11
In [3]: f1('hello','world')
helloworld
参数的使用：
使用带参数的函数
m=3;n=5
In [14]: def f4(x,y):
x -= 1
print x,y
....:
In [15]: f4(m,n)
2 5
In [16]: print m,n
3 5 #原来的变量不会变，因为是对应的对象。
可变参数：
调用函数时使用可变参数要求：
定义函数时使用*：收集位置参数
定义函数时使用**: 收集关键字参数
In [1]: m = 3;n = 4
*x 元祖模式
In [2]: def f1(*x):
...: print x
...:
In [3]: f1(m)
(3,)
In [4]: f1(m,n)
(3, 4)
In [6]: f1(m,n,9)
(3, 4, 9)
In [7]: f1(m,n,9,7)
(3, 4, 9, 7)
**x 字典模式
In [11]: def f2(**x):
print x
....:
In [12]: f2(x=m,y=n)
{'y': 4, 'x': 3}
In [13]: f2(x=m,y=n,z=9)
{'y': 4, 'x': 3, 'z': 9}
混合使用位置参数，和元祖，字典形式：
In [15]: def f3(x,*y): #不能（*y,x）,只要有可变参数，只能写在位置参数后面
....: print x,y
....:
In [17]: o=7
In [18]: f3(m,n,o)
3 (4, 7)
元祖形式和字典形式混用，所有元祖形式被*x收集，字典模式被**y收集
In [19]: def f4(*x,**y):
....: print x
....: print y
....:
In [20]: f4(m,n,o,i=3,j=6)
(3, 4, 7)
{'i': 3, 'j': 6}
分解参数
在调用的时候使用*号，分解，调用是为了分解。必须要参数个数匹配。
In [20]: f4(m,n,o,i=3,j=6)
(3, 4, 7)
{'i': 3, 'j': 6}
In [21]: l1 = [ 'Sun','Mon','Tus']
In [22]: def f5(x,y,z):
....: print x,y,z
....:
In [23]: f5(*l1)
Sun Mon Tus
定义和调用都使用可变参数：
In [24]: d1 = {'key1':'v1','key2':'v2','key3':77}
In [25]: def f9(x,*y,**z):
....: print x
....: print y
....: print z
....:
In [26]: f9(m,l1,**d1)
3
(['Sun', 'Mon', 'Tus'],)
{'key3': 77, 'key2': 'v2', 'key1': 'v1'}
lambda 函数
lambda是个表达式而非函数
In [27]: lambda x,y:x + y #x + y 是个表达式
Out[27]: <function __main__.<lambda>>
In [28]: f20 = lambda x,y:x + y
In [29]: f20(3,4)
Out[29]: 7
i是一个lambda函数对象，i(4)是传递一个参数4
In [30]: l3 = [(lambda x:x*2),(lambda y:y*3)]
In [33]: for i in l3:
....: print i(4)
....:
8
12
过滤器
fileter(函数，过滤的列表)
通过函数，过滤列表，生成新的列表、
In [34]: l1 = [2,4,5,60,50,23]
In [35]: def f1(x):
....: if x > 20:
....: return True
....: else:
....: return False
....:
In [36]: filter(f1,l1)
Out[36]: [60, 50, 23]