Python 函数的主要作用就是打包代码。 有两个显著的好处：

我们使用 def 语句来定义函数，紧跟着的是函数的名字，后面带一对小括号，冒号下面就是函数体，函数体是一个代码块，也就是每次调用函数时将被执行的内容：

注：pass 是一个空语句，表示不做任何事情，经常是被用来做一个占位符使用的。

调用这个函数，只需要在名字后面加上一对小括号：

从调用角度来看，参数可以细分为：形式参数（parameter）和实际参数（argument）。

其中，形式参数是函数定义的时候写的参数名字（比如下面例子中的 name 和 times）；实际参数是在调用函数的时候传递进去的值（比如下面例子中的 “Python” 和 5）。

有时候，我们可能需要函数干完活之后能给一个反馈，这在 BIF 函数中也很常见，比如 sum() 函数会返回求和后的结果，len() 函数会返回一个元素的长度，而 list() 函数则会将参数转换为列表后返回……

只需要使用 return 语句，就可以让咱们自己定制的函数实现返回：

最后，如果一个函数没有通过 return 语句返回，它也会自己在执行完函数体中的语句之后，悄悄地返回一个 None 值：

在通常的情况下，实参是按照形参定义的顺序进行传递的：

由于在定义函数的时候，就已经把参数的名字和位置确定了下来，我们将 Python 中这类位置固定的参数称之为位置参数。

使用关键字参数，我们只需要知道形参的名字就可以：

尽管使用关键字参数需要你多敲一些字符，但对于参数特别多的函数，这一招尤其管用。

如果同时使用位置参数和关键字参数，那么使用顺序是需要注意一下的：

比如这样就不行了，因为位置参数必须是在关键字参数之前，之间也不行哈。

Python 还允许函数的参数在定义的时候指定默认值，这样以来，在函数调用的时候，如果没有传入实参，那么将采用默认的参数值代替：

默认参数的意义就是当用户没有输入该参数的时候，有一个默认值可以使用，不至于造成错误。

如果用户指定了该参数值，那么默认的值就会被覆盖：

这里也有一点是需要注意的，就是如果要使用默认参数，那么应该把它们摆在最后：

咱们在使用 help() 函数查看函数文档的时候呢，经常会在函数原型的参数中发现一个斜杠（/），比如：

这表示斜杠左侧的参数必须传递位置参数，不能是关键字参数，举个例子：

那斜杠右侧的话呢，就随你了：

既然有限制 “只能使用位置参数”，那有没有那种限制 “只能使用关键字参数” 的语法呢？

那就是利用星号（*）：

这样，参数 a 既可以是位置参数也可以是关键字参数，但参数 b 和参数 c 就必须是关键字参数，才不会报错：

什么叫收集参数呢？

当我们在定义一个函数的时候，假如需要传入的参数的个数是不确定的，按照一般的写法可能需要定义很多个相同的函数然后指定不同的参数个数，这显然是很麻烦的，不能根本解决问题。

为解决这个问题，Python 就推出了收集参数的概念。所谓的收集参数，就是说只指定一个参数，然后允许调用函数时传入任意数量的参数。

定义收集参数其实也很简单，即使在形参的前面加上星号（*）来表示：

如果在收集参数后面还需要指定其它参数，那么在调用函数的时候就应该使用关键参数来指定后面的参数：

除了可以将多个参数打包为元组，收集参数其实还可以将参数们打包为字典，做法呢，是使用连续的两个星号（**）：

对于这种情况，在传递参数的时候就必须要使用关键字参数了，因为字典的元素都是键值对嘛，所以等号（=）左侧是键，右侧是值：

混合起来使用就更加灵活了：

这一个星号（*）和两个星号（**）不仅可以用在函数定义的时候，在函数调用的时候也有特殊效果，在形参上使用称之为参数的打包，在实参上的使用，则起到了相反的效果，即解包参数：

那么两个星号（**）对应的是关键字参数：

如果一个变量定义的位置是在一个函数里面，那么它的作用域就仅限于函数中，我们将它称为局部变量。

变量 x 是在函数 myfunc() 中定义的，所以它的作用域仅限于该函数，如果我们尝试在函数的外部访问这个变量，那么就会报错：

如果是在任何函数的外部去定义一个变量，那么它的作用域就是全局的，我们也将其称为全局变量：

如果在函数中存在一个跟全局变量同名的局部变量，会发生什么样的事情呢？

