【深圳校区】python的位置参数、默认参数、关键字参数、...

python 未结 0 186
长沙网站优化
长沙网站优化 2021-04-29 14:06
悬赏:43
一、位置参数

调用函数时根据函数定义的参数位置来传递参数。




  • #!/usr/bin/env python



  • # coding=utf-8







  • def print_hello(name, sex):



  •     sex_dict = {1: u"先生", 2: u"女士"}



  •     print "hello %s %s, welcome to python world!" %(name, sex_dict.get(sex, u"先生"))











  • # 两个参数的顺序必须一一对应,且少一个参数都不可以



  • # print_hello("tanggu", 1)



二、关键字参数

用于函数调用,通过“键-值”形式加以指定。可以让函数更加清晰、容易使用,同时也清除了参数的顺序需求。




  • # 以下是用关键字参数正确调用函数的实例



  • # print_hello("tanggu", sex=1)



  • # print_hello(1, name="tanggu")



  • # print_hello(name="tanggu", sex=1)



  • # print_hello(sex=1, name="tanggu")







  • # 以下是错误的调用方式



  • # print_hello(name="tanggu", 1)



  • # print_hello(sex=1, "tanggu")



通过上面的代码,我们可以发现:有位置参数时,位置参数必须在关键字参数的前面,但关键字参数之间不存在先后顺序的

三、默认参数

用于定义函数,为参数提供默认值,调用函数时可传可不传该默认参数的值(注意:所有位置参数必须出现在默认参数前,包括函数定义和调用)




  • # 正确的默认参数定义方式--> 位置参数在前,默认参数在后



  • def print_hello(name, sex=1):



  •     ....







  • # 错误的定义方式



  • def print_hello(sex=1, name):



  •     ....







  • # 调用时不传sex的值,则使用默认值1



  • # print_hello("tanggu")







  • # 调用时传入sex的值,并指定为2



  • # print_hello("tanggu", 2)



四、可变参数

定义函数时,有时候我们不确定调用的时候会传递多少个参数(不传参也可以)。此时,可用包裹(packing)位置参数,或者包裹关键字参数,来进行参数传递,会显得非常方便。

1、包裹位置传递




  • def func(*args):



  •     ....











  • # func()



  • # func(a)



  • # func(a, b, c)



我们传进的所有参数都会被args变量收集,它会根据传进参数的位置合并为一个元组(tuple),args是元组类型,这就是包裹位置传递。

2、包裹关键字传递



  • def func(**kargs):



  •     ....







  • # func(a=1)



  • # func(a=1, b=2, c=3)


kargs是一个字典(dict),收集所有关键字参数

五、解包裹参数

*和**,也可以在函数调用的时候使用,称之为解包裹(unpacking)

1、在传递元组时,让元组的每一个元素对应一个位置参数




  • def print_hello(name, sex):



  •     print name, sex







  • # args = ("tanggu", "男")



  • # print_hello(*args)



  • # tanggu 男



2、在传递词典字典时,让词典的每个键值对作为一个关键字参数传递给函数




  • def print_hello(kargs):



  •     print kargs







  • # kargs = {"name": "tanggu", "sex", u"男"}



  • # print_hello(**kargs)



  • # {"name": "tanggu", "sex", u"男"}



六、位置参数、默认参数、可变参数的混合使用

基本原则是:先位置参数,默认参数,包裹位置,包裹关键字(定义和调用都应遵循)




  • def func(name, age, sex=1, *args, **kargs):



  •     print name, age, sex, args, kargs











  • # func("tanggu", 25, 2, "music", "sport", class=2)



  • # tanggu 25 1 ("music", "sport") {"class"=2}



Python中 *args 和 **kwargs 的区别

先来看个例子:




  • def foo(*args, **kwargs):



  •     print "args = ", args



  •     print "kwargs = ", kwargs



  •     print "---------------------------------------"







  • if __name__ == "__main__":



  •     foo(1,2,3,4)



  •     foo(a=1,b=2,c=3)



  •     foo(1,2,3,4, a=1,b=2,c=3)



  •     foo("a", 1, None, a=1, b="2", c=3)



输出结果如下:




  • args =  (1, 2, 3, 4)



  • kwargs =  {}



  • ---------------------------------------



  • args =  ()



  • kwargs =  {"a": 1, "c": 3, "b": 2}



  • ---------------------------------------



  • args =  (1, 2, 3, 4)



  • kwargs =  {"a": 1, "c": 3, "b": 2}



  • ---------------------------------------



  • args =  ("a", 1, None)



  • kwargs =  {"a": 1, "c": 3, "b": "2"}



