CH07_函数和Lambda表达式

本章目标

  • 掌握函数的定义与调用
  • 掌握值传递和引用传递的区别
  • 掌握位置参数、关键字参数、默认参数的使用
  • 掌握局部函数与闭包函数使用
  • 掌握lambda表达式的使用
  • 掌握内置函数eval()和exec()的使用

Python函数

概述

Python 中函数的应用非常广泛，前面章节中我们已经接触过多个函数，比如 input() 、print()、range()、len() 函数等等，这些都是 Python 的内置函数，可以直接使用。

除了可以直接使用的内置函数外，Python 还支持自定义函数，即将一段有规律的、可重复使用的代码定义成函数，从而达到一次编写、多次调用的目的。

其实，函数的本质就是一段有特定功能、可以重复使用的代码，这段代码已经被提前编写好了，并且为其起一个“好听”的名字。在后续编写程序过程中，如果需要同样的功能，直接通过起好的名字就可以调用这段代码。

下面演示了如何将我们自己实现的 len() 函数封装成一个函数： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#自定义 len() 函数
def my_len(str):
    length = 0
    for c in str:
       length = length + 1
    return length
#调用自定义的 my_len() 函数
length = my_len("http://c.biancheng.net/python/")
print(length)

#再次调用 my_len() 函数
length = my_len("http://c.biancheng.net/shell/")
print(length)

运行结果：

1
2
30
29

定义

定义函数，也就是创建一个函数，可以理解为创建一个具有某些用途的工具。定义函数需要用 def 关键字实现，具体的语法格式如下：

1
2
3
def 函数名(参数列表):
     //实现特定功能的多行代码
    [return [返回值]]

其中，用 [] 括起来的为可选择部分，即可以使用，也可以省略。

此格式中，各部分参数的含义如下：

  • 函数名：其实就是一个符合 Python 语法的标识符，但不建议读者使用 a、b、c 这类简单的标识符作为函数名，函数名最好能够体现出该函数的功能（如上面的 my_len，即表示我们自定义的 len() 函数）。
  • 形参列表：设置该函数可以接收多少个参数，多个参数之间用逗号（ , ）分隔。
  • [return [返回值] ]：整体作为函数的可选参参数，用于设置该函数的返回值。也就是说，一个函数，可以用返回值，也可以没有返回值，是否需要根据实际情况而定。
1
注意，在创建函数时，即使函数不需要参数，也必须保留一对空的“()”，否则 Python 解释器将提示“invaild syntax”错误。另外，如果想定义一个没有任何功能的空函数，可以使用 pass 语句作为占位符。

例如，下面定义了 2 个函数： 

1
2
3
4
5
6
7
8
9
#定义个空函数，没有实际意义
def pass_dis():
    pass
#定义一个比较字符串大小的函数
def str_max(str1,str2):
    str = str1 if str1 > str2 else str2
    return str


虽然 Python 语言允许定义个空函数，但空函数本身并没有实际意义。

另外值得一提的是，函数中的 return 语句可以直接返回一个表达式的值，例如修改上面的 str_max() 函数： 

1
2
def str_max(str1,str2):
    return str1 if str1 > str2 else str2

该函数的功能，和上面的 str_max() 函数是完全一样的，只是省略了创建 str 变量，因此函数代码更加简洁。

调用

调用函数也就是执行函数。如果把创建的函数理解为一个具有某种用途的工具，那么调用函数就相当于使用该工具。

函数调用的基本语法格式如下所示：

1
[返回值] = 函数名([形参值])

其中，函数名即指的是要调用的函数的名称；形参值指的是当初创建函数时要求传入的各个形参的值。如果该函数有返回值，我们可以通过一个变量来接收该值，当然也可以不接受。

需要注意的是，创建函数有多少个形参，那么调用时就需要传入多少个值，且顺序必须和创建函数时一致。即便该函数没有参数，函数名后的小括号也不能省略。

例如，我们可以调用上面创建的 pass_dis() 和 str_max() 函数： 

1
2
3
pass_dis()
strmax = str_max("http://www.baidu.com","http://www.jd.com");
print(strmax)

首先，对于调用空函数来说，由于函数本身并不包含任何有价值的执行代码，也没有返回值，应该调用空函数不会有任何效果。

