By Rose Ou

更新日期:

文章目录
  1. 1. 位置参数
  2. 2. 关键字参数
  3. 3. 可变长度的参数
    1. 3.1. 非关键字可变长参数（元组）
    2. 3.2. 关键字变量参数（字典）

因为一直不是很理解函数的参数，然后复习的时候就总结了一下，免得以后又忘记…

位置参数

调用函数时，传入函数的参数的位置（顺序）一一对应着定义函数时参数的位置，且传入函数的参数与函数声明时的参数数目必须一致,不然会报错。看看栗子：

1
2
3
4
5
6
7
8
9
>>>def f(x,y,z):
...    return x,y,z
>>>print f(x,y,z)
(1,2,3)

>>>def g(x,y,z):
...    return x,z,y
>>>print g(1,2,3)
(1,3,2)

第二个函数中，先返回z，再返回y。因为声明函数时参数名的位置，与调用时所传参数位置是相对应的，所以其实在两个函数中，都是x=1，y=2，z=3，而输出的结果是由return的顺序来决定的。

关键字参数

关键字参数其实就是给参数起一个名字。调用函数的时候就是通过参数的名字来区分参数，而不是它们的位置、顺序。于是，调用函数时，参数的数目和顺序都不一定要对应定义函数时的参数数目和顺序（即允许参数缺失和不按顺序）。

  • 首先你可以直接按照函数声明中参数定义的顺序来调用它（这样看起来就跟位置函数没什么区别了..）：
1
2
3
4
>>>def f(name,age):
...    return '%s is %s years old.' % (name,age)
>>>print f('Rose','eighteen')
Rose is eighteen years old.
  • 再来看看如何不按顺序地调用它（这样就稍微看出来一点区别了..）：**
1
2
>>>print f(age='eighteen',name='Rose')
Rose is eighteen years old.
  • 然后来看看如何数目不对应地调用它：

关键字参数可以在定义函数时设置关键字参数默认值，也就是默认参数。上面提到过允许参数缺失，这个就是和默认参数有关了。
默认参数就是，在函数声明中就给参数提供一个值。这样在调用函数时，如果没有为参数传递一个值，那么这个参数就会取默认值。

1
2
3
4
>>>def f(name='Rose',age='eighteen')
...    return '%s is %s years old.' % (name,age)
>>>print f()
Rose is eighteen years old.

你也可以在调用函数时传入新参数：

1
2
3
4
>>>print f('Jack')
Jack is eighteen years old.
>>>print f('Jack','nineteen')
Jack is nineteen years old.

可是如果想name使用默认参数，而age传入新参数该怎么办？别忘了它可是关键字参数！（虽然上面这个例子按顺序传入参数让它看起来就像位置参数..）
所以可以这样：

1
2
>>>print f(age='nineteen')
   Rose is nineteen years old.

注意：声明函数时，所有的位置参数都必须出现在任何一个默认参数前面。否则会报错。而且在调用函数的时候，一定要给位置参数提供值。

可变长度的参数

调用函数时，有时候可能会需要处理可变数量的参数。这种参数在函数声明中不是显式命名的，因为在调用函数之前，参数的数目是未知的。于是我们可以将参数放在一个元组（非关键字参数）或字典中（关键字参数），作为一个参数组传递给函数。

非关键字可变长参数（元组）

当函数被调用时，所有的形参（位置参数和默认参数）都将值赋给了在函数声明时相对应的部分参数，然后剩下那部分非关键字参数就会按顺序插入到一个元组。这个元组是以一个*号开头的。
*号操作符后的形参会作为元组传递给函数，元组保存了调用函数时所有传递给函数的“额外”的参数（匹配了所有位置参数和关键字参数剩余的）。而如果没有额外的参数，这个元组就为空元祖。

1
2
3
4
5
6
7
8
9
>>> def f(x,*args):
... 	print x
... 	print args
>>> f(a)
1
()
>>> f(1,2,'a','b')
1
(2,'a','b')

第一个位置参数被赋了1的值，剩下的参数全部保存在*args这个元组里。于是我们就可以处理当超出数目的参数被传入函数的情形。

  • 注意：所有形式参数必须放在非关键字可变长参数的前面。
  • 先来举个栗子：
1
2
3
4
5
def f(x,y='1',*args):
	print 'x:', x
	print 'y:', y
	for i in args:    #遍历元组中参数
		print 'args:', i

好，调用这个函数试试看。

1
2
3
4
5
6
7
8
9
10
11
>>> f('abc')
x:abc
y:1
>>> f(11,22)
x:11
y:22
>>> f(123,'abc','xyz',456)
x:123
y:abc
args:xyz
args:456

关键字变量参数（字典）

它就是保存“额外”的关键字参数的字典，这个字典以**开头。其参数名是字典的键。（关键字参数有着参数名和参数值，所以元组没法满足它，于是要用字典。）

  • 栗子：
1
2
3
4
5
6
7
def f(x,y,*args,**kwargs):
	print 'x:', x
	print 'y:', y
	for m in args:
		print 'non-keyword arg:', m
	for n in kwargs.keys():         #遍历字典的键，因为参数名是字典的键
		print "keyword arg '%s': %s" % (n,kwargs[n])

好，来调用它。

1
2
3
4
5
6
7
>>>f(1,2,'abc','xyz',q=123,w=456)
x:1
y:2
non-keyword arg:abc
non-keyword arg:xyz
keyword arg 'q':123
keyword arg 'w':456

还可以这样调用： 

1
2
3
4
5
6
7
>>>f(1,2,*(3,4),**{'a':5,'b':6})
x:1
y:2
non-keyword arg:3
non-keyword arg:4
keyword arg 'a':5
keyword arg 'b':6

还有这样：

1
2
3
4
5
6
7
8
9
10
>>> tuple = (6,7)
>>> dict = {'a':8}
>>> f(1,2,3,b=4,*tuple,**dict)
x:1
y:2
non-keyword arg:3
non-keyword arg:6
non-keyword arg:7
keyword arg 'a':8
keyword arg 'b':4

这里很奇怪的是，调用函数时，对于元组，先将3传入并返回，然后再将元组里的元素作为参数传入并返回；而对于字典，顺序刚好相反，这是为什么呢？不知道..没想出来..

  • 注意：关键字参数应为函数定义的最后一个参数。

所以这些参数的定义顺序为：位置参数，关键字参数，非关键字可变长参数，关键字变量参数。

文章目录
  1. 1. 位置参数
  2. 2. 关键字参数
  3. 3. 可变长度的参数
    1. 3.1. 非关键字可变长参数（元组）
    2. 3.2. 关键字变量参数（字典）