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