其次，对于上面程序中调用 str_max() 函数，由于当初定义该函数为其设置了 2 个参数，因此这里在调用该参数，就必须传入 2 个参数。同时，由于该函数内部还使用了 return 语句，因此我们可以使用 strmax 变量来接收该函数的返回值。

因此，程序执行结果为：

1
http://www.jd.com

函数说明文档

前面章节讲过，通过调用 Python 的 help() 内置函数或者 doc 属性，我们可以查看某个函数的使用说明文档。事实上，无论是 Python 提供给我们的函数，还是自定义的函数，其说明文档都需要设计该函数的程序员自己编写。

其实，函数的说明文档，本质就是一段字符串，只不过作为说明文档，字符串的放置位置是有讲究的，函数的说明文档通常位于函数内部、所有代码的最前面。

以上面程序中的 str_max() 函数为例，下面演示了如何为其设置说明文档： 

1
2
3
4
5
6
7
8
9
10
#定义一个比较字符串大小的函数
def str_max(str1,str2):
    '''
    比较 2 个字符串的大小
    '''
    str = str1 if str1 > str2 else str2
    return str
help(str_max)
#print(str_max.__doc__)

运行结果：

1
2
3
4
Help on function str_max in module __main__:

 str_max(str1, str2)
     比较 2 个字符串的大小

上面程序中，还可以使用 doc 属性来获取 str_max() 函数的说明文档，即使用最后一行的输出语句，其输出结果为： 

1
比较 2 个字符串的大小

函数值传递和引用传递

概述

通常情况下，定义函数时都会选择有参数的函数形式，函数参数的作用是传递数据给函数，令其对接收的数据做具体的操作处理。

在使用函数时，经常会用到形式参数（简称“形参”）和实际参数（简称“实参”），二者都叫参数，之间的区别是：

  • 形式参数：在定义函数时，函数名后面括号中的参数就是形式参数，例如: 

    1
    2
    3
    #定义函数时，这里的函数参数 obj 就是形式参数
    def demo(obj):
        print(obj)

  • 实际参数：在调用函数时，函数名后面括号中的参数称为实际参数，也就是函数的调用者给函数的参数。例如: 

    1
    2
    3
    a = "note笔记网"
    #调用已经定义好的 demo 函数，此时传入的函数参数 a 就是实际参数
    demo(a)
1
实参和形参的区别，就如同剧本选主角，剧本中的角色相当于形参，而演角色的演员就相当于实参。

Python 中，根据实际参数的类型不同，函数参数的传递方式可分为 2 种，分别为值传递和引用（地址）传递：

  1. 值传递：适用于实参类型为不可变类型（字符串、数字、元组）；
  2. 引用（地址）传递：适用于实参类型为可变类型（列表，字典）；

值传递和引用传递的区别是，函数参数进行值传递后，若形参的值发生改变，不会影响实参的值；而函数参数继续引用传递后，改变形参的值，实参的值也会一同改变。

实例

例如，定义一个名为 demo 的函数，分别为传入一个字符串类型的变量（代表值传递）和列表类型的变量（代表引用传递）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def demo(obj) :
    obj += obj
    print("形参值为：",obj)
print("-------值传递-----")
a = "note笔记网"
print("a的值为：",a)
demo(a)
print("实参值为：",a)
print("-----引用传递-----")
a = [1,2,3]
print("a的值为：",a)
demo(a)
print("实参值为：",a)

运行结果：

1
2
3
4
5
6
7
8
-------值传递-----
a的值为： note笔记网
形参值为： note笔记网note笔记网
实参值为： note笔记网
-----引用传递-----
a的值为： [1, 2, 3]
形参值为： [1, 2, 3, 1, 2, 3]
实参值为： [1, 2, 3, 1, 2, 3]

分析运行结果不难看出，在执行值传递时，改变形式参数的值，实际参数并不会发生改变；而在进行引用传递时，改变形式参数的值，实际参数也会发生同样的改变。

位置参数

概述

位置参数，有时也称必备参数，指的是必须按照正确的顺序将实际参数传到函数中，换句话说，调用函数时传入实际参数的数量和位置都必须和定义函数时保持一致。

