8.5. locals 和 globals
Description: Python from novice to pro
Keywords: Python, Dive Into Python, tutorial, object-oriented, programming, documentation, book, free

# 深入 Python :Dive Into Python 中文版 Python 从新手到专家 [Dip_5.4b_CPyUG_Release] | Find:

## 8.5. `locals` 和 `globals`

我们先偏离一下 HTML 处理的主题，讨论一下 Python 如何处理变量。Python 有两个内置的函数，`locals` 和 `globals`，它们提供了基于 dictionary 的访问局部和全局变量的方式。

还记得 `locals` 吗？您第一次是在这里看到的：

        def unknown_starttag(self, tag, attrs):
            strattrs = "".join([' %s="%s"' % (key, value) for key, value in attrs])
            self.pieces.append("<%(tag)s%(strattrs)s>" % locals())

不，等等，此时您还不能理解 `locals` 。首先，您需要学习关于命名空间的知识。这很枯燥，但是很重要，因此要要耐心些。

Python 使用叫做名字空间的东西来记录变量的轨迹。名字空间只是一个 dictionary ，它的键字就是变量名，它的值就是那些变量的值。实际上，名字空间可以像 Python 的 dictionary 一样进行访问，一会儿我们就会看到。

在一个 Python 程序中的任何一个地方，都存在几个可用的名字空间。每个函数都有着自已的名字空间，叫做局部名字空间，它记录了函数的变量，包括函数的参数和局部定义的变量。每个模块拥有它自已的名字空间，叫做全局名字空间，它记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。还有就是内置名字空间，任何模块均可访问它，它存放着内置的函数和异常。

当一行代码要使用变量 `x` 的值时，Python 会到所有可用的名字空间去查找变量，按照如下顺序：

1. 局部名字空间――特指当前函数或类的方法。如果函数定义了一个局部变量 `x`，或一个参数 `x`，Python 将使用它，然后停止搜索。
2. 全局名字空间――特指当前的模块。如果模块定义了一个名为 `x` 的变量，函数或类，Python 将使用它然后停止搜索。
3. 内置名字空间――对每个模块都是全局的。作为最后的尝试，Python 将假设 `x` 是内置函数或变量。

如果 Python 在这些名字空间找不到 `x`，它将放弃查找并引发一个 `NameError` 异常，同时传递 `There is no variable named 'x'` 这样一条信息，回到 例 3.18 “引用未赋值的变量”，您会看到一路上都有这样的信息。但是您并没有体会到 Python 在给出这样的错误之前做了多少的努力。

Python 2.2 引入了一种略有不同但重要的改变，它会影响名字空间的搜索顺序：嵌套的作用域。 在 Python 2.2 版本之前，当您在一个嵌套函数或 `lambda` 函数中引用一个变量时，Python 会在当前 (嵌套的或 `lambda`) 函数的名字空间中搜索，然后在模块的名字空间。Python 2.2 将只在当前 (嵌套的或 `lambda`) 函数的名字空间中搜索，然后是在父函数的名字空间 中搜索，接着是模块的名字空间中搜索。Python 2.1 可 以两种方式工作，缺省地，按 Python 2.0 的方式工作。但是您可以把下面一行代码增加到您的模块头部，使您的模块工作起来像 Python 2.2 的方式：
    from __future__ import nested_scopes

您是否为此而感到困惑？不要灰心！我敢说这一点非常酷。像 Python 中的许多事情一样，名字空间在运行时直接可以访问。怎么样？不错吧，局部名字空间可以通过内置的 `locals` 函数来访问。全局 (模块级别) 名字空间可以通过内置的 `globals` 函数来访问。

### 例 8.10. `locals` 介绍

    >>> def foo(arg):
    ...     x = 1
    ...     print locals()
    ...
    >>> foo(7)
    {'arg': 7, 'x': 1}
    >>> foo('bar')
    {'arg': 'bar', 'x': 1}

| 函数 `foo` 在它的局部名字空间中有两个变量：`arg` (它的值是被传入函数的) 和 `x` (它是在函数里定义的)。
| `locals` 返回一个名字/值对的 dictionary。这个 dictionary 的键字是字符串形式的变量名字，dictionary 的值是变量的实际值。所以用 `7` 来调用 `foo`，会打印出包含函数两个局部变量的 dictionary：`arg` (`7`) 和 `x` (`1`)。
| 回想一下，Python 有动态数据类型，所以您可以非常容易地传递给 `arg` 一个字符串，这个函数 (和对 `locals` 的调用) 将仍然很好的工作。`locals` 可以用于所有类型的变量。

