Chinaunix首页 | 论坛 | 博客
  • 博客访问: 46985
  • 博文数量: 23
  • 博客积分: 425
  • 博客等级: 下士
  • 技术积分: 237
  • 用 户 组: 普通用户
  • 注册时间: 2012-12-10 09:57
文章分类

全部博文(23)

文章存档

2013年(23)

我的朋友

分类: Python/Ruby

2013-06-16 20:14:27

通常情况下,Python内的参数传递与C非常类似,另外,对于元组及字典的存在而引入类似指针作用的带星号传参方式,

函数参数的使用又有俩个方面值得注意:1.函数参数是如何定义的 2.在调用函数的过程中参数是如何被解析,在python中函数参数的定义主要有四种方式:

1.F(arg1,arg2,...)
这 是最常见的定义方式,一个函数可以定义任意个参数,每个参数间用逗号分割,用这种方式定义的函数在调用的的时候也必须在函数名后的小括号里提供个数相等的 值(实际参数),而且顺序必须相同,也就是说在这种调用方式中,形参和实参的个数必须一致,而且必须一一对应,也就是说第一个形参对应这第一个实参。例 如:
def a(x,y):
print x,y
调用该函数,a(1,2)则x取1,y取2,形参与实参相对应,如果a(1)或者a(1,2,3)则会报错。


2.F(arg1,arg2=value2,...)
这种方式就是第一种的改进版,提供了默认值
def a(x,y=3):
print x,y
调用该函数,a(1,2)同样还是x取1,y取2,但是如果a(1),则不会报错了,这个时候x还是1,y则为默认的3。上面这俩种方式,还可以更换参数位置,比如a(y=8,x=3)用这种形式也是可以的。


3.F(*arg1)
上 面俩个方式是有多少个形参,就传进去多少个实参,但有时候会不确定有多少个参数,则此时第三种方式就比较有用,它以一个*加上形参名的方式来表示这个函数 的实参个数不定,可能为0个也可能为n个。注意一点是,不管有多少个,在函数内部都被存放在以形参名为标识符的tuple中。

[python]
  1. >>> def a(*x):  
  2. if len(x)==0:  
  3. print 'None'  
  4. else:  
  5. print x  
  6. >>> a(1)  
  7. (1,)        #存放在元组中   
  8. >>> a()  
  9. None  
  10. >>> a(1,2,3)  
  11. (123)  
  12. >>> a(m=1,y=2,z=3)  
  13.   
  14. Traceback (most recent call last):  
  15. File "", line 1in -toplevel-  
  16. a(m=1,y=2,z=3)  
  17. TypeError: a() got an unexpected keyword argument 'm'  

事实上,对于采用星号将参数收集为元组也存在相应“逆过程”:在调用函数时,将传入的元组分配给不同的参数

[python]
  1. >>>def add(x, y):  
  2. return x+y  
  3. >>>params = (12)  
  4. >>>add(*params)  
  5. 3  

 

4.F(**arg1)
形参名前加俩个*表示,参数在函数内部将被存放在以形式名为标识符的dictionary中,这时调用函数的方法则需要采用arg1=value1,arg2=value2这样的形式。

[python]
  1. >>> def a(**x):  
  2. if len(x)==0:  
  3. print 'None'  
  4. else:  
  5. print x    
  6. >>> a()  
  7. None  
  8. >>> a(x=1,y=2)  
  9. {'y'2'x'1}      #存放在字典中   
  10. >>> a(1,2)            #这种调用则报错   
  11.   
  12. Traceback (most recent call last):  
  13. File "", line 1in -toplevel-  
  14. a(1,2)  
  15. TypeError: a() takes exactly 0 arguments (2 given)  

同样地,也存在着对字典处理的“逆过程”

 

上面介绍了四种定义方式,接下来看函数参数在调用过程中是怎么被解析的,其实只要记住上面这四种方法优先级依次降低,先1,后2,再3,最后4,也就是先把方式1中的arg解析,然后解析方式2中的arg=value,再解析方式3,即是把多出来的arg这种形式的实参组成个tuple传进去,最后把剩下的key=value这种形式的实参组成一个dictionary传给带俩个星号的形参,也就方式4

[python]
  1. >>> def test(x,y=1,*a,**b):  
  2. print x,y,a,b  
  3.   
  4.   
  5. >>> test(1)  
  6. 1 1 () {}  
  7. >>> test(1,2)  
  8. 1 2 () {}  
  9. >>> test(1,2,3)  
  10. 1 2 (3,) {}  
  11. >>> test(1,2,3,4)  
  12. 1 2 (34) {}  
  13. >>> test(x=1,y=2)  
  14. 1 2 () {}  
  15. >>> test(1,a=2)  
  16. 1 1 () {'a'2}  
  17. >>> test(1,2,3,a=4)  
  18. 1 2 (3,) {'a'4}  
  19. >>> test(1,2,3,y=4)  
  20.   
  21. Traceback (most recent call last):  
  22. File "", line 1in -toplevel-  
  23. test(1,2,3,y=4)  
  24. TypeError: test() got multiple values for keyword argument 'y'  
阅读(417) | 评论(1) | 转发(0) |
0

上一篇:Python的学习(二十一)----Python的静态变量

下一篇:没有了

给主人留下些什么吧!~~