实参和形参数量必须一致
在调用函数，指定的实际参数的数量，必须和形式参数的数量一致（传多传少都不行），否则 Python 解释器会抛出 TypeError 异常，并提示缺少必要的位置参数。

实例

1
2
3
4
def girth(width , height):
    return 2 * (width + height)
#调用函数时，必须传递 2 个参数，否则会引发错误
print(girth(3))

运行结果：

1
2
3
4
Traceback (most recent call last):
   File "C:\Users\mengma\Desktop\1.py", line 4, in <module>
     print(girth(3))
 TypeError: girth() missing 1 required positional argument: 'height'

可以看到，抛出的异常类型为 TypeError，具体是指 girth() 函数缺少一个必要的 height 参数。

同样，多传参数也会抛出异常： 

1
2
3
4
def girth(width , height):
    return 2 * (width + height)
#调用函数时，必须传递 2 个参数，否则会引发错误
print(girth(3,2,4))

运行结果：

1
2
3
4
Traceback (most recent call last):
   File "C:\Users\mengma\Desktop\1.py", line 4, in <module>
     print(girth(3,2,4))
 TypeError: girth() takes 2 positional arguments but 3 were given

通过 TypeErroe 异常信息可以知道，girth() 函数本只需要 2 个参数，但是却传入了 3 个参数。

实参和形参位置必须一致
在调用函数时，传入实际参数的位置必须和形式参数位置一一对应，否则会产生以下 2 种结果：

  1. 抛出 TypeError 异常
    当实际参数类型和形式参数类型不一致，并且在函数种，这两种类型之间不能正常转换，此时就会抛出 TypeError 异常。

    1
    2
    3
    def area(height,width):
        return height*width/2
    print(area("note笔记网",3))

    输出结果：

    1
    2
    3
    4
    5
    6
    Traceback (most recent call last):
       File "C:\Users\mengma\Desktop\1.py", line 3, in <module>
         print(area("note笔记网",3))
       File "C:\Users\mengma\Desktop\1.py", line 2, in area
         return height*width/2
     TypeError: unsupported operand type(s) for /: 'str' and 'int'

    以上显示的异常信息，就是因为字符串类型和整形数值做除法运算。

  2. 产生的结果和预期不符
    调用函数时，如果指定的实际参数和形式参数的位置不一致，但它们的数据类型相同，那么程序将不会抛出异常，只不过导致运行结果和预期不符。

例如，设计一个求梯形面积的函数，并利用此函数求上底为 4cm，下底为 3cm，高为 5cm 的梯形的面积。但如果交互高和下低参数的传入位置，计算结果将导致错误： 

1
2
3
4
5
def area(upper_base,lower_bottom,height):
    return (upper_base+lower_bottom)*height/2
print("正确结果为：",area(4,3,5))
print("错误结果为：",area(4,5,3))

运行结果：

1
2
正确结果为： 17.5
错误结果为： 13.5

因此，在调用函数时，一定要确定好位置，否则很有可能产生类似示例中的这类错误，还不容易发现。

关键字参数

概述

​ 关键字参数是指使用形式参数的名字来确定输入的参数值。通过此方式指定函数实参时，不再需要与形参的位置完全一致，只要将参数名写正确即可。 

1
因此，Python 函数的参数名应该具有更好的语义，这样程序可以立刻明确传入函数的每个参数的含义。

实例

​ 例如，在下面的程序中就使用到了关键字参数的形式给函数传参： 

1
2
3
4
5
6
7
8
9
10
11
def dis_str(str1,str2):
    print("str1:",str1)
    print("str2:",str2)
    
#位置参数
dis_str("http://www.baidu.com","http://www.jd.com")

#关键字参数
dis_str("http://www.baidu.com",str2="http://www.jd.com")
dis_str(str2="http://www.jd.com",str1="http://www.baidu.com")

运行结果：

1
2
3
4
5
6
str1: http://www.baidu.com
str2: http://www.jd.com
str1: http://www.baidu.com
str2: http://www.jd.com
str1: http://www.baidu.com
str2: http://www.jd.com

可以看到，在调用有参函数时，既可以根据位置参数来调用，也可以使用关键字参数（程序中第 8 行）来调用。在使用关键字参数调用时，可以任意调换参数传参的位置。

默认参数

概述

