【python - 函数】

一、交互式会话

在与 Python 的交互式会话中，你可以在提示符 >>> 后键入一些 Python 代码，Python 解释器会读取并执行你键入的各种命令。

要启动交互式会话，请在终端 (Mac/Unix/Linux) 中键入 python3 或在 Windows 中打开 Python 3 应用程序。

如果你看到了 Python 提示符 >>>，则已经成功启动交互式会话。我们会使用提示符和一些输入来展示示例。

>>> 2 + 2
4

交互控制：每个会话都会保留键入内容的历史记录，可以按下 <Control>-P（上一个）和 <Control>-N（下一个）浏览该历史记录。使用 <Control>-D 会退出会话并丢弃此历史记录。在某些系统上，上、下箭头也可以用于循环浏览历史记录。

二、表达式

我们从一种基本表达式“数字 number”开始，更准确地说，是你键入的，十进制数字组成的表达式。

>>> 42
42

表达式表示的数字可以与数学运算符组合形成一个复合表达式，解释器将对其进行求值：

>>> -1 - -1
0
>>> 1/2 + 1/4 + 1/8 + 1/16 + 1/32 + 1/64 + 1/128
0.9921875

这些数学表达式使用中缀表示法（infix notation），运算符（例如 +、-、* 或 /）出现在操作数之间。Python 包含许多种形成复合表达式的方法，我们会在学习中慢慢引入新的表达式形式和它们所支持的语言特性，而不是立即把它们列举出来。

2.1、调用表达式

最重要的一种复合表达式是调用表达式，它将函数运用于一些参数上。回想一下代数中的函数的数学概念：函数就是从一些输入参数到输出值的映射。例如，max 函数会输出一个最大的输入值，也就是将多个输入映射到了单个输出上。Python 中函数应用的方式与传统数学相同。

>>> max(7.5, 9.5)
9.5

这个调用表达式包含子表达式（subexpressions）：在括号之前是一个运算符表达式，而括号里面是一个以逗号分隔的操作数表达式的列表。

运算符指定了一个函数，在对这个调用表达式进行求值时，我们会说：使用参数 7.5 和 9.5 来调用函数 max，最后返回 9.5。

调用表达式中参数的顺序是很重要的。例如，pow 函数的第二个参数是第一个参数的幂。

>>> pow(100, 2)
10000
>>> pow(2, 100)
1267650600228229401496703205376

函数符号相比传统的中缀数学符号有三个主要优点。首先，因为函数名总是在参数前面，函数可以接收任意数量的参数而不会产生歧义。

>>> max(1, -2, 3, -4)
3

其次，函数可以直接扩展为嵌套（nested）表达式，其元素本身就是复合表达式。不同于中缀复合表达式，调用表达式的嵌套结构在括号中是完全明确的。

>>> max(min(1, -2), min(pow(3, 5), -4))
-2

这种嵌套的深度（理论上）没有任何限制，Python 解释器可以解释任何复杂的表达式。但人类很快就会被多层嵌套搞晕，所以作为一个程序员，你的一个重要目标就是：构造你自己、你的编程伙伴和其他任何可能阅读你代码的人都可以解释的表达式。

第三点，数学符号在形式上多种多样：星号表示乘法，上标表示幂指数，水平横杠表示除法，带有倾斜壁板的屋顶表示平方根，而其中一些符号很难被输入！但是，所有这些复杂事物都可以通过调用表达式的符号来进行统一。Python 除了支持常见的中缀数学符号（如 + 和 -）之外，其他任何运算符都可以表示为一个带有名称的函数。

2.2、导入库函数

Python 定义了大量的函数，包括上一节中提到的运算符函数，但默认情况下我们不能直接使用名字来调用它们。Python 将已知函数和其他东西组织起来放入到了模块中，而这些模块共同组成了 Python 库。我们要使用的时候需要导入它们，例如，math  模块提供了各种熟悉的数学函数：