`locals` 对局部 (函数) 名字空间做了些什么，`globals` 就对全局 (模块) 名字空间做了什么。然而 `globals` 更令人兴奋，因为一个模块的名字空间是更令人兴奋的。[6] 模块的名字空间不仅仅包含了模块级的变量和常量，还包括了所有在模块中定义的函数和类。除此以外，它还包括了任何被导入到模块中的东西。

回想一下 `from module import` 和 `import module` 之间的不同。使用 `import module`，模块自身被导入，但是它保持着自已的名字空间，这就是为什么您需要使用模块名来访问它的函数或属性：`module.function` 的原因。但是使用 `from module import`，实际上是从另一个模块中将指定的函数和属性导入到您自己的名字空间，这就是为什么您可以直接访问它们却不需要引用它们所来源的模块。使用 `globals` 函数，您会真切地看到这一切的发生。

### 例 8.11. `globals` 介绍

看看下面列出的在文件 `BaseHTMLProcessor.py` 尾部的代码块：

    if __name__ == "__main__":
        for k, v in globals().items():
            print k, "=", v

| 不要被吓坏了，想想以前您已经全部都看到过了。`globals` 函数返回一个 dictionary，我们使用 `items` 方法和多变量赋值来遍历 dictionary。在这里唯一的新东西就是 `globals` 函数。

现在从命令行运行这个脚本，会得到下面的输出 (注意您的输出可能有略微的不同，这依赖于您的系统平台和所安装的 Python 版本)：

    c:\docbook\dip\py> python BaseHTMLProcessor.py

    SGMLParser = sgmllib.SGMLParser
    htmlentitydefs = <module 'htmlentitydefs' from 'C:\Python23\lib\htmlentitydefs.py'>
    BaseHTMLProcessor = __main__.BaseHTMLProcessor
    __name__ = __main__
    ... rest of output omitted for brevity...

| 我们使用了 `from module import` 把 `SGMLParser` 从 `sgmllib` 中导入。也就是说它被直接导入到我们的模块名字空间了，就是这样。
| 把上面的例子和 `htmlentitydefs` 对比一下，它是用 `import` 被导入的。也就是说 `htmlentitydefs` 模块本身被导入了名字空间，但是定义在 `htmlentitydefs` 之中的 `entitydefs` 变量却没有。
| 这个模块只定义一个类，`BaseHTMLProcessor`，不错。注意这儿的值就是类本身，不是一个特别的类实例。
| 记得 `if __name__` 技巧吗？当运行一个模块时 (相对于从另外一个模块中导入而言)，内置的 `__name__` 是一个特殊值 `__main__`。因为我们是把这个模块当作脚本从命令来运行的，故 `__name__` 值为 `__main__`，这就是为什么我们这段简单地打印 `globals` 的代码可以执行的原因。

使用 `locals` 和 `globals` 函数，通过提供变量的字符串名字您可以动态地得到任何变量的值。这种方法提供了这样的功能：`getattr` 函数允许您通过提供函数的字符串名来动态地访问任意的函数。

在 `locals` 与 `globals` 之间有另外一个重要的区别，您应该在它困扰您之前就了解它。它无论如何都会困扰您的，但至少您还会记得曾经学习过它。

### 例 8.12. `locals` 是只读的，`globals` 不是

    def foo(arg):
        x = 1
        print locals()
        locals()["x"] = 2
        print "x=",x

    z = 7
    print "z=",z
    foo(3)
    globals()["z"] = 8
    print "z=",z

| 因为使用 `3` 来调用 `foo`，会打印出 `{'arg': 3, 'x': 1}`。这个应该没什么奇怪的。
| `locals` 是一个返回 dictionary 的函数，这里您在 dictionary 中设置了一个值。您可能认为这样会改变局部变量 `x` 的值为 `2`，但并不会。`locals` 实际上没有返回局部名字空间，它返回的是一个拷贝。所以对它进行改变对局部名字空间中的变量值并无影响。
| 这样会打印出 `x= 1`，而不是 `x= 2`。
| 在有了对 `locals` 的经验之后，您可能认为这样不会 改变 `z` 的值，但是可以。由于 Python 在实现过程中内部有所区别 (关于这些区别我宁可不去研究，因为我自已还没有完全理解) ，`globals` 返回实际的全局名字空间，而不是一个拷贝：与 `locals` 的行为完全相反。所以对 `globals` 所返回的 dictionary 的任何的改动都会直接影响到全局变量。
| 这样会打印出 `z= 8`，而不是 `z= 7`。

### Footnotes

[6] 我没有说得太多吧。