我们知道，在调用函数时如果不指定某个参数，Python 解释器会抛出异常。为了解决这个问题，Python 允许为参数设置默认值，即在定义函数时，直接给形式参数指定一个默认值。这样的话，即便调用函数时没有给拥有默认值的形参传递参数，该参数可以直接使用定义函数时设置的默认值。

Python 定义带有默认值参数的函数，其语法格式如下： 

1
2
def 函数名(...，形参名，形参名=默认值)：
    代码块

注意，在使用此格式定义函数时，指定有默认值的形式参数必须在所有没默认值参数的最后，否则会产生语法错误。

实例

下面程序演示了如何定义和调用有默认参数的函数： 

1
2
3
4
5
6
7
8
#str1没有默认参数，str2有默认参数
def dis_str(str1,str2 = "http://www.jd.com"):
    print("str1:",str1)
    print("str2:",str2)

dis_str("http://www.baidu.com")
dis_str("http://www.baidu.com","http://www.taobao.com")

运行结果：

1
2
3
4
str1: http://www.baidu.com
str2: http://www.jd.com
str1: http://www.baidu.com
str2: http://www.taobao.com

上面程序中，dis_str() 函数有 2 个参数，其中第 2 个设有默认参数。这意味着，在调用 dis_str() 函数时，我们可以仅传入 1 个参数，此时该参数会传给 str1 参数，而 str2 会使用默认的参数，如程序中第 6 行代码所示。

当然在调用 dis_str() 函数时，也可以给所有的参数传值（如第 7 行代码所示），这时即便 str2 有默认值，它也会优先使用传递给它的新值。

同时，结合关键字参数，以下 3 种调用 dis_str() 函数的方式也是可以的： 

1
2
3
4
dis_str(str1 = "www.baidu.com")
dis_str("http://www.baidu.com",str2 = "http://www.jd.com")
dis_str(str1 = "http://www.baidu.com",str2 = "www.taobao.com")

Pyhton 中，可以使用“函数名.__defaults__”查看函数的默认值参数的当前值，其返回值是一个元组。以本节中的 dis_str() 函数为例，在其基础上，执行如下代码： 

1
print(dis_str.__defaults__)

运行结果：

1
('http://www.jd.com',)

Python None （空值）用法

在 Python 中，有一个特殊的常量 None（N 必须大写）。和 False 不同，它不表示 0，也不表示空字符串，而表示没有值，也就是空值。

这里的空值并不代表空对象，即 None 和 []、“” 不同： 

1
2
3
4
>>> None is []
 False
 >>> None is ""
 False

None 有自己的数据类型，我们可以在 IDLE 中使用 type() 函数查看它的类型，执行代码如下： 

1
2
>>> type(None)
<class 'NoneType'>

可以看到，它属于 NoneType 类型。

需要注意的是，None 是 NoneType 数据类型的唯一值（其他编程语言可能称这个值为 null、nil 或 undefined），也就是说，我们不能再创建其它 NoneType 类型的变量，但是可以将 None 赋值给任何变量。如果希望变量中存储的东西不与任何其它值混淆，就可以使用 None。

除此之外，None 常用于 assert、判断以及函数无返回值的情况。举个例子，在前面章节中我们一直使用 print() 函数输出数据，其实该函数的返回值就是 None。因为它的功能是在屏幕上显示文本，根本不需要返回任何值，所以 print() 就返回 None。

1
2
3
4
>>> spam = print('Hello!')
Hello!
>>> None == spam
True

另外，对于所有没有 return 语句的函数定义，Python 都会在末尾加上 return None，使用不带值的 return 语句（也就是只有 return 关键字本身），那么就返回 None。

return函数返回值

Python中，用 def 语句创建函数时，可以用 return 语句指定应该返回的值，该返回值可以是任意类型。需要注意的是，return 语句在同一函数中可以出现多次，但只要有一个得到执行，就会直接结束函数的执行。

函数中，使用 return 语句的语法格式如下： 

1
return [返回值]

其中，返回值参数可以指定，也可以省略不写（将返回空值 None）。

实例1：

1
2
3
4
5
6
7
8
9
def add(a,b):
    c = a + b
    return c
#函数赋值给变量
c = add(3,4)
print(c)
#函数返回值作为其他函数的实际参数
print(add(3,4))

运行结果：

1
2
7
7

