标签:
函数是对程序逻辑进行结构化或过程化的一种编程方法。
Python的函数返回值
当什么也不返回时,返回了None
和大多数语言一样,Python返回一个值或对象。只是在返回容器对象时,看起来像返回多个对象。
这样在操作的时候显得很灵活,虽然它本质上只是反悔了一个对象。
调用函数
我们用一对圆括号电泳函数。任何输入的参数都应该放在括号中。
关键字参数
这个概念是针对函数调用的,比如我们有这样的函数
def fun(value, count): fun_suite
我们可以标准调用:
fun(12,20)
也可以关键字调用
fun(value = 12, count = 20)
或者
fun(count = 20, value =12)
这样可以丰富调用的方法。另外当参数允许“缺失”的时候,也可以用关键字参数。这取决于函数的默认参数。
参数组
Python同样允许程序员执行一个没有显式定义参数的函数,相应的方法是通过一个把元组或字典作为参数传递给函数(元组是非关键字调用,字典是关键字调用)。基本上,可以把所有参数放进一个元组或字典中,仅仅用这些装有参数的容器来调用一个函数,而不必显式地将它们放在函数调用中:
func(*tuple_grp_nonkw_args, **dict_grp_kw_args)
其中,tuple_grp_nonkw_args是以元组形式体现的非关键字参数组,dict_grp_kw_args是装有关键字参数的字典。这样的特性允许把变量放在元组和/或字典里,并在没有显式地对参数进行逐个声明的情况下调用函数。
当然也可以给出形参:
func(positional_args, keyword_args,
*tuple_grp_nonkw_args, **dict_grp_kw_args)
该语法的所有参数都是可选的,在单独函数调用时,每个参数都是独立的。可以有效取代Python1.6以前的apply()内建函数。
如下例:
from operator import add, sub from random import randint, choice ops = {‘+‘: add, ‘-‘: sub} MAXTRIES = 2 def doprob(): op = choice(‘+-‘) nums = [randint(1,10) for i in range(2)] nums.sort(reverse = True) ans = ops[op] (*nums) # *表示后面这个变量是个元组,这一句用了前缀操作符 pr = ‘%d %s %d = ‘%(nums[0],op,nums[1]) oops = 0 while True: try: if int(raw_input(pr)) == ans: print ‘correct‘ break if oops == MAXTRIES: print ‘answer\n%s%d‘ %(pr, ans) else: print ‘incorrect... try again‘ oops += 1 except (KeyboardInterrupt, EOFError, ValueError) : print ‘invalid input... try again‘ def main(): while True: doprob() try: opt = raw_input(‘Again? [y]‘).lower() if opt and opt[0] == ‘n‘: break except (KeyboardInterrupt, EOFError): break if __name__ == ‘__main__‘: main()
上面带有注释那一行,在Python1.6以前,要写成apply(ops[op], nums),而不是ops[op](*nums)
创建函数
def语句
语法如下:
def function_name(arguments): "function_documentation_string" function_body_suite
前向引用,要在使用前定义函数。
函数属性
命名空间与作用域的关系
可以获得每个Python模块,类,和函数中任意的名字空间。可以在模块foo和bar里都有名为x的一个变量,但是在将这两个模块导入你的程序后,仍然可以使用这两个变量。所以,即使在两个模块中使用了相同的变量名字,也是安全的,因为句点属性标识对于两个模块意味了不同的命名空间,比如说,在这段代码中没有名字冲突:
import foo, bar print foo.x + bar.x
函数属性是Python另外一个使用了句点属性标识并拥有名字空间的领域。
名字空间和作用域的关系,在之前的笔记 模块 这一部分里有详细叙述。
内嵌函数
在函数体内创建另外一个函数(对象)是完全合法的。这种函数叫做内部/内嵌函数。因为现在Python支持静态地嵌套域,内部函数实际上是很有用的。
最明显的创造内部函数的方法是在外部函数的定义体内定义函数,如:
def foo(): def bar(): print ‘bar() called‘ print ‘foo() called‘ bar() foo() bar()
结果是:
foo() called bar() called Traceback (most recent call last): File "<pyshell#6>", line 1, in <module> bar() NameError: name ‘bar‘ is not defined
传递函数
Python的函数就和其他对象一样,函数是可以被引用的,也可以作为参数传入函数,以及作为列表和字典等等容器对象的元素。
函数有个独一无二的特征使它同其他对象区分开来,那就是函数是可调用的。
因为所有的对象都是通过引用来传递的,函数也不例外。当对一个变量赋值时,实际上是将相同对象的引用赋值给这个变量。如果对象是函数的话,这个对象所有的别名都是可调用的。
>>> def foo(): print ‘in foo()‘ >>> bar = foo >>> bar <function foo at 0x02B3A0B0> >>> bar() in foo() >>> bar = foo() in foo() >>> bar >>> print bar
当我们把foo赋值给bar时,bar和foo引用了同一个函数对象,所以能以和调用foo()相同的方式调用。foo是函数对象的引用,foo()是函数对象的调用。
同时,函数也可以作为参数传入其他函数来进行调用
>>> def bar(func): func() >>> bar(foo) in foo()
注意,是将函数对象的引用作为参数,而不是函数对象的调用。
形式参数
Python函数的形参集合由在调用时要传入函数的所有参数组成,这参数与函数声明中的参数列表精确的配对。这些参数包括了所有必要参数(如果是标准调用则用正确的定位顺序来传入函数,如果是关键字调用则不一定按顺序传入)以及所有含有默认值,函数调用时不必要指定的参数。(声明函数时创建的)局部命名空间为各个参数值,创建了一个名字,一旦函数开始执行,即能访问这个名字。
位置参数
位置参数必须以在bewilder调用函数中定义的准确顺序来传递。另外,没有任何默认参数的话,传入函数的参数的精确的数目必须和声明的数字一致。位置参数也就是我们熟悉的标准化参数
默认参数
对于默认参数,如果在函数调用时我们没有提供值,就预先使用定义的标准值,如下:
>>> def taxMe(cost, rate=0.0825): return cost + (cost * rate) >>> taxMe (100) 108.25 >>> taxMe (100, 0.05) 105.0
默认参数让程序的健壮性上升到极高的级别,因为它们补充了标准位置参数没有提供的一些灵活性。
我们声明时,所有的必需参数都要在默认参数之前。否则,在混合模式下,解释器将无法知道如何匹配参数。当然,如果使用关键字参数的方式,是可以改换顺序的,前提是所有没给默认值的参数都传入了值。
可变长度的参数
可能会有需要函数处理可变数量参数的情况。这时可以使用可变长度的参数列表。变长的参数在函数声明中不是显式命名的,因为参数的数目在运行时是未知的,这和常规参数(位置和默认)明显不同,床柜参数都是在函数声明中命名的。由于函数调用提供了关键字以及非关键字两种参数类型,Python用两种方式来支持变长参数。
非关键字可变长参数(元组)
当函数被调用的时候,所有的形参(必须的和默认的)都将值赋给了在函数声明中对应的局部变量。
剩下的非关键字参数按顺序插入到一个元组中便于访问。Python在函数调用时,可以接受一个不定数目的参数。
可变长参数元组必须在位置和默认参数之后,带元组(或者非关键字可变长参数)的函数语法如下:
def function_name([formal_args,] *vargs_tuple): ‘function_documentation_string‘ function_body_suite
星号操作符之后的形参将作为元组传递给函数,元组保存了所有传递给函数的“额外”的参数(匹配了所有位置和具名参数后剩余的)。如果没有给出额外参数,元组为空。
在我们之前的函数调用中,如果给出了不正确的函数参数数目,就会产生一个TypeError异常。通过末尾增加一个可变的参数列表变量,我们就能处理当超过数目的参数被传入函数的情形,因为所有的额外(非关键字)参数会被添加到变量参数元组。而和位置参数必须放在关键字参数之前一样的原因,所有的形式参数必须先于非正式参数之前出现。
def tupleVarArgs(arg1, arg2 = ‘defaultB‘, *theRest): ‘display regular args and non-keyword variable args‘ print ‘formal arg 1:‘, arg1 print ‘formal arg 2:‘, arg2 for eachXtrArg in theRest: print ‘another arg:‘, eachXtrArg
运行结果如下:
>>> tupleVarArgs(‘abc‘) formal arg 1: abc formal arg 2: defaultB >>> tupleVarArgs(23,4.56) formal arg 1: 23 formal arg 2: 4.56 >>> tupleVarArgs(‘abc‘,123,‘xyz‘,456.789) formal arg 1: abc formal arg 2: 123 another arg: xyz another arg: 456.789
关键字变量参数(字典)
在我们有不定数目的或者额外集合的关键字的情况中,参数被放入一个字典中,字典中键为参数名,值为相应的参数值。
语法为:
def function_name([formal_args,][*vargst,] **theRest): function_documentation_string function_body_suite
为了区分关键字参数和非关键字非正式参数,使用了双星号(**)。**是被重载了的一边不与幂运算发生混淆。关键字变量参数应该为函数定义的最后一个参数,带**。如下例:
>>> def dictVarArgs(arg1,arg2=‘defaultB‘,**theRest): ‘display 2 regular args and keyword variable args‘ print ‘formal arg1:‘, arg1 print ‘formal arg2:‘, arg2 for eachXtrArg in theRest.keys(): print ‘Xtra arg %s: %s‘ % (eachXtrArg, str (theRest[eachXtrArg])) >>> dictVarArgs(1220,740.0,c=‘grail‘) formal arg1: 1220 formal arg2: 740.0 Xtra arg c: grail >>> dictVarArgs(arg2=‘tales‘, c=123, d=‘poe‘, arg1=‘mystery‘) formal arg1: mystery formal arg2: tales Xtra arg c: 123 Xtra arg d: poe
关键字和非关键字可变长参数都有可能用在同一个函数中,只要关键字字典是最后一个参数并且非关键字元组先于它之前出现。
调用带有可变长参数对象函数
将展示一些使用它的例子:
>>> def newfoo(arg1, arg2, *nkw, **kw): ‘display regular args and all variable args‘ print ‘arg1 is :‘, arg1 print ‘arg2 is :‘, arg2 for eachNKW in nkw: print ‘additional non-keyword arg:‘, eachNKW for eachKW in kw.keys(): print "additional keyword arg ‘%s‘: %s"%(eachKW, kw[eachKW]) >>> newfoo(‘wolf‘,3,‘projects‘,freud=90,gamble=96) arg1 is : wolf arg2 is : 3 additional non-keyword arg: projects additional keyword arg ‘gamble‘: 96 additional keyword arg ‘freud‘: 90 >>> newfoo(10,20,30,40,foo=50,bar=60) arg1 is : 10 arg2 is : 20 additional non-keyword arg: 30 additional non-keyword arg: 40 additional keyword arg ‘foo‘: 50 additional keyword arg ‘bar‘: 60 >>> newfoo(2,4,*(6,8),**{‘foo‘:10,‘bar‘:12 }) arg1 is : 2 arg2 is : 4 additional non-keyword arg: 6 additional non-keyword arg: 8 additional keyword arg ‘foo‘: 10 additional keyword arg ‘bar‘: 12 >>> aTuple = (6,7,8) >>> aDict = {‘z‘: 9} >>> newfoo(1,2,3,x=4,y=5, *aTuple, **aDict) arg1 is : 1 arg2 is : 2 additional non-keyword arg: 3 additional non-keyword arg: 6 additional non-keyword arg: 7 additional non-keyword arg: 8 additional keyword arg ‘y‘: 5 additional keyword arg ‘x‘: 4 additional keyword arg ‘z‘: 9
标签:
原文地址:http://www.cnblogs.com/SRL-Southern/p/4817789.html