>>> from math import sqrt
>>> sqrt(256)
16.0

operator  模块提供了中缀运算符对应的函数：

>>> from operator import add, sub, mul
>>> add(14, 28)
42
>>> sub(100, mul(7, add(8, 4)))
16

import  语句需要指定模块名称（例如 operator  或  math），然后列出要导入该模块里的具名函数（例如 sqrt）。一个函数被导入后就可以被多次调用。

使用运算符函数（例如 add）和运算符号（例如  +）之间并没有任何区别。按照惯例来说，大多数程序员使用符号和中缀表示法来表达简单的算术。

上面我们计算的表达式获得的值是绑定到区域的东西，它并不记得面积曾经是用半径来定义的。

2.3、名称与环境

编程语言的一个要素就是使用名称来引用计算对象，如果一个值被赋予了名称，我们说名称绑定到了值上面。

在 Python 中，我们可以使用赋值语句建立新的绑定，= 左边是名称，右边是值。

>>> radius = 10
>>> radius
10
>>> 2 * radius
20

名称也可以通过 import 语句绑定。

>>> from math import pi
>>> pi * 71 / 223
1.0002380197528042

= 在 Python 中称为 赋值 符号（即 assignment operator，许多其他语言也是如此），赋值是最简单的 抽象 方法，因为它允许我们使用简单名称来指代复合操作的结果，例如上面计算的 area。这样，复杂的程序由复杂性递增的计算对象逐步构建。

将名称与值绑定，之后通过名称检索可能的值，就意味着解释器必须维护某种内存来记录名称、值和绑定，这种内存就是环境（environment）。

名称也可以与函数绑定。例如，名称 max 就和我们之前使用的 max 函数进行了绑定。与数字不同，函数很难以文本呈现，因此当询问一个函数时，Python 会打印一个标识来描述：

>>> max
<built-in function max>

赋值语句可以为现有函数赋予新名称。

>>> f = max
>>> f
<built-in function max>
>>> f(2, 3, 4)
4

之后再次赋值可以将已有名称与新值绑定。

>>> f = 2
>>> f
2

在 Python 中，名称通常被称为“变量名 variable names”或“变量 variables”，因为它们可以在执行程序的过程中与不同的值绑定。当一个变量通过赋值语句与一个新值绑定，它就不再绑定以前的值。你甚至可以将内置名称与新值绑定。

>>> max = 5
>>> max
5

将 max 赋值为 5 后，名称 max 不再绑定函数，因此调用 max(2, 3, 4) 将导致错误。

执行赋值语句时，Python 会先求解 = 右侧的表达式，再将结果与左侧的名称绑定，所以可以在右侧表达式中引用一个已绑定的变量。

>>> x = 2
>>> x = x + 1
>>> x
3

还可以在单个语句中为多个变量分配值，左右都用逗号隔开。

>>> area, circumference = pi * radius * radius, 2 * pi * radius
>>> area
314.1592653589793
>>> circumference
62.83185307179586

更改一个变量的值不会影响其他变量。即使下列代码中 area 的值由最初定义的 radius 绑定，但改变 radius 的值并不能更新 area 的值，我们需要另一个赋值语句来更新它。

>>> radius = 11
>>> area
314.1592653589793
>>> area = pi * radius * radius
380.132711084365

对于多重赋值，所有 = 右边的表达式都会先求值，然后再与左边的名称绑定。在这个规则下，我们可以在单个语句内交换两个变量的值。

>>> x, y = 3, 4.5
>>> y, x = x, y
>>> x
4.5
>>> y
3

2.4、求解嵌套表达式

为了求值一个表达式，Python 将执行以下操作：

• 求解运算符子表达式和操作数子表达式
• 然后将操作数子表达式的值作为运算符子表达式的函数的参数