本例中，add() 函数既可以用来计算两个数的和，也可以连接两个字符串，它会返回计算的结果。

通过 return 语句指定返回值后，我们在调用函数时，既可以将该函数赋值给一个变量，用变量保存函数的返回值，也可以将函数再作为某个函数的实际参数。

实例2：

1
2
3
4
5
6
7
8
def isGreater0(x):
    if x > 0:
        return True
    else:
        return False
print(isGreater0(5))
print(isGreater0(0))

运行结果：

1
2
True
False

可以看到，函数中可以同时包含多个 return 语句，但需要注意的是，最终真正执行的做多只有 1 个，且一旦执行，函数运行会立即结束。

局部函数

通过前面的学习我们知道，Python 函数内部可以定义变量，这样就产生了局部变量，有读者可能会问，Python 函数内部能定义函数吗？答案是肯定的。Python 支持在函数内部定义函数，此类函数又称为局部函数。

首先，和局部变量一样，默认情况下局部函数只能在其所在函数的作用域内使用。举个例子： 

1
2
3
4
5
6
7
8
9
10
#全局函数
def outdef ():
    #局部函数
    def indef():
        print("http://www.baidu.com")
    #调用局部函数
    indef()
#调用全局函数
outdef()

运行结果：

1
http://www.baidu.com

就如同全局函数返回其局部变量，就可以扩大该变量的作用域一样，通过将局部函数作为所在函数的返回值，也可以扩大局部函数的使用范围。例如，修改上面程序为： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#全局函数
def outdef ():
    #局部函数
    def indef():
        print("调用局部函数")
    #调用局部函数
    return indef

#调用全局函数
new_indef = outdef()

#调用全局函数中的局部函数
new_indef()

运行结果：

1
调用局部函数

因此，对于局部函数的作用域，可以总结为：如果所在函数没有返回局部函数，则局部函数的可用范围仅限于所在函数内部；反之，如果所在函数将局部函数作为返回值，则局部函数的作用域就会扩大，既可以在所在函数内部使用，也可以在所在函数的作用域中使用。

以上面程序中的 outdef() 和 indef() 为例，如果 outdef() 不将 indef 作为返回值，则 indef() 只能在 outdef() 函数内部使用；反之，则 indef() 函数既可以在 outdef() 函数内部使用，也可以在 outdef() 函数的作用域，也就是全局范围内使用。

另外值得一提的是，如果局部函数中定义有和所在函数中变量同名的变量，也会发生“遮蔽”的问题。例如：

1
2
3
4
5
6
7
8
9
10
11
12
#全局函数
def outdef ():
    name = "所在函数中定义的 name 变量"
    #局部函数
    def indef():
        print(name)
        name = "局部函数中定义的 name 变量"

    indef()
#调用全局函数
outdef()

执行此程序，Python 解释器会报如下错误： 

1
UnboundLocalError: local variable 'name' referenced before assignment

此错误直译过来的意思是“局部变量 name 还没定义就使用”。导致该错误的原因就在于，局部函数 indef() 中定义的 name 变量遮蔽了所在函数 outdef() 中定义的 name 变量。再加上，indef() 函数中 name 变量的定义位于 print() 输出语句之后，导致 print(name) 语句在执行时找不到定义的 name 变量，因此程序报错。

闭包函数

闭包，又称闭包函数或者闭合函数，其实和前面讲的嵌套函数类似，不同之处在于，闭包中外部函数返回的不是一个具体的值，而是一个函数。一般情况下，返回的函数会赋值给一个变量，这个变量可以在后面被继续执行调用。

例如，计算一个数的 n 次幂，用闭包可以写成下面的代码：

1
2
3
4
5
6
7
8
9
10
11
#闭包函数，其中 exponent 称为自由变量
def nth_power(exponent):
    def exponent_of(base):
        return base ** exponent
    return exponent_of # 返回值是 exponent_of 函数
square = nth_power(2) # 计算一个数的平方
cube = nth_power(3) # 计算一个数的立方

print(square(2))  # 计算 2 的平方
print(cube(2)) # 计算 2 的立方

运行结果：

1
2
4
8

在上面程序中，外部函数 nth_power() 的返回值是函数 exponent_of()，而不是一个具体的数值。

