python之函数
函数
定义函数
为了定义python函数，你可以依次输入def,函数名，带有函数参数的圆括号，最后紧跟一个冒号（:）
现在定义一个无参数，但打印除一个单词的函数：
>>> def make_a_sound():
... print "quack"
...
>>> make_a_sound()
quack
在函数中引入参数，定义带有一个anything参数的函数echo(),它使用return 语句将anything返回给它的调用者两次，并在两次中间加入一个空格
>>> def echo(anything):
... return anything+' '+anything
...
>>> echo('Rumplestitskin')
'Rumplestitskin Rumplestitskin'
传入的值称为参数，当调用含参数的函数时，这些参数的值会复制给函数中的对应参数。
位置参数
Python处理参数的方式要比其他语言更加灵活，其中，最熟悉的就是位置参数，传入参数的值就是按照顺序依次复制过去的
>>> def menu(wine,entree,dessert):
... return{'wine':wine,'entree':entree,'dessert':dessert}
...
>>> menu('chardonnay','chicken','cake')
{'dessert': 'cake', 'entree': 'chicken', 'wine': 'chardonnay'}
关键字参数
>>> menu(entree='beef',dessert='bagal',wine='bordeaux')
{'dessert': 'bagal', 'entree': 'beef', 'wine': 'bordeaux'}
>>>
指定默认参数值
>>> def menu(wine,dessert='flan',entree='pudding'):
... return {'wine':wine,'entree':entree,'dessert':dessert}
...
>>> menu('chicken')
{'dessert': 'flan', 'entree': 'pudding', 'wine': 'chicken'}
如果你提供参数值，在调用时会代替默认值
>> menu('dunkelfelder','duck','doughnut')
{'dessert': 'duck', 'entree': 'doughnut', 'wine': 'dunkelfelder'}
看下面的例子，函数buggy()在每次调用时，调用参时arg到一个空的列表result，然后打印输出一个单值列表，但是存在一个问题，只有在第一次调用时列表是空的，第二次调用时就会存在之前调用的返回值
>>> def buggy(arg,result=[]):
... result.append(arg)
... print result
...
>>> buggy('a')
['a']
>>> buggy('b')
['a', 'b']
如果写成这个样子就会解决上面的问题
>>> def works(arg):
... result=[]
... result.append(arg)
... print result
...
>>> works('a')
['a']
>>> works('b')
['b']
使用*收集位置参数
当参数被用到函数内部的时候，星号将一组数量的位置参数集合成参数值的元祖，在下面的例子中args是传入到函数print_args()的参数值的元祖
>> def print_args(*args):
... print ('Positional argument tuple: ',args)
...
>>> print_args() #无参数调用函数，什么也不会返回
('Positional argument tuple: ', ())
给函数传入的所有参数都会以元祖的形式返回输出
>>> print_args(3,2,1,'waits','unh...')
('Positional argument tuple: ', (3, 2, 1, 'waits', 'unh...'))
>>>
使用**收集关键字参数
使用两个星号可以将参数收集到一个字典中，参数的名字是字典的健，对应参数的值是字典的值
>>> def print_kwargs(**kwargs):
... print('Keyword arguments:',kwargs)
...
X
现在使用一些关键字参数调用函数
>>> print_kwargs(wine='merlot',entree='mutton',dessert='macaroon')
('Keyword arguments:', {'dessert': 'macaroon', 'entree': 'mutton', 'wine': 'merlot'})
在函数内部，kwargs是一个字典
内部函数
在python中，可以在函数中定义另外一个函数
>>> def outer(a,b):
... def inner(c,d):
... return c+d
... return inner(a,b)
...
>>> outer(2,3)
5
当需要在函数内部多次执行复杂任务的时候，内部函数是非常有用的，内部函数可以看成一个闭包。
>> def knights(saying):
... def inner():
... return "we are the kgights who says :%s"%saying
... return inner
...
Inner（）函数可以得到sayin参数的值并且记录下来，return inner这一行返回的值是inner函数的复制（没有直接调用），所以它是一个闭包：一个动态创建的可以记录外部变量的函数
>>> a=knights('Duck')
>>> b=knights('Hasenpffer')
>>> a
<function inner at 0x7f10757e8ed8>
>>> a()
'we are the kgights who says :Duck'
>>> b()
'we are the kgights who says :Hasenpffer'
>>>
匿名函数lanmbda()
）Lambda是一个表达式，而不是一个语句。因为这点。Lambda能够出现在不允许def出现的地方。
2）lambda的主体是一个单个的表达式，而不是一个代码块。
使用lambda好处：lambda起到了一种函数速写的作用，允许在使用的代码内嵌一个函数的定义，
Lambda函数小例子
1)用lambda函数求和
>>> f=lambda x,y,z:x+y+z
>>> f(1,2,3)
6
2）
>>> def knights():
... title="sir"
... action=(lambda x:title+' '+x)
... return action
...
>>> act=knights()
>>> act('ll')
'sir ll'
3）求某数的平方，三次方和四次方
>>> L=[(lambda x:x**2),(lambda x:x**3),(lambda x:x**4)]
>>> for i in L:
... print i(2)
...
4
8
16
>>> print L[0](3)
9
4
）>>> ((lambda x:(lambda y:x+y))(99))(4)
103
>>> action=(lambda x:(lambda y:x+y))
>>> act=action(99)
>>> act(3)
102
