首页 > 代码库 > 函数(2)
函数(2)
返回值
#!/usr/bin/env python# coding=utf-8‘‘‘ 非波那契数列‘‘‘def fibs(n): result = [0,1] for i in range(n-2): result.append(result[i] + result[i+1]) return resultif __name__ == "__main__": lst = fibs(10) print lst
上面的函数只返回了一个返回值（是一个列表），有时候需要返回多个，是以元组形式返回。
没有return的函数，事实上返回的是一个None。
把那个只在函数体内（某个范围内）起作用的变量称之为局部变量。
有局部，就有对应的全部，在汉语中，全部变量，似乎有歧义，幸亏汉语丰富，于是又取了一个名词：全局变量
参数收集
函数的参数的个数不确定性
def func(x,*arg): print x #输出参数x的值 result = x print arg #输出通过*arg方式得到的值 for i in arg: result +=i return resultprint func(1,2,3,4,5,6,7,8,9) #赋给函数的参数个数不仅仅是2个
- 值1传给了参数x
- 值2,3,4,5,6.7.8.9被塞入一个tuple里面，传给了arg
运行此代码后，得到如下结果：
1 #这是函数体内的第一个print，参数x得到的值是1(2, 3, 4, 5, 6, 7, 8, 9) #这是函数内的第二个print，参数arg得到的是一个元组45 #最后的计算结果
如果输入的参数个数不确定，其它参数全部通过*arg，以元组的形式由arg收集起来。
>>> def foo(*args):... print args #打印通过这个参数得到的对象...下面演示分别传入不同的值，通过参数*args得到的结果：
>>> foo(1,2,3)(1, 2, 3)>>> foo("qiwsir","qiwsir.github.io","python")(‘qiwsir‘, ‘qiwsir.github.io‘, ‘python‘)>>> foo("qiwsir",307,["qiwsir",2],{"name":"qiwsir","lang":"python"})(‘qiwsir‘, 307, [‘qiwsir‘, 2], {‘lang‘: ‘python‘, ‘name‘: ‘qiwsir‘})
不管是什么，都一股脑地塞进了tuple中。
>>> foo("python")(‘python‘,)
即使只有一个值，也是用tuple收集它。特别注意，在tuple中，如果只有一个元素，后面要有一个逗号。
还有一种可能，就是不给那个*args传值，也是许可的。例如：
>>> def foo(x, *args):... print "x:",x... print "tuple:",args... >>> foo(7)x: 7tuple: ()
这时候*args收集到的是一个空的tuple。
bar 常被用作变量名，foo常用于函数/方法的名称，foobar常作为伪变量
*kargs的形式接收数值
>>> def foo(**kargs):... print kargs...>>> foo(a=1,b=2,c=3) #注意观察这次赋值的方式和打印的结果{‘a‘: 1, ‘c‘: 3, ‘b‘: 2}
**kargs的形式收集值，会得到dict类型的数据，但是，需要在传值的时候说明“键”和“值”，因为在字典中是以键值对形式出现的。
综合起来：
>>> def foo(x,y,z,*args,**kargs):... print x ... print y... print z... print args... print kargs ... >>> foo(‘qiwsir‘,2,"python")qiwsir2python(){}>>> foo(1,2,3,4,5)123(4, 5){}>>> foo(1,2,3,4,5,name="qiwsir")123(4, 5){‘name‘: ‘qiwsir‘}
另外一种传值方式
>>> def add(x,y):... return x + y... >>> add(2,3)5
这是通常的函数调用方法，在前面已经屡次用到。这种方法简单明快，很容易理解。但是，世界总是多样性的，有时候你秀出下面的方式，甚至在某种情况用下面的方法可能更优雅。
>>> bars = (2,3)>>> add(*bars)5
先把要传的值放到元组中，赋值给一个变量bars，然后用add(*bars)的方式，把值传到函数内。这有点像前面收集参数的逆过程。注意的是，元组中元素的个数，要跟函数所要求的变量个数一致。如果这样：
>>> bars = (2,3,4)>>> add(*bars)Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: add() takes exactly 2 arguments (3 given)
就报错了。这是使用一个星号*，是以元组形式传值，如果用**的方式，是不是应该以字典的形式呢？理当如此。
>>> def book(author,name):... print "%s is writing %s" % (author,name)... >>> bars = {"name":"Starter learning Python","author":"Kivi"}>>> book(**bars)Kivi is writing Starter learning Python
这种调用函数传值的方式，至少在我的编程实践中，用的不多。不过，不代表读者不用。这或许是习惯问题。
总结常见的函数参数定义方式
def foo(p1,p2,p3,...)
这种方式最常见了，列出有限个数的参数，并且彼此之间用逗号隔开。在调用函数的时候，按照顺序以此对参数进行赋值，特备注意的是，参数的名字不重要，重要的是位置。而且，必须数量一致，一一对应。第一个对象（可能是数值、字符串等等）对应第一个参数，第二个对应第二个参数，如此对应，不得偏左也不得偏右。
def foo(p1=value1,p2=value2,...)
这种方式比前面一种更明确某个参数的赋值，貌似这样就不乱子了，很明确呀。颇有一个萝卜对着一个坑的意味。
def foo(*args)
这种方式适合于不确定参数个数的时候，在参数args前面加一个*，注意，仅一个哟。
def foo(**args)
这种方式跟上面的区别在于，必须接收类似arg=val形式的。
>>> def foo(x,y=2,*targs,**dargs):... print "x==>",x... print "y==>",y... print "targs_tuple==>",targs... print "dargs_dict==>",dargs...>>> foo("1x")x==> 1xy==> 2targs_tuple==> ()dargs_dict==> {}>>> foo("1x","2y")x==> 1xy==> 2ytargs_tuple==> ()dargs_dict==> {}>>> foo("1x","2y","3t1","3t2")x==> 1xy==> 2ytargs_tuple==> (‘3t1‘, ‘3t2‘)dargs_dict==> {}>>> foo("1x","2y","3t1","3t2",d1="4d1",d2="4d2")x==> 1xy==> 2ytargs_tuple==> (‘3t1‘, ‘3t2‘)dargs_dict==> {‘d2‘: ‘4d2‘, ‘d1‘: ‘4d1‘}
函数(2)