需要注意的是，在执行完 square = nth_power(2) 和 cube = nth_power(3) 后，外部函数 nth_power() 的参数 exponent 会和内部函数 exponent_of 一起赋值给 squre 和 cube，这样在之后调用 square(2) 或者 cube(2) 时，程序就能顺利地输出结果，而不会报错说参数 exponent 没有定义。

看到这里，读者可能会问，为什么要闭包呢？上面的程序，完全可以写成下面的形式：

1
2
def nth_power_rewrite(base, exponent):
    return base ** exponent

上面程序确实可以实现相同的功能，不过使用闭包，可以让程序变得更简洁易读。设想一下，比如需要计算很多个数的平方，那么读者觉得写成下面哪一种形式更好呢？ 

1
2
3
4
5
6
7
8
9
10
# 不使用闭包
res1 = nth_power_rewrite(base1, 2)
res2 = nth_power_rewrite(base2, 2)
res3 = nth_power_rewrite(base3, 2)
# 使用闭包
square = nth_power(2)
res1 = square(base1)
res2 = square(base2)
res3 = square(base3)

显然第二种方式表达更为简洁，在每次调用函数时，都可以少输入一个参数。

其次，和缩减嵌套函数的优点类似，函数开头需要做一些额外工作，当需要多次调用该函数时，如果将那些额外工作的代码放在外部函数，就可以减少多次调用导致的不必要开销，提高程序的运行效率。

闭包比普通的函数多了一个 closure 属性，该属性记录着自由变量的地址。当闭包被调用时，系统就会根据该地址找到对应的自由变量，完成整体的函数调用。

以 nth_power() 为例，当其被调用时，可以通过 closure 属性获取自由变量（也就是程序中的 exponent 参数）存储的地址，例如： 

1
2
3
4
5
6
7
8
def nth_power(exponent):
    def exponent_of(base):
        return base ** exponent
    return exponent_of
square = nth_power(2)
#查看 __closure__ 的值
print(square.__closure__)

运行结果：

1
(<cell at 0x0000014454DFA948: int object at 0x00000000513CC6D0>,)

可以看到，显示的内容是一个 int 整数类型，这就是 square 中自由变量 exponent 的初始值。还可以看到，closure 属性的类型是一个元组，这表明闭包可以支持多个自由变量的形式。

匿名函数(Lambda表达式)

对于定义一个简单的函数，Python 还提供了另外一种方法，即使用本节介绍的 lambda 表达式。

lambda 表达式，又称匿名函数，常用来表示内部仅包含 1 行表达式的函数。如果一个函数的函数体仅有 1 行表达式，则该函数就可以用 lambda 表达式来代替。

lambda 表达式的语法格式如下：

1
name = lambda [list] : 表达式

其中，定义 lambda 表达式，必须使用 lambda 关键字；[list] 作为可选参数，等同于定义函数是指定的参数列表；value 为该表达式的名称。

该语法格式转换成普通函数的形式，如下所示：

1
2
3
4
def name(list):
    return 表达式
name(list)

显然，使用普通方法定义此函数，需要 3 行代码，而使用 lambda 表达式仅需 1 行。

举个例子，如果设计一个求 2 个数之和的函数，使用普通函数的方式，定义如下： 

1
2
3
def add(x, y):
    return x+ y
print(add(3,4))

运行结果：

1
7

由于上面程序中，add() 函数内部仅有 1 行表达式，因此该函数可以直接用 lambda 表达式表示： 

1
2
add = lambda x,y:x+y
print(add(3,4))

运行结果：

1
7

可以这样理解 lambda 表达式，其就是简单函数（函数体仅是单行的表达式）的简写版本。相比函数，lamba 表达式具有以下  2 个优势：

  • 对于单行函数，使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁；
  • 对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高程序执行的性能。

eval()和exec()

eval() 和 exec() 函数的功能是相似的，都可以执行一个字符串形式的 Python 代码（代码以字符串的形式提供），相当于一个 Python 的解释器。二者不同之处在于，eval() 执行完要返回结果，而 exec() 执行完不返回结果。

eval()和exec()的用法

eval() 函数的语法格式为： 

1
eval(source, globals=None, locals=None, /)

而 exec() 函数的语法格式如下： 

1
exec(source, globals=None, locals=None, /)