可以看到,这两个是Python中的可变参数。*args 表示任何多个无名参数,它是一个tuple;**kwargs 表示关键字参数,它是一个dict。并且同时使用*args和**kwargs时,必须*args参数列要在**kwargs前,像foo(a=1, b="2", c=3, a", 1, None, )这样调用的话,会提示语法错误“SyntaxError: non-keyword arg after keyword arg”。

知道*args和`**kwarg是什么了吧。还有一个很漂亮的用法,就是创建字典:



  •     def kw_dict(**kwargs):



  •         return kwargs



  •     print kw_dict(a=1,b=2,c=3) == {"a":1, "b":2, "c":3}


其实python中就带有dict类,使用dict(a=1,b=2,c=3)即可创建一个字典了。


*args:

  重点在*,后面的args相当于一个变量名,可以自己定义的。它的本质就是将标准调用剩下的值集中转变为元组。




  • #*args的运用



  • def foo (x,*args):



  •     print(x)



  •     print(args)







  • foo(1,2,3,4,5,6,6,"a","b")  #调用函数







  • 输出:


1----->x
(2, 3, 4, 5, 6, 6, "a", "b")----->*args


#从形参的角度def foo(*args):  # foo(x,y,z)参数个数可以至多个    print(args)foo(1, 2, 3)  # 没有个数限制(1, 2, 3)      #输出结果#*args=*(1,2,3)


  • 从实参的角度



  • def bar(x,y,z):



  •     print(x)



  •     print(y)



  •     print(z)







  • # bar(*(1,2,3,4)) #会报错只需要3个值,但给定的实参有4个值,不能一一对应



  • bar(*(1,2,3))   #实参一一对应



  • 1



  • 2



  • 3



*args与位置参数和默认参数混用:(输出元组)




  • #*args与位置参数和默认参数混用:*args要放到位置参数后面,默认参数要放最后。



  • def foo(x,*args,y = 1):



  •     print(x)



  •     print(y)



  •     print(args)



  • foo(1,2,3,4,5,6,7,8,9,10,y=10000)   #调用函数



  • 1------->x=1



  • 10000-------->y=10000



  • (2, 3, 4, 5, 6, 7, 8, 9, 10)----->args的值变成元组



**kwargs(输出字典)




  • 重点在**,后面的kwargs相当于一个变量名,可以自己定义的。它的本质就是将关键字调用剩下的值集中转变为字典。



  • def foo(x,**kwargs):    #kwargs = {"y":1,"z": 2}



  •     print(x)



  •     print(kwargs)



  • foo(1,y=1,z=2)      #调用函数



  • # 1-->x的值



  • # {"y": 1, "z": 2} #kwargs的值,转为了一个字典



从不同角度看**kwargs:




  • def foo(**kwargs):  #foo(x=1,y=2,z=3)参数个数可以一个至多个



  •     print(kwargs)







  • foo(x=1,y=2,z=3)  #调用函数,没有个数限制



  • {"x": 1, "y": 2, "z": 3}  ----->输出字典



  • --------------分割线-------------------------



  • def foo(x,y,z):



  •     print(x)



  •     print(y)



  •     print(z)



  • # foo(**{"x" : 1,"y" : 2, "z" : 3,"a":4 })#TypeError: foo() got an unexpected keyword argument "a",报错原因是函数foo只有3个值(x,y,z)



  • foo(**{"x" : 1,"y" : 2, "z" : 3})   #三个值正好匹配



  • 1#输出结果



  • 2



  • 3



**kwargs与位置参数和默认参数混用:




  • def foo(x,a = 4,**kwargs):  #混合使用参数



  •     print(x)



  •     print(a)



  •     print(kwargs)







  • foo(1,y=2,z=3)  #使用默认参数


1  #输出
4
{"y": 2, "z": 3}


foo(1,5,y=2,z=3)  #修改默认参数

1
5
{"y": 2, "z": 3}


超复杂混合参数混用记:

从形参角度:

[url=][/url]



  • def foo(x,*args,a=4,**kwargs):  #使用默认参数时,注意默认参数的位置要在args之后kwargs之前



  •     print(x)



  •     print(a)



  •     print(args)



  •     print(kwargs)







  • foo(1,5,6,7,8,y=2,z=3)  #调用函数,不修改默认参数



  • 1   #x的值



  • 4   #a的值



  • (5, 6, 7, 8)   #*args的值



  • {"y": 2, "z": 3}    ##kwargs的值





  • def foo(x,a=4,*args,**kwargs):  ##注意:当需要修改默认参数时,要调整默认参数的位置,要放在args之前即可,但不可放在开头。



  •     print(x)



  •     print(a)



  •     print(args)



  •     print(kwargs)







  • foo(1,9,5,6,7,8,y=2,z=3)    #调用函数,修改默认参数a为9



  • 1   #x的值



  • 9   #被修改后a的值



  • (5, 6, 7, 8)    #args的值



  • {"y": 2, "z": 3}    #kwargs的值



从实参角度:




  • def foo(x,*args,a=4,**kwargs):  #使用默认参数时,注意默认参数的位置要在args之后kwargs之前



  •     print(x)



  •     print(a)



  •     print(args)



  •     print(kwargs)







  • foo(1,*(5,6,7,8),**{"y":2,"z":3})   #调用函数,不改默认参数



  • 1   #x的值



  • 4   #默认a的值



  • (5, 6, 7, 8)    #args的值



  • {"y": 2, "z": 3}    #kwargs的值



  • -------------分割线----------------------




  • def foo(x,a=4,*args,**kwargs):  #注意:当需要修改默认参数时,要调整默认参数的位置,要放在args之前,但不可放在开头



  •     print(x)



  •     print(a)



  •     print(args)



  •     print(kwargs)







  • foo(1,9,10,*(5,6,7,8),**{"y":2,"z":3})  #调用函数,修改默认参数a为9



  • 1   #x的值



  • 9   #修改默认参数a后的值



  • (10, 5, 6, 7, 8)    #args的值



  • {"y": 2, "z": 3}    #kwargs的值


小结:

位置参数:

调用函数时所传参数的位置必须与定义函数时参数的位置相同

关键字参数:

使用关键字参数会指定参数值赋给哪个形参,调用时所传参数的位置可以任意

*位置参数:可接受任意数量的位置参数(元组);只能作为最后一个位置参数出现,其后参数均为关键字参数

**关键字参数:可接受任意数量的关键字参数(字典);只能作为最后一个参数出现


默认参数:默认参数的赋值只会在函数定义的时候绑定一次,默认值不会再被修改


相关标签:
回答
  • 消灭零回复
提交回复