上一天看到第四章的一半，介绍了一些常用的流程控制工具，也就是常用语句，主要是if、for、range()、break、continue、else和pass。今天把第四章剩下的看完，讲的是如何在python中定义和使用函数。函数其实就是一种对代码的封装，对于一段完成某种功能的代码，如果需要在程序中多次用到这个功能，不使用函数的话，就要写多次相同的代码，很麻烦；如果使用函数的话，定义函数只需要一次，往后每次需要使用这个函数的话调用就行了，即实现了代码重用，简便很多。

4.6. 定义函数

python中，我们使用关键字 def 引入一个函数定义。它必须后跟函数名称和带括号的形式参数列表。构成函数体的语句从下一行开始，并且必须缩进。

函数体的第一个语句通常是注释或者帮助文档，用三引号‘’‘ ’‘’括起来，里面应该写上函数的功能和各参数的意义等等，是面向用户的。在notebook里面使用help()就可以查看到这些信息。写帮助文档是一个应该养成的好习惯。

函数调用（执行）则是直接运行函数名，如果有参数则写在括号内，一个用于输出斐波拉契数列的函数例子如下：

>>> def fib(n):    # 函数定义
...     """函数功能：打印n以内的斐波拉契数列"""
...     a, b = 0, 1
...     while a < n:
...         print(a, end=' ')
...         a, b = b, a+b
...     print()
...
>>> # 函数调用
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

定义了的函数是一个特定的类型，它也支持重命名，如下f和fib就是同一个函数了：

>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89

学过其他语言的人可能会问，python的函数有返回值吗？答案是肯定的，我们可以用return语句返回指定的值，如果像上面的例子一样没有return呢？实际上也有返回值，只不过是一个None而已，使用print()就可以看到它了。

总结一句：return 语句会从函数内部返回一个值。 不带表达式参数的 return 会返回 None。 函数执行完毕退出也会返回 None。

>>> fib(0)
>>> print(fib(0))
None

最后我们改写上面的斐波拉契函数，不是直接打印print()，而是先调用函数返回return一个列表，再打印这个列表：

>>> def fib2(n):  # 函数定义
...     """函数功能：返回一个列表，里面包含了n以内的斐波拉契数列"""
...     result = []
...     a, b = 0, 1
...     while a < n:
...         result.append(a)    # 向列表新增一个数据
...         a, b = b, a+b
...     return result
...
>>> f100 = fib2(100)    # 函数调用
>>> f100                # 打印结果
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

4.7. 函数定义的更多形式

4.7.1. 参数默认值

最有用的形式是对一个或多个参数指定一个默认值。这样创建的函数，可以用比定义时允许的更少的参数调用，比如:

def ask_ok(prompt, retries=4, reminder='Please try again!'):while True:ok = input(prompt)if ok in ('y', 'ye', 'yes'): # in关键字可以测试一个序列是否包含某个值return Trueif ok in ('n', 'no', 'nop', 'nope'):return Falseretries = retries - 1if retries < 0:raise ValueError('invalid user response')print(reminder)

这个函数可以通过几种方式调用:

• 只给出必需的参数（参数prompt）：ask_ok('Do you really want to quit?')
• 给出一个可选的参数（参数prompt和retries）：ask_ok('OK to overwrite the file?', 2)
• 或者给出所有的参数（参数prompt、retries和reminder）：ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

有两点需要注意！！

一、默认值是在 定义过程 中在函数定义处计算的，所以以下结果会打印5而不是6：

i = 5def f(arg=i):   # 此处传入默认值i，所以arg=i=5print(arg)i = 6  # 不影响f的默认值
f()

二、默认值只会执行一次。这条规则在默认值为可变对象（列表、字典以及大多数类实例）时很重要。比如，下面的函数会存储在后续调用中传递给它的参数:

def f(a, L=[]):L.append(a)return Lprint(f(1))
print(f(2))
print(f(3))

打印结果为：

[1]
[1, 2]
[1, 2, 3]

如果你不想要在后续调用之间共享默认值，你可以这样写这个函数:

def f(a, L=None):if L is None:L = []L.append(a)return L

打印结果为：

[1]
[2]
[3]

4.7.2. 关键字参数

4.7.3. 特殊参数

这两节已经在我之前的文章中介绍过了，感兴趣的小伙伴可以去看看：
python函数参数那些事，关键字参数与位置参数

4.7.4. 任意的参数列表

最后，最不常用的选项是可以使用任意数量的参数调用函数。这些参数会被包含在一个元组里（参见 元组和序列 ）。在可变数量的参数之前，可能会出现零个或多个普通参数。:

def write_multiple_items(file, separator, *args):file.write(separator.join(args))

一般来说，这些可变参数 将在形式参数列表的末尾，如上面代码中的*args参数（和C语言区分一下，注意不是指针）。因为它们收集传递给函数的所有剩余输入参数，简单来说，就是捡破烂的，剩下的参数都归他了。
但也有例外，它不在参数列表的末尾。此时，出现在 *args 参数之后的任何形式参数都是 仅关键字参数，也就是说它们只能作为关键字参数而不能是位置参数:

>>> def concat(*args, sep="/"):
...     return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'

4.7.5. 解包参数列表

如果我们的参数已经在列表或元组里了，但是想把里面的元素作为单独的参数传入函数，应该怎么做呢？此时称为对参数列表进行解包。
例如，内置的 range() 函数需要单独的 start 和 stop 参数。如果它们不能单独使用，可以使用 *操作符 来编写函数调用以便从列表或元组中解包参数:

>>> list(range(3, 6))      #正常的调用，向range函数传入两个单独的参数3和6
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args))    #解包调用，从列表args中解包出数字3和6，再传入range函数
[3, 4, 5]

如果参数在字典里，则用**操作符解包出字典的值value，来提供关键字参数:

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

4.7.6. Lambda 表达式

可以用 lambda 关键字来创建一个小的匿名函数。Lambda函数可以在需要函数对象的任何地方使用。它们在语法上限于单个表达式。从语义上来说，它们只是正常函数定义的语法糖。与嵌套函数定义一样，lambda函数可以引用所包含域的变量。
简单来说，Lambda函数有两个作用：返回一个函数，或者传递一个小函数作为参数。
作用1：

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

作用2：

>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

4.7.7. 文档字符串

4.7.8. 函数标注

这两节介绍的是关于函数帮助文档和注释内容和格式的一些约定，这里不详细展开了。