摘要:在调用函数时,我们可以给该函数传递任意个参数,包括个参数传递个参数传递个参数传递个参数传递个参数上面的表示任意参数,实际上,它还有另外一个用法用来给函数传递参数。应该使用不可变对象作为函数的默认参数。
函数参数
在 Python 中,定义函数和调用函数都很简单,但如何定义函数参数和传递函数参数,则涉及到一些套路了。总的来说,Python 的函数参数主要分为以下几种:
必选参数
默认参数
可变参数
关键字参数
必选参数必选参数可以说是最常见的了,顾名思义,必选参数就是在调用函数的时候要传入数量一致的参数,比如:
>>> def add(x, y): # x, y 是必选参数 ... print x + y ... >>> add() # 啥都没传,不行 Traceback (most recent call last): File "默认参数", line 1, in TypeError: add() takes exactly 2 arguments (0 given) >>> add(1) # 只传了一个,也不行 Traceback (most recent call last): File " ", line 1, in TypeError: add() takes exactly 2 arguments (1 given) >>> add(1, 2) # 数量一致,通过 3
默认参数是指在定义函数的时候提供一些默认值,如果在调用函数的时候没有传递该参数,则自动使用默认值,否则使用传递时该参数的值。
看看例子就明白了:
>>> def add(x, y, z=1): # x, y 是必选参数,z 是默认参数,默认值是 1 ... print x + y + z ... >>> add(1, 2, 3) # 1+2+3 6 >>> add(1, 2) # 没有传递 z,自动使用 z=1,即 1+2+1 4
可以看到,默认参数使用起来也很简单,但有两点需要注意的是:
默认参数要放在所有必选参数的后面
默认参数应该使用不可变对象
比如,下面对默认参数的使用是错误的:
>>> def add(x=1, y, z): # x 是默认参数,必须放在所有必选参数的后面 ... return x + y + z ... File "", line 1 SyntaxError: non-default argument follows default argument >>> >>> def add(x, y=1, z): # y 是默认参数,必须放在所有必选参数的后面 ... return x + y + z ... File " ", line 1 SyntaxError: non-default argument follows default argument
再来看看为什么默认参数应该使用不可变对象。
我们看一个例子:
>>> def add_to_list(L=[]): ... L.append("END") ... return L
在上面的函数中,L 是一个默认参数,默认值是 [],表示空列表。
我们来看看使用:
>>> add_to_list([1, 2, 3]) # 没啥问题 [1, 2, 3, "END"] >>> add_to_list(["a", "b", "c"]) # 没啥问题 ["a", "b", "c", "END"] >>> add_to_list() # 没有传递参数,使用默认值,也没啥问题 ["END"] >>> add_to_list() # 没有传递参数,使用默认值,竟出现两个 "END" ["END", "END"] >>> add_to_list() # 糟糕了,三个 "END" ["END", "END", "END"]
为啥呢?我们在调用函数的时候没有传递参数,那么就默认使用 L=[],经过处理,L 应该只有一个元素,怎么会出现调用函数两次,L 就有两个元素呢?
原来,L 指向了可变对象 [],当你调用函数时,L 的内容发生了改变,默认参数的内容也会跟着变,也就是,当你第一次调用时,L 的初始值是 [],当你第二次调用时,L 的初始值是 ["END"],等等。
所以,为了避免不必要的错误,我们应该使用不可变对象作为函数的默认参数。
可变参数在某些情况下,我们在定义函数的时候,无法预估函数应该制定多少个参数,这时我们就可以使用可变参数了,也就是,函数的参数个数是不确定的。
看看例子:
>>> def add(*numbers): ... sum = 0 ... for i in numbers: ... sum += i ... print "numbers:", numbers ... return sum
在上面的代码中,numbers 就是一个可变参数,参数前面有一个 * 号,表示是可变的。在函数内部,参数 numbers 接收到的是一个 tuple。
在调用函数时,我们可以给该函数传递任意个参数,包括 0 个参数:
>>> add() # 传递 0 个参数 numbers: () 0 >>> add(1) # 传递 1 个参数 numbers: (1,) 1 >>> add(1, 2) # 传递 2 个参数 numbers: (1, 2) 3 >>> add(1, 2, 3) # 传递 3 个参数 numbers: (1, 2, 3) 6
上面的 * 表示任意参数,实际上,它还有另外一个用法:用来给函数传递参数。
看看例子:
>>> def add(x, y, z): # 有 3 个必选参数 ... return x + y + z ... >>> a = [1, 2, 3] >>> add(a[0], a[1], a[2]) # 这样传递参数很累赘 6 >>> add(*a) # 使用 *a,相当于上面的做法 6 >>> b = (4, 5, 6) >>> add(*b) # 对元组一样适用 15
再看一个例子:
>>> def add(*numbers): # 函数参数是可变参数 ... sum = 0 ... for i in numbers: ... sum += i ... return sum ... >>> a = [1, 2] >>> add(*a) # 使用 *a 给函数传递参数 3 >>> a = [1, 2, 3, 4] >>> add(*a) 10关键字参数
可变参数允许你将不定数量的参数传递给函数,而关键字参数则允许你将不定长度的键值对, 作为参数传递给一个函数。
让我们看看例子:
>>> def add(**kwargs): return kwargs >>> add() # 没有参数,kwargs 为空字典 {} >>> add(x=1) # x=1 => kwargs={"x": 1} {"x": 1} >>> add(x=1, y=2) # x=1, y=2 => kwargs={"y": 2, "x": 1} {"y": 2, "x": 1}
在上面的代码中,kwargs 就是一个关键字参数,它前面有两个 * 号。kwargs 可以接收不定长度的键值对,在函数内部,它会表示成一个 dict。
和可变参数类似,我们也可以使用 **kwargs 的形式来调用函数,比如:
>>> def add(x, y, z): ... return x + y + z ... >>> dict1 = {"z": 3, "x": 1, "y": 6} >>> add(dict1["x"], dict1["y"], dict1["z"]) # 这样传参很累赘 10 >>> add(**dict1) # 使用 **dict1 来传参,等价于上面的做法 10
再看一个例子:
>>> def sum(**kwargs): # 函数参数是关键字参数 ... sum = 0 ... for k, v in kwargs.items(): ... sum += v ... return sum >>> sum() # 没有参数 0 >>> dict1 = {"x": 1} >>> sum(**dict1) # 相当于 sum(x=1) 1 >>> dict2 = {"x": 2, "y": 6} >>> sum(**dict2) # 相当于 sum(x=2, y=6) 8参数组合
在实际的使用中,我们经常会同时用到必选参数、默认参数、可变参数和关键字参数或其中的某些。但是,需要注意的是,它们在使用的时候是有顺序的,依次是必选参数、默认参数、可变参数和关键字参数。
比如,定义一个包含上述四种参数的函数:
>>> def func(x, y, z=0, *args, **kwargs): print "x =", x print "y =", y print "z =", z print "args =", args print "kwargs =", kwargs
在调用函数的时候,Python 会自动按照参数位置和参数名把对应的参数传进去。让我们看看:
>>> func(1, 2) # 至少提供两个参数,因为 x, y 是必选参数 x = 1 y = 2 z = 0 args = () kwargs = {} >>> func(1, 2, 3) # x=1, y=2, z=3 x = 1 y = 2 z = 3 args = () kwargs = {} >>> func(1, 2, 3, 4, 5, 6) # x=1, y=2, z=3, args=(4, 5, 6), kwargs={} x = 1 y = 2 z = 3 args = (4, 5, 6) kwargs = {} >>> func(1, 2, 4, u=6, v=7) # args = (), kwargs = {"u": 6, "v": 7} x = 1 y = 2 z = 4 args = () kwargs = {"u": 6, "v": 7} >>> func(1, 2, 3, 4, 5, u=6, v=7) # args = (4, 5), kwargs = {"u": 6, "v": 7} x = 1 y = 2 z = 3 args = (4, 5) kwargs = {"u": 6, "v": 7}
我们还可以通过下面的形式来传递参数:
>>> a = (1, 2, 3) >>> b = {"u": 6, "v": 7} >>> func(*a, **b) x = 1 y = 2 z = 3 args = () kwargs = {"u": 6, "v": 7}小结
默认参数要放在所有必选参数的后面。
应该使用不可变对象作为函数的默认参数。
*args 表示可变参数,**kwargs 表示关键字参数。
参数组合在使用的时候是有顺序的,依次是必选参数、默认参数、可变参数和关键字参数。
*args 和 **kwargs 是 Python 的惯用写法。
参考资料本文由 funhacks 发表于个人博客,采用 Creative Commons BY-NC-ND 4.0(自由转载-保持署名-非商用-禁止演绎)协议发布。
非商业转载请注明作者及出处。商业转载请联系作者本人。
本文标题为: Python: 函数参数魔法
本文链接为: https://funhacks.net/2016/12/...
args 和 *kwargs · Python进阶
函数的参数 - 廖雪峰的官方网站
文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。
转载请注明本文地址:https://www.ucloud.cn/yun/44324.html
摘要:本文记录一些用于代码计时和简单性能分析的工具。也就是这个魔法命令把中剩余的代码作为输入变量,对其进行计时。该命令会运行最后一个参数指定的代码,然后在运行时分析所有需要分析的函数。该命令运行之后会打印一个逐行分析报告。 本文记录一些用于 Python 代码计时和简单性能分析的工具。强烈推荐后两种工具。 begin & end 手动计时 Matlab 里有一对 tic toc 命令,使用格...
摘要:类的继承类继承有三种调用方式,其实是有区别的,听我慢慢道来第一种父类方法参数直接调用第二种方法参数直接调用在谁的类下调用,就找此类对应的下一个就是要继承的第三种方法参数找类名对应的的下一个,就是继承的,一般写本身的类名上下文管理器上下文管理 类的继承 类继承有三种调用方式,其实是 有区别 的,听我慢慢道来 class A: def say(self, name): ...
摘要:什么是元类刚才说了,元类就是创建类的类。类上面的属性,相信愿意了解元类细节的盆友,都肯定见过这个东西,而且为之好奇。使用了这个魔法方法就意味着就会用指定的元类来创建类了。深刻理解中的元类 (一) python中的类 今天看到一篇好文,然后结合自己的情况总结一波。这里讨论的python类,都基于python2.7x以及继承于object的新式类进行讨论。 首先在python中,所有东西都...
摘要:据说,的对象天生拥有一些神奇的方法,它们总被双下划线所包围,他们是面向对象的的一切。的魔术方法非常强大,然而随之而来的则是责任。 据说,Python 的对象天生拥有一些神奇的方法,它们总被双下划线所包围,他们是面向对象的 Python 的一切。 他们是可以给你的类增加魔力的特殊方法,如果你的对象实现(重载)了这些方法中的某一个,那么这个方法就会在特殊的情况下被 Python 所调用,你...
摘要:幸而,提供了造物主的接口这便是,或者称为元类。接下来我们将通过一个栗子感受的黑魔法,不过在此之前,我们要先了解一个语法糖。此外,在一些小型的库中,也有元类的身影。 首发于 我的博客 转载请注明出处 接触过 Django 的同学都应该十分熟悉它的 ORM 系统。对于 python 新手而言,这是一项几乎可以被称作黑科技的特性:只要你在models.py中随便定义一个Model的子类,Dj...
阅读 2907·2021-10-19 10:09
阅读 3125·2021-10-09 09:41
阅读 3370·2021-09-26 09:47
阅读 2687·2019-08-30 15:56
阅读 590·2019-08-29 17:04
阅读 979·2019-08-26 11:58
阅读 2504·2019-08-26 11:51
阅读 3352·2019-08-26 11:29