可以看到，二者的语法格式除了函数名，其他都相同，其中各个参数的具体含义如下：

  • expression：这个参数是一个字符串，代表要执行的语句 。该语句受后面两个字典类型参数 globals 和 locals 的限制，只有在 globals 字典和 locals 字典作用域内的函数和变量才能被执行。
  • globals：这个参数管控的是一个全局的命名空间，即 expression 可以使用全局命名空间中的函数。如果只是提供了 globals 参数，而没有提供自定义的 __builtins__，则系统会将当前环境中的 builtins 复制到自己提供的 globals 中，然后才会进行计算；如果连 globals 这个参数都没有被提供，则使用 Python 的全局命名空间。
  • locals：这个参数管控的是一个局部的命名空间，和 globals 类似，当它和 globals 中有重复或冲突时，以 locals 的为准。如果 locals 没有被提供，则默认为 globals。

注意，builtins 是 Python 的内建模块，平时使用的 int、str、abs 都在这个模块中。通过 print(dic[“builtins“]) 语句可以查看 builtins 所对应的 value。

首先，通过如下的例子来演示参数 globals 作用域的作用，注意观察它是何时将 builtins 复制 globals 字典中去的： 

1
2
3
4
5
6
dic={} #定义一个字
dic['b'] = 3 #在 dic 中加一条元素，key 为 b
print (dic.keys()) #先将 dic 的 key 打印出来，有一个元素 b
exec("a = 4", dic) #在 exec 执行的语句后面跟一个作用域 dic
print(dic.keys()) #exec 后，dic 的 key 多了一个

运行结果：

1
2
dict_keys(['b'])
dict_keys(['b', '__builtins__', 'a'])

上面的代码是在作用域 dic 下执行了一句 a = 4 的代码。可以看出，exec() 之前 dic 中的 key 只有一个 b。执行完 exec() 之后，系统在 dic 中生成了两个新的 key，分别是 a 和 builtins__。其中，a 为执行语句生成的变量，系统将其放到指定的作用域字典里；__builtins 是系统加入的内置 key。

locals参数的用法就很简单了，举个例子： 

1
2
3
4
5
6
a=10
b=20
c=30
g={'a':6, 'b':8} #定义一个字典
t={'b':100, 'c':10} #定义一个字典
print(eval('a+b+c', g, t)) #定义一个字典 116

运行结果：

1
116

eval()和exec()的区别

前面已经讲过，它们的区别在于，eval() 执行完会返回结果，而 exec() 执行完不返回结果。举个例子： 

1
2
3
4
5
6
7
a = 1
exec("a = 2") #相当于直接执行 a=2
print(a)
a = exec("2+3") #相当于直接执行 2+3，但是并没有返回值，a 应为 None
print(a)
a = eval('2+3') #执行 2+3，并把结果返回给 a
print(a)

运行结果：

1
2
3
2
None
5

可以看出，exec() 中最适合放置运行后没有结果的语句，而 eval() 中适合放置有结果返回的语句。

如果 eval() 里放置一个没有结果返回的语句会怎样呢？例如下面代码： 

1
a= eval("a = 2")

这时 Python 解释器会报 SyntaxError 错误，提示 eval() 中不识别等号语法。

eval()和exec()函数的应用场景

在使用 Python 开发服务端程序时，这两个函数应用得非常广泛。例如，客户端向服务端发送一段字符串代码，服务端无需关心具体的内容，直接跳过 eval() 或 exec() 来执行，这样的设计会使服务端与客户端的耦合度更低，系统更易扩展。

另外，如果读者以后接触 TensorFlow 框架，就会发现该框架中的静态图就是类似这个原理实现的：

  • TensorFlow 中先将张量定义在一个静态图里，这就相当将键值对添加到字典里一样；
  • TensorFlow 中通过 session 和张量的 eval() 函数来进行具体值的运算，就当于使用 eval() 函数进行具体值的运算一样。

需要注意的是，在使用 eval() 或是 exec() 来处理请求代码时，函数 eval() 和 exec() 常常会被黑客利用，成为可以执行系统级命令的入口点，进而来攻击网站。解决方法是：通过设置其命名空间里的可执行函数，来限制 eval() 和 exec() 的执行范围。

课后作业

1.略