Learning Python 010 函数 2

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

---

参考网站：

http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014316784721058975e02b46cc45cb836bb0827607738d000