这个简单的过程也说明了有关流程的一些要点。第一步规定：为了求出调用表达式，必须首先求出其他表达式。因此，求值程序本质上是 递归 的，也就是说它会自己调用自己作为步骤之一。

例如，此式需要应用四次求值过程。

>>> sub(pow(2, add(1, 10)), pow(2, 5))
2016

如果把每个需要求解的表达式都抽出来，我们可以看到这个求值过程的层次结构。

这个图叫做表达式树，在计算机科学中，树通常从上到下增长。树中每个点的对象都叫做节点。这里节点分别是表达式和表达式的值。

求解根节点（即顶部的完整表达式），需要首先求解子表达式，也就是分支节点。叶子节点（也就是没有分支的节点）表示函数或数值。内部节点有两部分：我们想要应用的求值规则的调用表达式，以及该表达式的结果。观察这棵树的求解过程，我们可以想象操作数的值会向上流动，从叶子节点开始一步步向上组合。

接下来，观察第一步的重复应用，将我们带到我们需要求解的原始表达式，而不是调用表达式，例如数字（例如 2）和名称（例如  add）。我们规定基本逻辑为：

• 数字的值就是它们所表示的数值
• 名称的值是环境中关联此名称的对象

注意环境在决定表达式中的符号意义上有重要作用。在 Python 中，不指定任何环境信息去谈论一个值是没有意义的，例如名称 x 和 add。环境为求解提供了上下文信息，对理解程序执行过程有着重要作用。

>>> add(x, 1)

这个求解步骤并不能对所有 Python 代码求值，它仅能求解调用表达式、数字和名称。例如，它并不能处理赋值语句。

>>> x = 3

因为赋值语句的目的是将名称与值绑定，它并不返回值，也不应用参数去求解函数。也就是说，赋值语句不被求解但“被执行”，它们只是做出一些改变但不产生值。每种类型的表达式或语句都有自己的求解或执行过程。

注意：当我们说“一个数字求解为一个数值”时，实际上是 Python 解释器将数字求解为数值，是解释器赋予了编程语言这个意义。鉴于解释器是一个始终表现一致的固定程序，我们就可以说数字（以及表达式）会在 Python 程序的上下文中被求解为值。

2.5、定义新的函数

我们已经在 Python 中确定了强大的编程语言中一些必须出现的要素：

1. 原始的内置数据和函数：数字和算术运算
2. 组合方式：嵌套函数
3. 受限的抽象方式：将名称与值绑定

现在我们来学习 函数定义，这是一种更为强大的抽象技术，通过它可以将名称与复合操作绑定为一个单元。

首先来研究一下 平方 的概念。我们可能会说：“平方就是一个数乘以它本身。”这在 Python 中可以表示为：

>>> def square(x):return mul(x, x)

上面的代码定义了一个名为 square 的新函数，这个用户定义的函数并不会内置到解释器中，它表示将某值与自身相乘的复合运算。这个定义将 x 作为被乘的东西的名称，称为 形式参数，同时也将此函数与名称 square 绑定。

如何定义函数：函数定义包含 def 语句、<name 函数名> 和一个以逗号分隔的 <formal parameters 形式参数> 列表，然后是一个被称为函数体的 return 语句，它指定了调用函数时要计算的表达式，也就是函数的 <return expression 返回表达式> ：

def <name>(<formal parameters>):return <return expression>

函数的第二行 必须 进行缩进，大多数程序员使用四个空格。返回表达式会作为新定义的函数的一部分存储，并且仅在最终调用该函数时才进行求值。

定义了 square 之后，我们可以调用它：

>>> square(21)
441
>>> square(add(2, 5))
49
>>> square(square(3))
81

我们还可以将 square 作为一个构建单元来定义其他函数。例如，我们可以很容易地定义一个函数 sum_squares，给定任意两个数字作为参数，返回它们的平方和：

>>> def sum_squares(x, y):return add(square(x), square(y))>>> sum_squares(3, 4)
25