在函数中，局部变量就会覆盖同名的全局变量的值：

注意：代码中两个 x 并非同一个变量，只是由于作用域不同，它们同名但并不同样。

通常我们无法在函数内部修改全局变量的值，除非使用 global 语句破除限制：

函数也是可以嵌套的：

在外部函数 funA() 里面嵌套了一个内部函数 funB()，那么这个内部函数是无法被直接调用的：

想要调用 funB()，必须得通过 funA()：

通常我们无法在嵌套函数的内部修改外部函数变量的值，除非使用 nonlocal 语句破除限制：

只要记住 LEGB，那么就相当于掌握了 Python 变量的解析机制。 其中：

是不是，它本来的功能是将参数转换成字符串类型，但由于我们将它作为变量名赋值了，那么 Python 就把它给覆盖了：

对于嵌套函数来说，外层函数的作用域是会通过某种形式保存下来的，它并不会跟局部作用域那样，调用完就消失。

所谓闭包（closure），也有人称之为工厂函数（factory function）。

举个例子：

这里 power() 函数就像是一个工厂，由于参数不同，得到了两个不同的 “生产线”，一个是 square()，一个是 cube()，前者是返回参数的平方，后者是返回参数的立方。

比如说在游戏开发中，我们需要将游戏中角色的移动位置保护起来，不希望被其他函数轻易就能够修改，所以我们就可以利用闭包：

程序实现如下：

装饰器本质上也是一个函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外的功能。

程序实现如下：

使用了装饰器，我们并不需要修改原来的代码，只需要在函数的上方加上一个 @time_master，然后函数就能够实现统计运行时间的功能了。

这个 @ 加上装饰器名字其实是个语法糖，装饰器原本的样子应该这么调用的：

我们在 f-string 里面谈到过语法糖，我们说语法糖是某种特殊的语法，对语言的功能没有影响，但对程序员来说，有更好的易用性，简洁性、可读性和方便性。

这个就是装饰器的实现原理啦~

多个装饰器也可以用在同一个函数上：

程序实现如下：

这样的话，就是先计算平方（square 装饰器），再计算立方（cube 装饰器），最后再加 1（add 装饰器）。

如何给装饰器传递参数呢？

答案是添加多一层嵌套函数来传递参数：

程序实现如下：

我们将语法糖去掉，拆解成原来的样子，你就知道原理了：

程序实现如下：

这里其实就是给它裹多一层嵌套函数上去，然后通过最外层的这个函数来传递装饰器的参数。

这样，logger(msg=“A”) 得到的是 timemaster() 函数的引用，然后再调用一次，并传入 funA，也就是这个 logger(msg=“A”)(funA)，得到的就是 call_func() 函数的引用，最后将它赋值回 funA()。

咱们对比一下没有参数的描述器，这里其实就是添加了一次调用，然后通过这次调用将参数给传递进去而已。

lambda 表达式，也就是大牛们津津乐道的匿名函数。

只要掌握了 lambda 表达式，你也就掌握了一行流代码的核心 —— 仅使用一行代码，就能解决一件看起来相当复杂的事情。

它的语法是这样的：

lambda arg1, arg2, arg3, … argN : expression

ambda 是个关键字，然后是冒号，冒号左边是传入函数的参数，冒号后边是函数实现表达式以及返回值。

我们可以将 lambda 表达式的语法理解为一个极致精简之后的函数，如果使用传统的函数定义方式，应该是这样：

如果要求我们编写一个函数，让它求出传入参数的平方值，以前我们这么写：

现在我们这么写：

传统定义的函数，函数名就是一个函数的引用：

而 lambda 表达式，整个表达式就是一个函数的引用：

lambda 是一个表达式，因此它可以用在常规函数不可能存在的地方：

注意：这里说的是将整个函数的定义过程都放到列表中哦~

利用 lambda 表达式与 map() 和 filter() 函数搭配使用，会使代码显得更加 Pythonic：

lambda 是一个表达式，而非语句，所以它能够出现在 Python 语法不允许 def 语句出现的地方，这是它的最大优势。

但由于所有的功能代码都局限在一个表达式中实现，因此，lambda 通常只能实现那些较为简单的需求。

当然，Python 肯定是有意这么设计的，让 lambda 去做那些简单的事情，我们就不用花心思去考虑这个函数叫什么，那个函数叫什么……

def 语句则负责用于定义功能复杂的函数，去处理那些复杂的工作。

