码迷,mamicode.com
首页 > 编程语言 > 详细

2015/9/17 Python基础(13):函数

时间:2015-09-17 22:55:53      阅读:289      评论:0      收藏:0      [点我收藏+]

标签:

函数是对程序逻辑进行结构化或过程化的一种编程方法。

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

 

2015/9/17 Python基础(13):函数

标签:

原文地址:http://www.cnblogs.com/SRL-Southern/p/4817789.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!