二、关键字参数
用于函数调用,通过“键-值”形式加以指定。可以让函数更加清晰、容易使用,同时也清除了参数的顺序需求。
# 以下是用关键字参数正确调用函数的实例
# 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')
通过上面的代码,我们可以发现:有位置参数时,位置参数必须在关键字参数的前面,但关键字参数之间不存在先后顺序的
y = 2
非关键字可变长参数(元组)
在定义函数时,我们有时候并不知道调用的时候会传递多少个参数。这时候,包裹(packing)位置参数,或者包裹关键字参数,来进行参数传递,会非常有用。
下面是包裹位置传递的例子:
def func(*name):
print (type(name))
print (name)
func(1,4,6)
func(5,6,7,1,2,3)
#两次调用,尽管参数个数不同,都基于同一个func定义。在func的参数表中,所有的参数被name收集,根据位置合并成一个元组(tuple),这就是包裹位置传递。
#name是包裹位置传递所用的元组名,在定义func时,在name前加*号。
包裹关键字传递
例子:
def func(**dict):
print type(dict)
print dict
func(a=1,b=9)
func(m=2,n=1,c=11)
#与上面一个例子类似,dict是一个字典,收集所有的关键字,传递给函数func。
#参数dict是包裹关键字传递所用的字典,在dict前加**。包裹传递的关键在于定义函数时,在相应元组或字典前加*或**。
python函数的参数使用
python函数的参数类似于C++中的形参,传递的只是参数的拷贝。
而函数的默认参数也会被保存为一个变量,并且是全局静态变量。
六、位置参数、默认参数、可变参数的混合使用
基本原则是:先位置参数,默认参数,包裹位置,包裹关键字(定义和调用都应遵循)
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)即可创建一个字典了。
[‘END’, ‘END’]
可变长度的参数
python进阶教程之函数参数的多种传递方法,python进阶教程
我们已经接触过函数(function)的参数(arguments)传递。当时我们根据位置,传递对应的参数。我们将接触更多的参数传递方式。
回忆一下位置传递:
复制代码 代码如下:
def f(a,b,c):
return a+b+c
print(f(1,2,3))
在调用f时,1,2,3根据位置分别传递给了a,b,c。
关键字传递
有些情况下,用位置传递会感觉比较死板。关键字(keyword)传递是根据每个参数的名字传递参数。关键字并不用遵守位置的对应关系。依然沿用上面f的定义,更改调用方式:
复制代码 代码如下:
print(f(c=3,b=2,a=1))
关键字传递可以和位置传递混用。但位置参数要出现在关键字参数之前:
复制代码 代码如下:
print(f(1,c=3,b=2))
参数默认值
在定义函数的时候,使用形如a=19的方式,可以给参数赋予默认值(default)。如果该参数最终没有被传递值,将使用该默认值。
复制代码 代码如下:
云顶娱乐平台:python:函数说明。def f(a,b,c=10):
return a+b+c
print(f(3,2))
print(f(3,2,1))
在第一次调用函数f时, 我们并没有足够的值,c没有被赋值,c将使用默认值10.
第二次调用函数的时候,c被赋值为1,不再使用默认值。
包裹传递
在定义函数时,我们有时候并不知道调用的时候会传递多少个参数。这时候,包裹(packing)位置参数,或者包裹关键字参数,来进行参数传递,会非常有用。
下面是包裹位置传递的例子:
复制代码 代码如下:
def func(*name):
print type(name)
print name
func(1,4,6)
func(5,6,7,1,2,3)
两次调用,尽管参数个数不同,都基于同一个func定义。在func的参数表中,所有的参数被name收集,根据位置合并成一个元组(tuple),这就是包裹位置传递。
为了提醒Python参数,name是包裹位置传递所用的元组名,在定义func时,在name前加*号。
下面是包裹关键字传递的例子:
复制代码 代码如下:
def func(**dict):
print type(dict)
print dict
func(a=1,b=9)
func(m=2,n=1,c=11)
与上面一个例子类似,dict是一个字典,收集所有的关键字,传递给函数func。为了提醒Python,参数dict是包裹关键字传递所用的字典,在dict前加**。
包裹传递的关键在于定义函数时,在相应元组或字典前加*或**。
解包裹
*和**,也可以在调用的时候使用,即解包裹(unpacking), 下面为例:
复制代码 代码如下:
def func(a,b,c):
print a,b,c
args = (1,3,4)
func(*args)
在这个例子中,所谓的解包裹,就是在传递tuple时,让tuple的每一个元素对应一个位置参数。在调用func时使用*,是为了提醒Python:我想要把args拆成分散的三个元素,分别传递给a,b,c。(设想一下在调用func时,args前面没有*会是什么后果?)
相应的,也存在对词典的解包裹,使用相同的func定义,然后:
复制代码 代码如下:
dict = {‘a’:1,’b’:2,’c’:3}
func(**dict)
在传递词典dict时,让词典的每个键值对作为一个关键字传递给func。
混合
在定义或者调用参数时,参数的几种传递方式可以混合。但在过程中要小心前后顺序。基本原则是,先位置,再关键字,再包裹位置,再包裹关键字,并且根据上面所说的原理细细分辨。
注意:请注意定义时和调用时的区分。包裹和解包裹并不是相反操作,是两个相对独立的过程。
总结
关键字,默认值,
包裹位置,包裹关键字
解包裹
2、包裹关键字传递
def func(**kargs):
....
# func(a=1)
# func(a=1, b=2, c=3)
kargs是一个字典(dict),收集所有关键字参数
0
位置传递
例子:
def f(a,b,c):
return a+b+c
print(f(1,2,3))
#在调用f时,1,2,3根据位置分别传递给了a,b,c。
python的参数传递问题
楼主的理解没有问题啊 .
python中函数的实参传递规则是:
标注了参数名的就要按参数名传递,打乱顺序的情况下一定要加参数名,否则会混乱的。
没有缺省的实参情况下就会依次传递,如果不够的话,后面的会自动去取自己的缺省值。
如果实参的数量比形参要多的话,就要用到带*号的参数名了。
我们已经接触过函数(function)的参数(arguments)传递。当时我们根据位置,传递对应的…
**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}
print ‘y =’, y
总结
关键字,默认值,
包裹位置,包裹关键字
解包裹
1、包裹位置传递
def func(*args):
....
# func()
# func(a)
# func(a, b, c)
我们传进的所有参数都会被args变量收集,它会根据传进参数的位置合并为一个元组(tuple),args是元组类型,这就是包裹位置传递。
7
正文
我们已经接触过函数,函数是可以被引用的(访问或者以其他变量作为其别名),也作为参数传入函数,以及作为列表和字典等等容器对象的元素(function)的参数(arguments)传递。
传递函数
形式参数
位置参数
默认参数
关键字变量参数
*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
>>> func(*a, **b)
形式参数
2、在传递词典字典时,让词典的每个键值对作为一个关键字参数传递给函数
def print_hello(kargs):
print kargs
# kargs = {'name': 'tanggu', 'sex', u'男'}
# print_hello(**kargs)
# {'name': 'tanggu', 'sex', u'男'}
再来看看为什么默认参数应该使用不可变对象。
会包也要解包
超复杂混合参数混用记:
从形参角度:
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的值
小结:
位置参数:
调用函数时所传参数的位置必须与定义函数时参数的位置相同
关键字参数:
使用关键字参数会指定参数值赋给哪个形参,调用时所传参数的位置可以任意
*位置参数:可接受任意数量的位置参数(元组);只能作为最后一个位置参数出现,其后参数均为关键字参数
**关键字参数:可接受任意数量的关键字参数(字典);只能作为最后一个参数出现
默认参数:默认参数的赋值只会在函数定义的时候绑定一次,默认值不会再被修改
在实际的使用中,我们经常会同时用到必选参数、默认参数、可变参数和关键字参数或其中的某些。但是,需要注意的是,它们在使用的时候是有顺序的,依次是必选参数、默认参数、可变参数和关键字参数。
前言
系列文章:[传送门]
继续干起来!!
1、在传递元组时,让元组的每一个元素对应一个位置参数
def print_hello(name, sex):
print name, sex
# args = ('tanggu', '男')
# print_hello(*args)
# tanggu 男
>>> b = (4, 5, 6)
关键字传递
用位置传递会感觉比较死板。关键字(keyword)传递是根据每个参数的名字传递参数。关键字并不用遵守位置的对应关系。
例子:
print(f(c=3,b=2,a=1))
关键字传递可以和位置传递混用。但位置参数要出现在关键字参数之前:
print(f(1,c=3,b=2))
#必须存在唯一的必须参数
一、位置参数
调用函数时根据函数定义的参数位置来传递参数。
#!/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)
24
参数默认值
在定义函数的时候,使用形如a=19的方式,可以给参数赋予默认值(default)。如果该参数最终没有被传递值,将使用该默认值。
def f(a,b,c=10):
return a+b+c
print(f(3,2))
print(f(3,2,1))
#在第一次调用函数f时,
我们并没有足够的值,c没有被赋值,c将使用默认值10.
#第二次调用函数的时候,c被赋值为1,不再使用默认值。
三、默认参数
用于定义函数,为参数提供默认值,调用函数时可传可不传该默认参数的值(注意:所有位置参数必须出现在默认参数前,包括函数定义和调用)
# 正确的默认参数定义方式--> 位置参数在前,默认参数在后
def print_hello(name, sex=1):
....
# 错误的定义方式
def print_hello(sex=1, name):
....
# 调用时不传sex的值,则使用默认值1
# print_hello('tanggu')
# 调用时传入sex的值,并指定为2
# print_hello('tanggu', 2)
8
感谢及资源共享
路上走来一步一个脚印,希望大家和我一起。
感谢读者!很喜欢你们给我的支持。如果支持,点个赞。
知识来源:
系列文章: [传送门] 继续干起来!! 正文
我们已经接触过函数,函数是可以被引用的(访问或者以其他变量作为其别名),也作为参…
四、可变参数
定义函数时,有时候我们不确定调用的时候会传递多少个参数(不传参也可以)。此时,可用包裹(packing)位置参数,或者包裹关键字参数,来进行参数传递,会显得非常方便。
8
解包裹
*和**,也可以在调用的时候使用,即解包裹(unpacking), 下面为例:
def func(a,b,c):
print a,b,c
args = (1,3,4)
func(*args)
#所谓的解包裹,就是在传递tuple时,让tuple的每一个元素对应一个位置参数。在调用func时使用*,是为了提醒Python:我想要把args拆成分散的三个元素,分别传递给a,b,c。(设想一下在调用func时,args前面没有*会是什么后果?)
相应的,也存在对词典的解包裹,使用相同的func定义,然后:
dict = {'a':1,'b':2,'c':3}
func(**dict)
#在传递词典dict时,让词典的每个键值对作为一个关键字传递给func。
五、解包裹参数
*和**,也可以在函数调用的时候使用,称之为解包裹(unpacking)
Python: 函数参数魔法
*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
3
3
8
*args 和 **kwargs 是 Python 的惯用写法。
11
默认参数是指在定义函数的时候提供一些默认值,如果在调用函数的时候没有传递该参数,则自动使用默认值,否则使用传递时该参数的值。
…
1
9
… print x + y + z
print ‘z =’, z
[1, 2, 3, ‘END’]
5
>>> add(dict1[‘x’], dict1[‘y’], dict1[‘z’]) #
这样传参很累赘
z = 3
>>> a = [1, 2]
4
>>> def add(**kwargs):
2
… return x + y + z
5
必选参数
1
y = 2
{}
5
3
26
21
y = 2
>>>
28
SyntaxError: non-default argument follows default argument
y = 2
z = 3
z = 4
4
1
6
3
4
>>> def add(x, y, z=1): # x, y 是必选参数,z
是默认参数,默认值是 1
Traceback (most recent call last):
6
{‘x’: 1}
print ‘x =’, x
13
25
6
5
8
11
y = 2
3
5
1
我们看一个例子:
3
z = 3
参数组合在使用的时候是有顺序的,依次是必选参数、默认参数、可变参数和关键字参数。
12
SyntaxError: non-default argument follows default argument
2
12
7
>>> a = (1, 2, 3)
>>> add() # 传递 0 个参数
14
10
>>> def add(*numbers): # 函数参数是可变参数
9
…
>>> def add(x, y, z): # 有 3 个必选参数
9
6
7
… return x + y + z
>>> add(**dict1) # 使用 **dict1
来传参,等价于上面的做法
x = 1
print ‘args =’, args
…
可变参数
>>> dict1 = {‘z’: 3, ‘x’: 1, ‘y’: 6}
再看一个例子:
3
File “”, line 1
… return x + y + z
11
默认参数
10
z = 3
>>> a = [1, 2, 3, 4]
>>> dict2 = {‘x’: 2, ‘y’: 6}
File “”, line 1
5
kwargs = {}
10
print ‘kwargs =’, kwargs
… return sum
Traceback (most recent call last):
7
args = (4, 5)
再看一个例子:
7
args = ()
6
4
应该使用不可变对象作为函数的默认参数。
6
默认参数要放在所有必选参数的后面。
2
默认参数
必选参数
3
>>> def func(x, y, z=0, *args, **kwargs):
4
>>> add_to_list() #
没有传递参数,使用默认值,竟出现两个 ‘END’
return kwargs
让我们看看例子:
在调用函数时,我们可以给该函数传递任意个参数,包括 0 个参数:
12
args = (4, 5, 6)
3
2
… return x + y + z
5
11
7
y = 2
看看例子就明白了:
8
1
4
>>> sum() # 没有参数
5
File “”, line 1, in
x = 1
7
11
6
1
比如,下面对默认参数的使用是错误的:
>>> add_to_list([1, 2, 3]) # 没啥问题
11
args = ()
…
1
2
… L.append(‘END’)
函数的参数 – 廖雪峰的官方网站
2
15
… print x + y
2
16
1
在上面的代码中,numbers 就是一个可变参数,参数前面有一个 *
号,表示是可变的。在函数内部,参数 numbers 接收到的是一个 tuple。
9
2
6
… sum = 0
>>> add(x=1) # x=1 => kwargs={‘x’: 1}
10
3
可变参数
8
看看例子:
原来,L 指向了可变对象 [],当你调用函数时,L
的内容发生了改变,默认参数的内容也会跟着变,也就是,当你第一次调用时,L
的初始值是 [],当你第二次调用时,L 的初始值是 [‘END’],等等。
>>> add(1, 2) # 传递 2 个参数
7
0
17
5
3
… sum += i
1
5
8
4
… return sum
1
10
numbers: ()
… sum = 0
13
>>> add() # 没有参数,kwargs 为空字典
[‘END’, ‘END’, ‘END’]
关键字参数
2
>>> def add_to_list(L=[]):
可以看到,默认参数使用起来也很简单,但有两点需要注意的是:
>>> add(1, 2, 3) # 传递 3 个参数
9
>>> func(1, 2, 3) # x=1, y=2, z=3
默认参数要放在所有必选参数的后面
6
kwargs = {}
8
>>> func(1, 2) # 至少提供两个参数,因为 x,
y 是必选参数
22
TypeError: add() takes exactly 2 arguments (0 given)
比如,定义一个包含上述四种参数的函数:
默认参数应该使用不可变对象
numbers: (1,)
1
TypeError: add() takes exactly 2 arguments (1 given)
5
和可变参数类似,我们也可以使用 **kwargs 的形式来调用函数,比如:
我们来看看使用:
4
2
在调用函数的时候,Python
会自动按照参数位置和参数名把对应的参数传进去。让我们看看:
>>> add(1, 2) # 没有传递 z,自动使用 z=1,即
1+2+1
1
>>> sum(**dict2) # 相当于 sum(x=2, y=6)
3
10
3
18
8
上面的 * 表示任意参数,实际上,它还有另外一个用法:用来给函数传递参数。
2
[‘END’]
9
9
函数参数
>>> add_to_list() #
没有传递参数,使用默认值,也没啥问题
File “”, line 1, in
27
4
4
… sum += i
kwargs = {}
13
3
>>> func(1, 2, 4, u=6, v=7) # args = (), kwargs = {‘u’:
6, ‘v’: 7}
12
6
6
6
numbers: (1, 2, 3)
15
[‘a’, ‘b’, ‘c’, ‘END’]
>>> dict1 = {‘x’: 1}
… for i in numbers:
为啥呢?我们在调用函数的时候没有传递参数,那么就默认使用
L=[],经过处理,L 应该只有一个元素,怎么会出现调用函数两次,L
就有两个元素呢?
3
x = 1
{‘y’: 2, ‘x’: 1}
>>> def add(x, y, z):
30
kwargs = {‘u’: 6, ‘v’: 7}
>>> add(*a) # 使用 *a 给函数传递参数
>>> func(1, 2, 3, 4, 5, 6) # x=1, y=2, z=3, args=(4,
5, 6), kwargs={}
4
>>> def add(x=1, y, z): # x
是默认参数,必须放在所有必选参数的后面
… print ‘numbers:’, numbers
kwargs = {‘u’: 6, ‘v’: 7}
10
1
6
29
kwargs = {‘u’: 6, ‘v’: 7}
5
args = ()
10
>>> add(1) # 只传了一个,也不行
args = ()
1
4
6
… return sum
>>> a = [1, 2, 3]
args 和 *kwargs · Python进阶
5
参考资料
x = 1
>>> add(1, 2, 3) # 1+2+3
7
2
10
3
在上面的代码中,kwargs 就是一个关键字参数,它前面有两个 * 号。kwargs
可以接收不定长度的键值对,在函数内部,它会表示成一个 dict。
19
2
2
6
>>> sum(**dict1) # 相当于 sum(x=1)
>>> add(*a) # 使用 *a,相当于上面的做法
关键字参数
>>> add() # 啥都没传,不行
7
…
>>> def sum(**kwargs): # 函数参数是关键字参数
… for i in numbers:
在上面的函数中,L 是一个默认参数,默认值是 [],表示空列表。
8
可变参数允许你将不定数量的参数传递给函数,而关键字参数则允许你将不定长度的键值对,
作为参数传递给一个函数。
11
>>> def add(x, y=1, z): # y
是默认参数,必须放在所有必选参数的后面
numbers: (1, 2)
小结
在某些情况下,我们在定义函数的时候,无法预估函数应该制定多少个参数,这时我们就可以使用可变参数了,也就是,函数的参数个数是不确定的。
6
23
5
2
10
>>> add(1, 2) # 数量一致,通过
8
所以,为了避免不必要的错误,我们应该使用不可变对象作为函数的默认参数。
3
6
x = 1
4
… for k, v in kwargs.items():
10
12
1
>>> def add(*numbers):
7
… sum += v
>>> add(*b) # 对元组一样适用
>>> add_to_list() # 糟糕了,三个 ‘END’
2016-12-01
参数组合
>>> def add(x, y): # x, y 是必选参数
6
>>> add(*a)
… return L
>>> add(x=1, y=2) # x=1, y=2 => kwargs={‘y’: 2, ‘x’: 1}
7
必选参数可以说是最常见的了,顾名思义,必选参数就是在调用函数的时候要传入数量一致的参数,比如:
4
>>> add_to_list([‘a’, ‘b’, ‘c’]) # 没啥问题
…
1
>>> b = {‘u’: 6, ‘v’: 7}
>>> func(1, 2, 3, 4, 5, u=6, v=7) # args = (4, 5), kwargs =
{‘u’: 6, ‘v’: 7}
>>> add(a[0], a[1], a[2]) # 这样传递参数很累赘
9
*args 表示可变参数,**kwargs 表示关键字参数。
…
看看例子:
8
z = 0
3
在 Python
中,定义函数和调用函数都很简单,但如何定义函数参数和传递函数参数,则涉及到一些套路了。总的来说,Python
的函数参数主要分为以下几种:
20
4
x = 1
>>> add(1) # 传递 1 个参数
1
… sum = 0
我们还可以通过下面的形式来传递参数: