函数的参数

定义函数时()里的参数叫做形参(形式参数)，它只是一个变量名，接受调用时传递的实参，仅供函数体中的代码调用。

函数调用时，传入()里的参数叫实参(实际参数)，它是实际的数据，会传递给形参。

形参

根据形参的功能和定义方式可以分为：

• 必须参数
• 默认参数
• 动态参数
  • 位置动态参数
  • 关键字动态参数

必须参数

在定义函数时，如果要求调用者必须传递实参给这个形参，那么这个形参就要定义为必须形参。

直接定义在函数名后的()里的形参就是必须形参。

例如上一节中的my_print函数中的content和count。我们再来看一个案例：

定义一个函数，接收两个数，然后打印它们的和

>>> def add(x,y):
...     print(x+y)
>>> add(1)		# 调用时必须传递实参给必须参数，否则报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() missing 1 required positional argument: 'y'
>>> add(1,2)
3

默认参数

在定义函数时，某些形参有默认值，在调用时可以不接收实参，这种情况就可以定义为默认形参。

在函数名后()中，以参数名=默认值的形式定义的形参就是必须参数。

注意：默认参数必须定义在必须参数的后面

案例：

定义一个函数，它接收两个参数content和count

content是函数要打印的内容

count是函数打印的次数，如果不传递count默认打印1次

>>> def my_print(content, count=1):
...     for i in range(count):
...        print(content)
# 调用
>>> my_print('好好学习，天天向上！')
'好好学习，天天向上！'
>>> my_print('好好学习，天天向上！', 2)
'好好学习，天天向上！'
'好好学习，天天向上！'

调用函数时传递实参给默认形参会覆盖默认值。

动态参数

在定义函数时，不确定在调用时会传递多少个实参，可以定义为动态形参。

动态形参根据实参的传递方式又分为两种。

位置动态参数

在函数名后的（）中，在形参前加*号，这个形参就被定义为位置动态参数，通常位置动态参数的参数名为args。

它用来接收函数调用时，以位置形式传递过来的超过形参数量的多余的实参。

注意：位置动态参数必须定义在默认参数后面。

位置动态参数会将所有多余的位置实参创建成一个元组。

>>> def func(a, *args):
...     print(args, type(args))
>>> func(1,2,3,4)
(2, 3, 4) <class 'tuple'>

案例：

定义一个函数，接受2个以上的数，打印它们的和。

>>> def add(x, y, *args):
...     sum = x + y
...     for i in args:
...         sum += i
...     print(sum)
>>> add(1, 2, 3, 4)
10

关键字动态参数

在函数名后的（）中，在形参前加**号，这个形参就被定义为关键字动态参数，通常关键字动态参数的参数名为kwargs。

它用来接收函数调用时，以关键字形式传递过来的超过形参数量的多余的实参。

注意：关键字动态参数必须定义在位置动态参数的后面。

关键字动态参数会将多余的关键字实参创建成一个字典

>>> def func(a, **kwargs):
...     print(kwargs, type(kwargs))
>>> func(a=1,b=2,c=3,d=4)
{'b': 2, 'c': 3, 'd': 4} <class 'dict'>

实参

调用函数时传递实参有两种方式：

• 位置传递
• 关键字传递

位置传递

调用函数时，在小括号中以(实参1,实参2,...)的形式传递的实参会按照位置与形参一一对应，以这种方式传递的实参叫做位置实参。

案例：

定义一个函数实现打印一个数的n次幂。

>>> def my_power(x, n):
...     print(x**n)
>>> my_power(3,2)		# 3传递给x,2传递给n
9
>>> my_power(2,3)		# 2传递给x,3传递给n
8

关键字传递

调用函数时，在小括号中以(形参1=实参1,形参2=实参2,...)的形式，显式的指定形参与实参的对应关系，以这种方式传递的实参叫做关键字实参。

注意：关键字实参必须写在位置实参的后面。

案例：

使用关键字的方式调用my_power函数

>>> my_power(x=3,n=2)
9
>>> my_power(n=2,x=3)
9
>>> my_power(3,n=2)
9

参数解包

当一个函数接收多个参数时，如果参数存储在一个列表或一个字典中时，调用起来非常不方便。看下面的案例：

>>> def func(a, *args):
...     print(args, type(args))
>>> ls = [1,2,3,4,5,6]
>>> fun(ls[0],ls[1],ls[2],ls[3],ls[4],ls[5])
1 2 (3, 4, 5, 6)
>>> def func(a, **kwargs):
...     print(kwargs, type(kwargs))
>>> dc =  {'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> fun(a=dc['a'], b=dc['b'], c=dc['c'], d=dc['d'])
1 2 {'c': 3, 'd': 4}

可以看到上面的案例调用时的不便，参数解包就是为了解决这些问题的。

*解包

在传递实参时，可以通过*对可迭代对象进行解包。

>>> func(ls[0],ls[1],ls[2],ls[3],ls[4],ls[5])
1 2 (3, 4, 5, 6)
>>> func(*ls)			# 与上面的写法等价
1 2 (3, 4, 5, 6)

**解包

在传递实参时，可以通过**对字典进行解包。

>>> fun(a=dc['a'], b=dc['b'], c=dc['c'], d=dc['d'])
1 2 {'c': 3, 'd': 4}
>>> fun(**dc)			# 与上面的写法等价
1 2 {'c': 3, 'd': 4}