Python 函数 2
函数的参数
位置参数（普通，正常的参数）
随便编写一个求x^n的值的函数power(x, n)：
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s我们调用这个函数，需要传入两个参数，这个两个参数也叫做位置参数：
>>> power(5, 2)
25如果我们给power()函数只传入1个参数，会这样：
>>> power(5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: power() missing 1 required positional argument: 'n'显然会报错，这个时候，提示的错误大概意思是说：你需要在传入一个n参数。
如果我们就像给
power(x, n)函数传入1个参数，要怎么做？这个时候，就是要是默认参数了。
默认参数
默认参数在其他高级语言里也用，C/C++也有，你可以一时想不起来，但是，只要上代码，你就知道什么是默认参数了：
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s现在，这个形参n就是默认参数。
Q：使用默认参数有什么好处？
A：最大的好处是能降低调用函数的难度。
怎么就降低了函数的调用难度呢：一共两个方面：
1. 参数的数量。对于power(x, n)函数，参数数量可以是1个，也可以是2个。
2. 参数的顺序。如果有更多的参数，我们可以这样使用函数power(2, n=2)，默认参数对输入顺序没有要求。
对于默认参数一定要注意一点：必须使用不变对象，想：list这种可变的参数：不要使用。举例：
def add_end(L=[]):
L.append('END')
return L这个函数，你不给它传入参数时，如果你多次调用，会得到下面的结果：
>>> add_end()
['END']
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']如果你给它参数参数，它却可以正常的使用，不会出现上面的错误结果：
>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']Q：这是为什么？
A：解释：每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。
所以，结论就是，add_end()函数你写的不对，正确的写法是这样的：def add_end(L=None): if L is None: L = [] L.append('END') return L现在就对了，你可以试试，不管你调用几次，都没有问题。
可变参数
Q：什么是可变参数？
A：就是指针!
举个例子，看下面的程序：
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum这个calc(*numbers)函数，我可以随便个它传入参数：
>>> calc(*[1, 2, 3])
14
>>> calc(*(1, 3, 5, 7))
84
>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14
>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84
>>> calc()
0这个可变参数几乎无敌，它允许你传入0个或任意个参数。（解释：这些可变参数在函数调用时自动组装为一个tuple。）所以说，玩转指针，你就牛逼了。
关键字参数
Q：什么是关键字参数？
A：**para这样的参数就是所谓的关键字参数。
举例：
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)这个**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'}看到了吧，这就是关键字参数。
Q：那它究竟有什么作用？
A：也是，降低了函数的调用难度，并且可以扩展函数的功能。比如，这个person()函数，我们只需要保证能够接受到name和age这个两个参数就可以，如果调用者愿意提供更多的参数，我们也能收到。使用起来相当的灵活。
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}注意：kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
命名关键字参数
命名关键字参数就是：调用者依然可以不受限制的向person()函数传入形参，但是我们只接受指定的几个参数。
def person(name, age, *, city, job):
print(name, age, city, job)其中*后面的参数就都是命名关键字参数。（命名关键字参数需要一个特殊分隔符*）。
第2种写法：
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() takes 2 positional arguments but 4 were given >>> person('Jack', 24, city = 'Beijing', job = 'Engineer') Jack 24 Beijing Engineer解释：
如果命名关键字参数没有写参数名，Python解释器把这4个参数均视为位置参数。
所以，既然命令关键字参数是可选输入的，所以命令关键字参数需要些默认值。程序还要改：def person(name, age, *, city='Beijing', job='Engineer'): print(name, age, city, job)这样，程序就完美了。
总结：
1. 必须使用*作为特殊分隔符，它是为Python解释器识别位置参数和命名关键字参数用的。
2. 如果有可变参数，就不需要特意在加*了，可变参数后面跟着的默认为命名关键字参数。
3. 命名关键字参数必须赋默认值。
参数组合
Python中，函数的形参是上面这么多的形式。如果组合使用，顺序必须注意：必选参数、默认参数、可变参数、命名关键字参数和关键字参数， 这样的顺序。
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)调用：
>>> 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)的形式调用它，无论它的参数是如何定义的。
- 可见Python语言的灵活。如果使用C++取实现一个这种函数的功能，需要写多少重载方法啊！
- Python非常适合实验室做程序。就是，突然有一个灵感涌现，我们快速的使用Python编写一段脚本程序，来测试一下这个灵感的可行性。
递归函数
这的重点是讲Python，而不是递归。要说起递归，那是有很多好讲的，有许多的技巧。递归的思想很简单，但是写起程序来很绕。
随便写一个：
def fact(n):
if n==1:
return 1
return n * fact(n - 1)Python使用自己写的递归函数时，注意的事情就是：传入的值不要太大，容易产生栈溢出错误。
>>> fact(1000)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in fact
...
File "<stdin>", line 4, in fact
RuntimeError: maximum recursion depth exceeded in comparison