在 Python 中，使用了 yield 语句的函数被称为生成器（generator）。

与普通函数不同的是，生成器是一个返回生成器对象的函数，它只能用于进行迭代操作，更简单的理解是 —— 生成器就是一个特殊的迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 yield 方法时从当前位置继续运行。

定义一个生成器，很简单，就是在函数中，使用 yield 表达式代替 return 语句即可。 举个例子：

我们可以把它放到一个 for 语句中：

注意：生成器不像列表、元组这些可迭代对象，你可以把生成器看作是一个制作机器，它的作用就是每调用一次提供一个数据，并且会记住当时的状态。而列表、元组这些可迭代对象是容器，它们里面存放着早已准备好的数据。

生成器可以看作是一种特殊的迭代器，因为它首先是 “不走回头路”，第二是支持 next() 函数：

当没有任何元素产出的时候，它就会抛出一个 “StopIteration” 异常。

由于生成器每调用一次获取一个结果这样的特性，导致生成器对象是无法使用下标索引这样的随机访问方式：

因为列表有推导式，元组则没有，如果非要这么写：

那么我们可以看到，它其实就是得到一个生成器嘛：

这种利用推导的形式获取生成器的方法，我们称之为生成器表达式。

使用 help() 函数，我们可以快速查看到一个函数的使用文档：

创建函数文档非常简单，使用字符串就可以了，举个例子：

注意：函数文档一定是在函数的最顶部。

我们可以看到，函数开头的几行字符串并不会被打印出来，但它将作为函数的文档被保存起来。

现在通过 help() 函数，就可以查看到 exchange() 的文档了：

有时候，你可能会看到这样的代码：

其实这里面多出来的东东，就是 Python 的类型注释啦~

比如上面代码表示该函数的作者，希望调用者传入到 s 参数的是字符串类型，传入到 n 参数的是整数类型，最后还告诉我们函数将会返回一个字符串类型的返回值：

当然，这只不过是函数作者的寄望，如果调用者非要胡来，Python 也是不会出面阻止的：

因为这只是类型注释，是给人看的，不是给机器看的哈。

如果需要使用默认参数，那么类型注释可以这么写：

如果还想更进一步，比如期望参数类型是一个整数列表（也就是列表中所有的元素都是整数），那么代码可以这么写：

映射类型也可以使用这种方法，比如我们期望字典的键是字符串，值是整数，可以这么写：

内省，其实最先是心理学的基本研究方法之一，又称为自我观察法。它是发生在内部的，我们自己能够意识到的主观现象。

Python 通过一些特殊的属性来实现内省，比如我们想知道一个函数的名字，可以使用 name：

使用 _annotations 查看函数的类型注释：

查看函数文档，可以使用 doc：

阅读不友好，咱们使用 print() 函数给打印一下：

很多同学一听高阶，那一定是很厉害很强大的意思，其实这样描述并不全面。

在前面的学习中，我们发现，函数是可以被当作变量一样自由使用的，那么当一个函数接收另一个函数作为参数的时候，这种函数就称之为高阶函数。

高阶函数几乎就是函数式编程的灵魂所在，所以 Python 专程为此搞了一个模块 —— functools，这里面包含了非常多实用的高阶函数，以及装饰器。

它的第一个参数是指定一个函数，这个函数必须接收两个参数，然后第二个参数是一个可迭代对象，reduce() 函数的作用就是将可迭代对象中的元素依次传递到第一个参数指定的函数中，最终返回累积的结果。

其实就相当于这样子：

另外，将 reduce() 函数的第一个参数写成 lambda 表达式，代码就更加极客了，比如我们要计算 10 的阶乘，那么可以这么写：

偏函数是对指定函数的二次包装，通常是将现有函数的部分参数预先绑定，从而得到一个新的函数，该函数就称为偏函数。

偏函数的实现原理大致等价于：

其实不难发现，它的实现原理就是闭包！

只不过使用偏函数的话更简单了一些，细节实现不用我们去费脑子了，直接拿来就用。

让我们先回到讲解装饰器时候的例子：

程序实现如下：

这里的代码呢，其实是有一个 “副作用” 的：

竟然，myfunc 的名字它不叫 ‘my_func’，而是叫 ‘call_func’……

这个其实就是装饰器的一个副作用，虽然通常情况下用起来影响不大，但大佬的眼睛里哪能容得下沙子，对吧？

所以发明了这个 @wraps 装饰器来装饰装饰器：

程序实现如下：