定义函数的时候，把参数的名字和位置确定下来，接口就算定好了。调用的人只要知道怎么传参、会返回什么就行，至于函数内部怎么实现的，完全不用管。
Python定义函数很简单，但玩法却特别多。除了普通的必选参数，还有默认参数、可变参数、关键字参数这些花样，用好了能让函数接口既强大又好用。
位置参数
先写个计算 x² 的函数：
def power(x):
return x * x
这里的 x 就是位置参数。调用 power 函数时，必须传一个参数进去：
>>> power(5)
25
>>> power(15)
225
要算 x³ 怎么办？再写个 power3 函数？那 x⁴、x⁵ 呢？总不能写无数个函数吧。
其实可以把 power(x) 改成 power(x, n)，用来算 xⁿ：
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
改完后就能算任意次方了：
>>> power(5, 2)
25
>>> power(5, 3)
125
现在 power(x, n) 有两个位置参数，调用时传入的值按顺序分别赋给 x 和 n。
默认参数
新的 power(x, n) 函数没问题，但之前的代码全挂了：
>>> power(5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: power() missing 1 required positional argument: 'n'
Python直接告诉你：缺了个参数 n。
这时候默认参数就派上用场了。既然平时算 x² 最多，不如把 n 的默认值设成 2：
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
这样调用 power(5) 就相当于调用 power(5, 2)：
>>> power(5)
25
>>> power(5, 2)
25
要算更高次方就显式传 n，比如 power(5, 3)。
默认参数能简化函数调用。用的时候注意两点：
必选参数放前面，默认参数放后面，不然Python会报错。
参数该怎么设？变化大的放前面，变化小的放后面作为默认参数。
默认参数的好处是降低调用难度。
比如写个小学生注册函数，需要姓名和性别：
def enroll(name, gender):
print('name:', name)
print('gender:', gender)
调用时传两个参数就行：
>>> enroll('Sarah', 'F')
name: Sarah
gender: F
要是还要传年龄、城市呢？参数越来越多，调用就越来越复杂。
把年龄和城市设成默认参数：
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
大部分学生注册时只需要传必填信息：
>>> enroll('Sarah', 'F')
name: Sarah
gender: F
age: 6
city: Beijing
只有特殊情况才需要提供额外信息：
enroll('Bob', 'M', 7)
enroll('Adam', 'M', city='Tianjin')
默认参数让简单调用更简单，复杂调用也能实现，一个函数搞定所有场景。
有多个默认参数时，可以按顺序提供，比如 enroll('Bob', 'M', 7)，最后一个参数对应 age，city 还是用默认值。
也可以不按顺序，但要写上参数名。比如 enroll('Adam', 'M', city='Tianjin')，只有 city 用了传入的值，其他默认参数保持不变。
默认参数很好用，但有个大坑。
写个函数，传入一个 list，往里加个 'END' 再返回：
def add_end(L=[]):
L.append('END')
return L
正常调用看起来没问题：
>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']
用默认参数调用，一开始也对：
>>> add_end()
['END']
再调一次就出事了：
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']
新手经常懵：默认参数不是 [] 吗？怎么函数"记住"了上次的结果？
原因在这：Python定义函数时，默认参数 L 的值就确定了，也就是 []。因为 L 是个变量，指向对象 []，每次调用改了 L 的内容，下次调用时默认参数就不再是最初的 [] 了。
划重点：默认参数必须指向不变对象！
改成用 None 这个不变对象：
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
现在调用多少次都没问题：
>>> add_end()
['END']
>>> add_end()
['END']
为什么要设计 str、None 这些不变对象？因为不变对象创建后内部数据就不能改，大大减少了因为修改数据导致的错误。而且多任务环境下同时读取不用加锁，非常安全。写程序时能用不变对象就尽量用。
可变参数
Python函数还能定义可变参数，也就是传入的参数个数不固定，可以是1个、2个、任意多个，甚至0个。
数学题举例：给定一组数字 a、b、c……，算 a²+b²+c²+……。
参数个数不确定，可以先把它们放进 list 或 tuple：
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
调用时得先组装：
>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84
用可变参数就方便多了：
>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84
把参数改成可变参数：
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
和 list 或 tuple 参数比，就是在参数前加了个 * 号。函数内部 numbers 接收到的是个 tuple，所以函数代码不用改。但调用时可以传任意个参数，包括0个：
>>> calc(1, 2)
5
>>> calc()
0
已经有个 list 或 tuple，要传给可变参数怎么办？
>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14
这样写太麻烦。Python允许在 list 或 tuple 前加 *，把元素变成可变参数传进去：
>>> nums = [1, 2, 3]
>>> calc(*nums)
14
*nums 表示把 nums 这个 list 的所有元素作为可变参数传进去。这写法很实用，也很常见。
关键字参数
可变参数让你传任意个参数，它们在函数内自动组装成 tuple。关键字参数让你传任意个带参数名的参数,它们在函数内自动组装成 dict：
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
person 函数除了必选参数 name 和 age，还接受关键字参数 kw。调用时可以只传必选参数：
>>> person('Michael', 30)
name: Michael age: 30 other: {}
也可以传任意个关键字参数：
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
关键字参数能扩展函数功能。比如 person 函数保证能收到 name 和 age，但调用者想提供更多信息也没问题。做用户注册功能时，用户名和年龄是必填项，其他是可选项，关键字参数正好满足这个需求。
和可变参数类似,可以先组装个 dict,再转成关键字参数：
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
简化写法：
>>> 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 是 extra 的拷贝，改 kw 不会影响函数外的 extra。
命名关键字参数
关键字参数允许传任意不受限制的参数。具体传了哪些，要在函数内检查。
还是 person() 函数，检查是否有 city 和 job 参数：
def person(name, age, **kw):
if 'city' in kw:
# 有city参数
pass
if 'job' in kw:
# 有job参数
pass
print('name:', name, 'age:', age, 'other:', kw)
但调用者还是能传任意参数：
>>> person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)
要限制关键字参数的名字，用命名关键字参数。比如只接收 city 和 job：
def person(name, age, *, city, job):
print(name, age, city, job)
和 **kw 不同，命名关键字参数需要特殊分隔符 *，* 后面的参数就是命名关键字参数。
调用方式：
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer
如果函数已经有可变参数，后面的命名关键字参数就不需要 * 了：
def person(name, age, *args, city, job):
print(name, age, args, city, job)
命名关键字参数必须传参数名，不像位置参数。没传参数名会报错：
>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'
因为缺少参数名 city 和 job，Python把前两个当位置参数，后两个传给 *args，导致命名关键字参数缺失。
命名关键字参数可以有默认值：
def person(name, age, *, city='Beijing', job):
print(name, age, city, job)
city 有默认值，调用时可以不传：
>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer
用命名关键字参数时要注意：没有可变参数就必须加 * 作为分隔符。少了 *，Python会把它们当位置参数：
def person(name, age, city, job):
# 缺少 *，city和job变成位置参数
pass
参数组合
Python定义函数可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种可以组合使用。但要注意顺序：必选参数、默认参数、可变参数、命名关键字参数、关键字参数。
定义包含多种参数的函数：
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
调用时Python会自动按位置和参数名对应：
>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
更神奇的是用 tuple 和 dict 调用函数：
>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}
任意函数都能通过 func(*args, **kw) 形式调用，不管参数怎么定义的。
提示： 虽然能组合5种参数，但别同时用太多，不然函数接口会很难理解。
练习
下面这个函数算两个数的乘积，改造一下让它能接收一个或多个数并计算乘积：
def mul(x, y):
return x * y
# 测试
print('mul(5) =', mul(5))
print('mul(5, 6) =', mul(5, 6))
print('mul(5, 6, 7) =', mul(5, 6, 7))
print('mul(5, 6, 7, 9) =', mul(5, 6, 7, 9))
if mul(5) != 5:
print('mul(5)测试失败!')
elif mul(5, 6) != 30:
print('mul(5, 6)测试失败!')
elif mul(5, 6, 7) != 210:
print('mul(5, 6, 7)测试失败!')
elif mul(5, 6, 7, 9) != 1890:
print('mul(5, 6, 7, 9)测试失败!')
else:
try:
mul()
print('mul()测试失败!')
except TypeError:
print('测试成功!')
小结
Python函数的参数形态很灵活，既能实现简单调用，又能传入复杂参数。
默认参数一定要用不可变对象，用可变对象会有逻辑错误。
定义可变参数和关键字参数的语法：*args 是可变参数，接收 tuple；**kw 是关键字参数，接收 dict。
调用时传参的语法：可变参数可以直接传 func(1, 2, 3)，也可以先组装再用 *args 传入 func(*(1, 2, 3))；关键字参数可以直接传 func(a=1, b=2)，也可以先组装再用 **kw 传入 func(**{'a': 1, 'b': 2})。
*args 和 **kw 是Python的习惯写法，虽然可以用其他名字，但最好遵循习惯。
命名关键字参数是为了限制调用者能传的参数名，同时可以提供默认值。
定义命名关键字参数时，没有可变参数就别忘了加分隔符 *，不然会被当成位置参数。