用户定义函数的使用方式与内置函数完全相同。实际上，从 sum_squares 的定义中我们并不能判断 square 是内置于解释器中，还是从模块中导入的，又或是用户定义的。

def 语句和赋值语句都将名称与值绑定，并且绑定后任何之前的绑定都将丢失。例如，下面的 g 首先指的是一个没有参数的函数，然后是指一个数字，最后是一个含有两个参数的函数。

>>> def g():return 1
>>> g()
1
>>> g = 2
>>> g
2
>>> def g(h, i):return h + i
>>> g(1, 2)
3

三、环境 

虽然我们现在的 Python 子集已经足够复杂，但程序的含义并不明显。如果形参与内置函数同名怎么办？两个函数可以共享名称而不会混淆吗？要解决这些问题，我们必须更详细地描述环境。

求解表达式的环境由 帧 序列组成，它们可以被描述为一些盒子。每个帧都包含了一些 绑定，它们将名称与对应的值相关联。全局 帧（global frame）只有一个。赋值和导入语句会将条目添加到当前环境的第一帧。目前，我们的环境仅由全局帧组成。

此 环境图 显示了当前环境中的绑定，还有名称和值的绑定。本文中的环境图是交互式的：你可以逐步运行左侧程序的每一行，然后在右侧查看环境状态的演变。你还可以单击“Edit this code”以将示例加载到 Online Python Tutor 中，它是由 Philip Guo  创建的用于生成环境图的工具。希望你能够自己去创建示例，研究对应生成的环境图。

函数也会出现在环境图中。import 语句将名称与内置函数绑定。def 语句将名称与用户自定义的函数绑定。导入 mul 并定义 square 后的结果环境如下所示：

每个函数都是一行，以 func 开头，后面是函数名称和形式参数。mul 等内置函数没有正式的参数名称，所以都是使用 ... 代替。

函数名称重复两次，一次在环境帧中，另一次是作为函数定义的一部分。函数定义中出现的名称叫做 内在名称（intrinsic name），帧中的名称叫做 绑定名称（bound name）。两者之间有一个区别：不同的名称可能指的是同一个函数，但该函数本身只有一个内在名称。

绑定到帧中的函数名称是在求值过程中使用，而内在名称在求值中不起作用。使用 Next 按钮逐步执行下面的示例，可以看到一旦名称 max 与数字值 3 绑定，它就不能再用作函数。

错误信息“TypeError: 'int' object is not callable”报告了名称 max （当前绑定到数字 3）是一个整数而不是函数，所以它不能用作调用表达式中的运算符。

函数签名：每个函数允许采用的参数数量有所不同。为了跟踪这些要求，我们绘制了每个函数的名称及其形式参数。用户定义的函数 square 只需要 x 一个参数，提供或多或少的参数都将导致错误。对函数形式参数的描述被称为函数的签名。

函数 max 可以接受任意数量的参数，所以它被呈现为 max(...)。因为原始函数从未明确定义，所以无论采用多少个参数，所有的内置函数都将呈现为 <name>(...)。

四、调用用户定义的函数

为了求出操作符为用户定义函数的调用表达式，Python 解释器遵循了以下计算过程。与其他任何调用表达式一样，解释器将对操作符和操作数表达式求值，然后用生成的实参调用具名函数。

调用用户定义的函数会引入局部帧（local frame），它只能访问该函数。通过一些实参调用用户定义的函数：

1. 在新的局部帧中，将实参绑定到函数的形参上。
2. 在以此帧开始的环境中执行函数体。

求值函数体的环境由两个帧组成：一是包含形式参数绑定的局部帧，然后是包含其他所有内容的全局帧。函数的每个实例都有自己独立的局部帧。

为了详细说明一个例子，下面将会描述相同示例的环境图中的几个步骤。执行第一个 import 语句后，只有名称 mul 被绑定在全局帧中。

