7 函数
7.3 函数的参数
Python 的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变 参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。
7.3.1 位置参数 例:
计算 x2.
def power(x):
return x * x
print(power (5)) print(power (15))
25 225
对于power()函数，x就是一个位置参数。调用它时，必须传入有且仅有的一个参数x。
如果要计算 x3 怎么办？可以再定义一个power3()函数。但如果要计算 x4, x5,· · · 怎么办？我们不可能定 义无限多个函数。
例:
计算 xn.
def power(x, n):
s = 1
while n > 0:
n -= 1 s *= x return s
print(power (5, 2)) print(power (5, 3))
25 125
修改后的power(x, n)函数有两个位置参数：x和n。调用函数时，传入的两个值按照位置顺序依次赋给参数x 和n。
7.3.2 默认参数
新的power(x, n)函数定义没有问题，但是，旧的调用失败了，原因是我们增加了一个参数，导致旧的代码因 为缺少一个参数而无法正常调用：
>>> power (5)
Traceback (most recent call last):
File "<stdin >", line 1, in <module >
TypeError : power () missing 1 required positional argument : 'n' 调用power()时缺少了一个位置参数n。
这个时候默认参数就派上用场了。由于经常计算 x2，完全可以将第二个参数n的默认值设定为 2：
例:
计算 xn.
def power(x, n=2):
s = 1
while n > 0:
n -= 1 s *= x return s
print(power (5)) print(power (5, 2))
25 25
• 调用power(5)时，相当于调用power(5, 2)；
• 而对于 n≥ 2 的情形，则必须明确传入第二个参数，如power(5, 3)。
设置默认参数时，有几点要注意：
1. 位置参数在前，默认参数在后，否则 Python 解释器会报错；
2. 如何设置默认参数？当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参 数就可以作为默认参数。
使用默认参数有什么好处？最大的好处是简化函数的调用。
例:
编写一个小学一年级新生注册的函数，需要传入name和gender两个参数：
def enroll (name , gender ):
print(f"name: {name}") print(f" gender : { gender }")
enroll ('Sarah ', 'F')
name: Sarah gender : F
如果要继续传入年龄、城市等信息怎么办？这样会使得调用函数的复杂度大大增加。可以把年龄和城市设 为默认参数：
例:
def enroll (name , gender , age =6, city='Wuhan '):
print(f"name: {name}") print(f" gender : { gender }") print(f"age: {age}")
print(f"city: {city}") print('')
enroll ('Sarah ', 'F') enroll ('Bob ', 'M', '7')
enroll ('Adam ', 'F', city='Beijing ' )
name: Sarah gender : F age: 6 city: Wuhan
name: Bob gender : M age: 7 city: Wuhan
name: Adam gender : F age: 6
city: Beijing
• 大部分学生注册时不需要提供年龄和城市，只需要提供必须的两个参数；
• 只有与默认参数不符的学生才需要提供额外的信息。
由此可见，默认参数降低了函数调用的难度，而一旦需要更复杂的调用时，又可以传递更多的参数来实现。无 论是简单调用还是复杂调用，函数只需要定义一个。
如果存在多个默认参数，则在调用时，
• 既可以按顺序提供默认参数，如enroll('Bob', 'M', 7)，除位置参数name和gender外，最后一个参数 应用在参数age上，参数city仍使用默认值；
• 也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。如enroll(' Adam', 'M', city='Beijing')：参数city用传进去的值，其他默认参数仍使用默认值。
7.3.3 可变参数
在 Python 函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是 1 个、
2 个到任意个，还可以是 0 个。
例:
给定一组数字 a, b, c,· · · ，计算 a2+ b2+ c2+· · · 。要定义该函数，必须先确定输入的参数。由于参数个数 不确定，可把 a, b, c,· · · 作为一个 list 或 tuple 传进来，即
def calc( numbers ):
sum = 0
for n in numbers : sum += n*n return sum
print(calc ([1 , 2, 3, 4])) print(calc ((1 , 3, 5, 7)))
30 84
此时，必须先组装出一个 list 或 tuple 才能调用。
如果利用可变参数，调用方式可以简化：
例:
def calc (* numbers ):
sum = 0
for n in numbers : sum += n*n return sum
print(calc (1, 2, 3, 4)) print(calc (1, 3, 5, 7)) print(calc ())
30 84 0
与上例相比，定义可变参数时仅需在参数前加上一个*号。在函数内部，参数numbers接收到的是一个 tuple，故函数代码完全不变。但是，调用函数时，可传入任意个参数，包括 0 个参数。
如果已经有一个 list 或者 tuple，要调用一个可变参数怎么办？可以这样做：
nums = [1, 2, 3]
print(calc(nums [0] , nums [1] , nums [2]))
不过这样做过于繁琐。事实上，Python 允许你在 list 或 tuple 前加一个*号，把 list 或 tuple 中的元素变成可 变参数传进去：
print(calc (* nums)) 这种写法非常有用，且很常见。
7.3.4 关键字参数
可变参数允许你传入 0 个或任意个参数，这些可变参数在函数调用时自动组装为一个 tuple。而关键字参数允 许你传入 0 个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个 dict。
def person (name , age , ** kw):
print(f"name: {name}, age: {age }, other : {kw}")
person ('Michael ', 30)
person ('Bob ', 35, city='Wuhan ') person ('Sarah ', 22, gender ='F', city='Beijing ')
name: Michael , age: 30, other : {}
name: Bob , age: 35, other: {'city ':
'Wuhan '}
name: Sarah , age: 22, other : {' gender ': 'F', 'city ': 'Beijing '}
函数person()除了必选参数name和age外，还接受关键字参数kw。调用该函数时，
• 可以只传入必选参数，如person('Michael', 30)
• 也可传入任意个数的关键字参数，如person('Bob', 35, city='Beijing'), person('Adam', 45, gender
='M', job='Engineer')。
关键字参数有什么用？它可以扩展函数的功能。
• 在person()中，可保证接受参数name和age，但如果调用者愿意提供更多的参数，也能做到。
• 试想你要实现一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数 来定义这个函数就能满足注册的需求。
和可变参数类似，也可以先组装出一个 dict，然后，把该 dict 转换为关键字参数传进去：
extra = {'city ': 'Beijing ', 'job ':
'Engineer '}
person ('Jack ', 24, ** extra )
name: Jack , age: 24, other : {'city ' : 'Beijing ', 'job ': 'Engineer '}
**extra表示把extra这个 dict 的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个 dict。注意kw获得的 dict 是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
7.3.5 命名关键字参数
如果要限制关键字参数的名字，就可以用命名关键字参数。
例:
如果只接收city和job作为关键字参数，可以这么定义函数 def person (name , age , *, gender ,
city):
print(f"name: {name}, age: { age}, gender : { gender }, city:
{city}")
person ('Sarah ', 22, gender ='F', city='Beijing ')
name: Sarah , age: 22, gender : F, city: Beijing
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
如果函数定义中已经有了一个可变参数，则后面可直接命名关键字参数，而不需要特殊分隔符*：
def person (name , age , *args , gender , city):
print(f"name: {name}, age: {age}, args: {args}, gender : { gender }, city: { city}")
person ('Sarah ', 22, 'Engineer ', gender ='F', city='Beijing ')
name: Sarah , age: 22, args: ('Engineer ' ,), gender : F, city: Beijing 命名关键字参数可以有缺省值，从而简化调用：
def person (name , age , *, gender ='M', city):
print(f"name: {name}, age: {age}, gender : { gender }, city: {city}")
person ('Sarah ', 22, city='Beijing ')
name: Sarah , age: 22, gender : M, city: Beijing
7.3.6 参数组合
在 Python 中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这 5 种参数 都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和 关键字参数。
例:
def f1(a, b, c=0, *args , ** kw):
print(f'a = {a}, b = {b}, c = {c}, args: {args}, kw: {kw}')
def f2(a, b, c=0, *, d, ** kw):
print(f'a = {a}, b = {b}, c = {c}, d: {d}, kw: {kw}') 函数调用时，Python 解释器自动按照参数位置和参数名把对应的参数传进去。
f1(1, 2) f1(1, 2, c=3)
f1(1, 2, 3, 'a', 'b', x=99) f1(1, 2, d=99 , ext=None)
a = 1, b = 2, c = 0, args: () , kw: {}
a = 1, b = 2, c = 3, args: () , kw: {}
a = 1, b = 2, c = 3, args: ('a', 'b'), kw: {'x': 99}
a = 1, b = 2, c = 0, args: () , kw: {'d': 99, 'ext ': None}
最神奇的是通过一个 tuple 和 dict，你也可以调用上述函数：
args = (1, 2, 3, 4) kw = {'d': 99, 'x': '#'}
f1 (*args , ** kw)
args = (11 , 22, 33)
kw = {'d': 44, 'x': '## '}
f2 (*args , ** kw)
a = 1, b = 2, c = 3, args: (4 ,) , kw: {'d': 99, 'x': '#'}
a = 11, b = 22, c = 33, d: 44, kw: {'x': '## '}
因此，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。
7.4 习题
练习 2. 定义一个函数quadratic(a, b, c)，它接受 3 个参数，返回一元二次方程 ax2+ bx + c = 0 的两个 根。