首先，执行定义函数 square 的语句。请注意，整个 def 语句是在一个步骤中处理的。直到函数被调用（而不是定义时），函数体才会被执行。

接下来，使用参数 -2 调用 square 函数，它会创建一个新的帧，将形式参数 x 与 -2 绑定。

Visualized with pythontutor.com

然后在当前环境中查找名称 x，它由所示的两个帧组成，而在这两种情况下，x 的结果都是 -2，因此此 square 函数返回 4。

square() 帧中的“返回值”不是名称绑定的值，而是调用创建帧的函数返回的值。

即使在这个简单的示例中，也使用了两个不同的环境。顶级表达式 square(-2) 在全局环境中求值，而返回表达式 mul(x, x) 在调用 square 时创建的环境中求值。虽然 x 和 mul 都在这个环境中，但在不同的帧中。

环境中帧的顺序会影响通过表达式查找名称而返回的值。我们之前说过，名称会求解为当前环境中与该名称关联的值。我们现在可以更准确地说：

名称求解（Name Evaluation）：在环境中寻找该名称，最早找到的含有该名称的帧，其里边绑定的值就是这个名称的计算结果。

环境、名称和函数的概念框架构成了求解模型，虽然一些机械细节仍未指定（例如，如何实现绑定），但我们的模型确实精准地描述了解释器如何求解调用表达式。

4.1、示例：调用用户定义的函数 

让我们再次思考两个简单的函数定义，并说明计算用户定义函数的调用表达式的过程。

Python 首先求解名称 sum_squares ，并将它绑定到全局帧中的用户定义的函数，而原始数值表达式 5 和 12 的计算结果为它们所代表的数字。

接下来 Python 会调用 sum_squares ，它引入了一个局部帧，将 x 绑定到 5，将 y 绑定到 12。

sum_squares 的主体包含此调用表达式：

  add     (  square(x)  ,  square(y)  )
________     _________     _________
operator     operand 0     operand 1

所有三个子表达式都在当前环境中计算，且始于标记为 sum_squares() 的帧。运算符子表达式 add 是在全局帧中找到的名称，它绑定到了内置的加法函数上。在调用加法之前，必须依次求解两个操作数子表达式，两个操作数都在标记为 sum_squares 的帧的环境中计算。

在 operand 0 中，square 在全局帧中命名了一个用户定义的函数，而 x 在局部帧中命名了数字 5。Python 通过引入另一个将将 x 与 5 绑定的局部帧来调用 square 函数。

此环境下表达式 mul(x, x) 的计算结果为 25。

继续求解 operand 1，其中 y 的值为 12。Python 会再次对 square 的函数体进行求解，此时引入另一个将 x 与 12 绑定的局部帧，计算结果为 144。

最后，对参数 25 和 144 调用加法得到 sum_squares 的最终返回值：169。

这个例子展示了我们到目前为止学到的许多基本思想。将名称绑定到值，而这些值会分布在多个无关的局部帧，以及包含共享名称的单个全局帧中。每次调用函数时都会引入一个新的局部帧，即使是同一个函数被调用两次。

所有这些机制的存在都是为了确保名称在程序执行期间的正确时间解析为正确的值。这个例子说明了为什么我们之前介绍了“模型需要复杂性”。所有三个局部帧都包含名称 x 的绑定，但该名称会与不同帧中的不同值进行绑定，局部帧会将这些名称分开。

我们尝试分析一下上面的代码为什么会正确执行，没有冲突？

上图我们看到，这里定义了一个名为square且形式参数为square的函数。

所以，在我们调用square函数时并没有发生灾难，这时它查找这个函数，函数被命名为局部的框架块，然后再将参数-2绑定到名称square，它是形式参数。

重要的是，这一步的square在这个环境中意味着与过去不同的东西，现在它就是-2，因为我们做的第一件事就是在右侧下面带颜色的框中查找square，所以我们并没有在全局范围内查找square。