9. 类
*****

和其他编程语言相比，Python 用非常少的新语法和语义将类加入到语言中。它
是 C++ 和 Modula-3 中类机制的结合。Python 的类提供了面向对象编程的所有
标准特性：类继承机制允许多个基类，派生类可以覆盖它基类的任何方法，一个
方法可以调用基类中相同名称的的方法。对象可以包含任意数量和类型的数据。
和模块一样，类也拥有 Python 天然的动态特性：它们在运行时创建，可以在创
建后修改。

在C++术语中，通常类成员（包括数据成员）是 *public* （除了见下文
Private Variables and Class-local References ），所有成员函数都是
*virtual* 。与在Modula-3中一样，没有用于从其方法引用对象成员的简写：方
法函数使用表示对象的显式第一个参数声明，该参数由调用隐式提供。与
Smalltalk一样，类本身也是对象。这为导入和重命名提供了语义。与C++和
Modula-3不同，内置类型可以用作用户扩展的基类。此外，与C++一样，大多数
具有特殊语法（算术运算符，下标等）的内置运算符都可以重新定义为类实例。

(Lacking universally accepted terminology to talk about classes, I
will make occasional use of Smalltalk and C++ terms.  I would use
Modula-3 terms, since its object-oriented semantics are closer to
those of Python than C++, but I expect that few readers have heard of
it.)


9.1. 名称和对象
===============

对象具有个性，多个名称（在多个作用域内）可以绑定到同一个对象。这在其他
语言中称为别名。乍一看Python时通常不会理解这一点，在处理不可变的基本类
型（数字，字符串，元组）时可以安全地忽略它。但是，别名对涉及可变对象，
如列表，字典和大多数其他类型，的Python代码的语义可能会产生惊人的影响。
这通常用于程序的好处，因为别名在某些方面表现得像指针。例如，传递一个对
象很便宜，因为实现只传递一个指针；如果函数修改了作为参数传递的对象，调
用者将看到更改 — 这就不需要像 Pascal 中那样使用两个不同的参数传递机制
。


9.2. Python 作用域和命名空间
============================

在介绍类之前，我首先要告诉你一些Python的作用域规则。类定义对命名空间有
一些巧妙的技巧，你需要知道作用域和命名空间如何工作才能完全理解正在发生
的事情。顺便说一下，关于这个主题的知识对任何高级Python程序员都很有用。

让我们从一些定义开始。

*namespace* 是一个从名字到对象的映射。大部分命名空间当前都由 Python 字
典实现，但一般情况下基本不会去关注它们（除了要面对性能问题时），而且也
有可能在将来更改。下面是几个命名空间的例子：存放内置函数的集合（包含
"abs()" 这样的函数，和内建的异常等）；模块中的全局名称；函数调用中的本
地名称。从某种意义上说，对象的的属性集合也是一种命名空间的形式。关于命
名空间的重要一点是，不同命名空间中的名称之间绝对没有关系；例如，两个不
同的模块都可以定义函数“最大化”而不会产生混淆 - 模块的用户必须在其前面
加上模块名称。

顺便说明一下，我把任何跟在一个点号之后的名称都称为 *属性* — 例如，在表
达式 "z.real" 中，"real" 是对象 "z" 的一个属性。按严格的说法，对模块中
名称的引用属于属性引用：在表达式 "modname.funcname" 中，"modname" 是一
个模块对象而 "funcname" 是它的一个属性。在此情况下在模块的属性和模块中
定义的全局名称之间正好存在一个直观的映射：它们共享相同的命名空间！ [1]

属性可以是只读或者可写的。如果为后者，那么对属性的赋值是可行的。模块属
性是可以写，你可以写出 "modname.the_answer = 42" 。可写的属性同样可以
用 "del" 语句删除。例如，"del modname.the_answer" 将会从名为
"modname" 的对象中移除 "the_answer" 属性。

Namespaces are created at different moments and have different
lifetimes.  The namespace containing the built-in names is created
when the Python interpreter starts up, and is never deleted.  The
global namespace for a module is created when the module definition is
read in; normally, module namespaces also last until the interpreter
quits.  The statements executed by the top-level invocation of the
interpreter, either read from a script file or interactively, are
considered part of a module called "__main__", so they have their own
global namespace.  (The built-in names actually also live in a module;
this is called "__builtin__".)

一个函数的本地命名空间在这个函数被调用时创建，并在函数返回或抛出一个不
在函数内部处理的错误时被删除。（事实上，比起描述到底发生了什么，忘掉它
更好。）当然，每次递归调用都会有它自己的本地命名空间。

一个 *作用域* 是一个命名空间可直接访问的 Python 程序的文本区域。 这里
的 “可直接访问” 意味着对名称的非限定引用会尝试在命名空间中查找名称。

Although scopes are determined statically, they are used dynamically.
At any time during execution, there are at least three nested scopes
whose namespaces are directly accessible:

* 最先搜索的最内部作用域包含局部名称

* 从最近的封闭作用域开始搜索的任何封闭函数的范围包含非局部名称，也包
  括 非全局名称

* 倒数第二个作用域包含当前模块的全局名称

* 最外面的范围（最后搜索）是包含内置名称的命名空间

If a name is declared global, then all references and assignments go
directly to the middle scope containing the module’s global names.
Otherwise, all variables found outside of the innermost scope are
read-only (an attempt to write to such a variable will simply create a
*new* local variable in the innermost scope, leaving the identically
named outer variable unchanged).

通常，当前局部作为域将（按字面文本）引用当前函数的局部名称。 在函数以
外，局部作用域将引用与全局作用域相一致的命名空间：模块的命名空间。 类
定义将在局部命名空间内再放置另一个命名空间。

重要的是应该意识到作用域是按字面文本来确定的：在一个模块内定义的函数的
全局作用域就是该模块的命名空间，无论该函数从什么地方或以什么别名被调用
。 另一方面，实际的名称搜索是在运行时动态完成的 — 但是，语言定义在 *编
译时* 是朝着静态名称解析的方向演化的，因此不要过于依赖动态名称解析！
（事实上，局部变量已经是被静态确定了。）

A special quirk of Python is that – if no "global" statement is in
effect – assignments to names always go into the innermost scope.
Assignments do not copy data — they just bind names to objects.  The
same is true for deletions: the statement "del x" removes the binding
of "x" from the namespace referenced by the local scope.  In fact, all
operations that introduce new names use the local scope: in
particular, "import" statements and function definitions bind the
module or function name in the local scope.  (The "global" statement
can be used to indicate that particular variables live in the global
scope.)


9.3. 初探类
===========

类引入了一些新语法，三种新对象类型和一些新语义。


9.3.1. 类定义语法
-----------------

最简单的类定义看起来像这样:

   class ClassName:
       <statement-1>
       .
       .
       .
       <statement-N>

类定义与函数定义 ("def" 语句) 一样必须被执行才会起作用。 （你可以尝试
将类定义放在 "if" 语句的一个分支或是函数的内部。）

在实践中，类定义内的语句通常都是函数定义，但也允许有其他语句，有时还很
有用 — 我们会稍后再回来说明这个问题。 在类内部的函数定义通常具有一种特
别形式的参数列表，这是方法调用的约定规范所指明的 — 这个问题也将在稍后
再说明。

当进入类定义时，将创建一个新的命名空间，并将其用作局部作用域 — 因此，
所有对局部变量的赋值都是在这个新命名空间之内。 特别的，函数定义会绑定
到这里的新函数名称。

当（从结尾处）正常离开类定义时，将创建一个 *类对象*。 这基本上是一个包
围在类定义所创建命名空间内容周围的包装器；我们将在下一节了解有关类对象
的更多信息。 原始的（在进入类定义之前起作用的）局部作用域将重新生效，
类对象将在这里被绑定到类定义头所给出的类名称 (在这个示例中为
"ClassName")。


9.3.2. 类对象
-------------

类对象支持两种操作：属性引用和实例化。

*属性引用* 使用 Python 中所有属性引用所使用的标准语法: "obj.name"。 有
效的属性名称是类对象被创建时存在于类命名空间中的所有名称。 因此，如果
类定义是这样的:

   class MyClass:
       """A simple example class"""
       i = 12345

       def f(self):
           return 'hello world'

那么 "MyClass.i" 和 "MyClass.f" 就是有效的属性引用，将分别返回一个整数
和一个函数对象。 类属性也可以被赋值，因此可以通过赋值来更改
"MyClass.i" 的值。 "__doc__" 也是一个有效的属性，将返回所属类的文档字
符串: ""A simple example class""。

类的 *实例化* 是使用函数表示法。 可以相像类对象就是会返回一个新的类实
例的不带参数的函数。 举例来说（假设使用上述的类）:

   x = MyClass()

创建类的新 *实例* 并将此对象分配给局部变量 "x"。

实例化操作（“调用”类对象）会创建一个空对象。 许多类喜欢创建带有特定初
始状态的自定义实例。 为此类定义可能包含一个名为 "__init__()" 的特殊方
法，就像这样:

   def __init__(self):
       self.data = []

当一个类定义了 "__init__()" 方法时，类的实例化操作会自动为新创建的类实
例发起调用 "__init__()"。 因此在这个示例中，可以通过以下语句获得一个经
初始化的新实例:

   x = MyClass()

当然，"__init__()" 方法还可以有额外参数以实现更高灵活性。 在这种情况下
，提供给类实例化运算符的参数将被传递给 "__init__()"。 例如，:

   >>> class Complex:
   ...     def __init__(self, realpart, imagpart):
   ...         self.r = realpart
   ...         self.i = imagpart
   ...
   >>> x = Complex(3.0, -4.5)
   >>> x.r, x.i
   (3.0, -4.5)


9.3.3. 实例对象
---------------

现在我们可以用实例对象做什么？实例对象理解的唯一操作是属性引用。有两种
有效的属性名称，数据属性和方法。

*数据属性* 对应于 Smalltalk 中的“实例变量”，以及 C++ 中的“数据成员”。
数据属性不需要声明；像局部变量一样，它们将在第一次被赋值时产生。 例如
，如果 "x" 是上面创建的 "MyClass" 的实例，则以下代码段将打印数值 "16"
，且不保留任何追踪信息:

   x.counter = 1
   while x.counter < 10:
       x.counter = x.counter * 2
   print x.counter
   del x.counter

另一类实例属性引用称为 *方法*。 方法是“从属于”对象的函数。 （在 Python
中，方法这个术语并不是类实例所特有的：其他对方也可以有方法。 例如，列
表对象具有 append, insert, remove, sort 等方法。 然而，在以下讨论中，
我们使用方法一词将专指类实例对象的方法，除非另外显式地说明。）

实例对象的有效方法名称依赖于其所属的类。 根据定义，一个类中所有是函数
对象的属性都是定义了其实例的相应方法。 因此在我们的示例中，"x.f" 是有
效的方法引用，因为 "MyClass.f" 是一个函数，而 "x.i" 不是方法，因为
"MyClass.i" 不是一个函数。 但是 "x.f" 与 "MyClass.f" 并不是一回事 — 它
是一个 *方法对象*，不是函数对象。


9.3.4. 方法对象
---------------

通常，方法在绑定后立即被调用:

   x.f()

在 "MyClass" 示例中，这将返回字符串 "'hello world'"。 但是，立即调用一
个方法并不是必须的: "x.f" 是一个方法对象，它可以被保存起来以后再调用。
例如:

   xf = x.f
   while True:
       print xf()

将继续打印 "hello world"，直到结束。

当一个方法被调用时到底发生了什么？ 你可能已经注意到上面调用 "x.f()" 时
并没有带参数，虽然 "f()" 的函数定义指定了一个参数。 这个参数发生了什么
事？ 当不带参数地调用一个需要参数的函数时 Python 肯定会引发异常 — 即使
参数实际未被使用…

Actually, you may have guessed the answer: the special thing about
methods is that the object is passed as the first argument of the
function.  In our example, the call "x.f()" is exactly equivalent to
"MyClass.f(x)".  In general, calling a method with a list of *n*
arguments is equivalent to calling the corresponding function with an
argument list that is created by inserting the method’s object before
the first argument.

如果你仍然无法理解方法的运作原理，那么查看实现细节可能会澄清问题。 当
一个实例的非数据属性被引用时，将搜索实例所属的类。 如果名称表示一个属
于函数对象的有效类属性，会通过合并打包（指向）实例对象和函数对象到一个
抽象对象中的方式来创建一个方法对象：这个抽象对象就是方法对象。 当附带
参数列表调用方法对象时，将基于实例对象和参数列表构建一个新的参数列表，
并使用这个新参数列表调用相应的函数对象。


9.3.5. 类和实例变量
-------------------

一般来说，实例变量用于每个实例的唯一数据，而类变量用于类的所有实例共享
的属性和方法:

   class Dog:

       kind = 'canine'         # class variable shared by all instances

       def __init__(self, name):
           self.name = name    # instance variable unique to each instance

   >>> d = Dog('Fido')
   >>> e = Dog('Buddy')
   >>> d.kind                  # shared by all dogs
   'canine'
   >>> e.kind                  # shared by all dogs
   'canine'
   >>> d.name                  # unique to d
   'Fido'
   >>> e.name                  # unique to e
   'Buddy'

正如 名称和对象 中已讨论过的，共享数据可能在涉及 *mutable* 对象例如列
表和字典的时候导致令人惊讶的结果。 例如以下代码中的 *tricks* 列表不应
该被用作类变量，因为所有的 *Dog* 实例将只共享一个单独的列表:

   class Dog:

       tricks = []             # mistaken use of a class variable

       def __init__(self, name):
           self.name = name

       def add_trick(self, trick):
           self.tricks.append(trick)

   >>> d = Dog('Fido')
   >>> e = Dog('Buddy')
   >>> d.add_trick('roll over')
   >>> e.add_trick('play dead')
   >>> d.tricks                # unexpectedly shared by all dogs
   ['roll over', 'play dead']

正确的类设计应该使用实例变量:

   class Dog:

       def __init__(self, name):
           self.name = name
           self.tricks = []    # creates a new empty list for each dog

       def add_trick(self, trick):
           self.tricks.append(trick)

   >>> d = Dog('Fido')
   >>> e = Dog('Buddy')
   >>> d.add_trick('roll over')
   >>> e.add_trick('play dead')
   >>> d.tricks
   ['roll over']
   >>> e.tricks
   ['play dead']


9.4. 补充说明
=============

数据属性会覆盖掉具有相同名称的方法属性；为了避免会在大型程序中导致难以
发现的错误的意外名称冲突，明智的做法是使用某种约定来最小化冲突的发生几
率。 可能的约定包括方法名称使用大写字母，属性名称加上独特的短字符串前
缀（或许只加一个下划线），或者是用动词来命名方法，而用名词来命名数据属
性。

数据属性可以被方法以及一个对象的普通用户（“客户端”）所引用。 换句话说
，类不能用于实现纯抽象数据类型。 实际上，在 Python 中没有任何东西能强
制隐藏数据 — 它是完全基于约定的。 （而在另一方面，用 C 语言编写的
Python 实现则可以完全隐藏实现细节，并在必要时控制对象的访问；此特性可
以通过用 C 编写 Python 扩展来使用。）

客户端应当谨慎地使用数据属性 — 客户端可能通过直接操作数据属性的方式破
坏由方法所维护的固定变量。 请注意客户端可以向一个实例对象添加他们自己
的数据属性而不会影响方法的可用性，只要保证避免名称冲突 — 再次提醒，在
此使用命名约定可以省去许多令人头痛的麻烦。

在方法内部引用数据属性（或其他方法！）并没有简便方式。 我发现这实际上
提升了方法的可读性：当浏览一个方法代码时，不会存在混淆局部变量和实例变
量的机会。

方法的第一个参数常常被命名为 "self"。 这也不过就是一个约定: "self" 这
一名称在 Python 中绝对没有特殊含义。 但是要注意，不遵循此约定会使得你
的代码对其他 Python 程序员来说缺乏可读性，而且也可以想像一个 *类浏览器
* 程序的编写可能会依赖于这样的约定。

任何一个作为类属性的函数都为该类的实例定义了一个相应方法。 函数定义的
文本并非必须包含于类定义之内：将一个函数对象赋值给一个局部变量也是可以
的。 例如:

   # Function defined outside the class
   def f1(self, x, y):
       return min(x, x+y)

   class C:
       f = f1

       def g(self):
           return 'hello world'

       h = g

现在 "f", "g" 和 "h" 都是 "C" 类的引用函数对象的属性，因而它们就都是
"C" 的实例的方法 — 其中 "h" 完全等同于 "g"。 但请注意，本示例的做法通
常只会令程序的阅读者感到迷惑。

方法可以通过使用 "self" 参数的方法属性调用其他方法:

   class Bag:
       def __init__(self):
           self.data = []

       def add(self, x):
           self.data.append(x)

       def addtwice(self, x):
           self.add(x)
           self.add(x)

方法可以通过与普通函数相同的方式引用全局名称。 与方法相关联的全局作用
域就是包含其定义的模块。 （类永远不会被作为全局作用域。） 虽然我们很少
会有充分的理由在方法中使用全局作用域，但全局作用域存在许多合法的使用场
景：举个例子，导入到全局作用域的函数和模块可以被方法所使用，在其中定义
的函数和类也一样。 通常，包含该方法的类本身是在全局作用域中定义的，而
在下一节中我们将会发现为何方法需要引用其所属类的很好的理由。

每个值都是一个对象，因此具有 *class* （也称为 *type*）。它存储在
"object .__ class__"。


9.5. 继承
=========

当然，如果不支持继承，语言特性就不值得称为“类”。派生类定义的语法如下所
示:

   class DerivedClassName(BaseClassName):
       <statement-1>
       .
       .
       .
       <statement-N>

名称 "BaseClassName" 必须定义于包含派生类定义的作用域中。 也允许用其他
任意表达式代替基类名称所在的位置。 这有时也可能会用得上，例如，当基类
定义在另一个模块中的时候:

   class DerivedClassName(modname.BaseClassName):

派生类定义的执行过程与基类相同。 当构造类对象时，基类会被记住。 此信息
将被用来解析属性引用：如果请求的属性在类中找不到，搜索将转往基类中进行
查找。 如果基类本身也派生自其他某个类，则此规则将被递归地应用。

派生类的实例化没有任何特殊之处: "DerivedClassName()" 会创建该类的一个
新实例。 方法引用将按以下方式解析：搜索相应的类属性，如有必要将按基类
继承链逐步向下查找，如果产生了一个函数对象则方法引用就生效。

派生类可能会重载其基类的方法。 因为方法在调用同一对象的其他方法时没有
特殊权限，调用同一基类中定义的另一方法的基类方法最终可能会调用覆盖它的
派生类的方法。 （对 C++ 程序员的提示：Python 中所有的方法实际上都是
"virtual" 方法。）

在派生类中的重载方法实际上可能想要扩展而非简单地替换同名的基类方法。
有一种方式可以简单地直接调用基类方法：即调用
"BaseClassName.methodname(self, arguments)"。 有时这对客户端来说也是有
用的。 （请注意仅当此基类可在全局作用域中以 "BaseClassName" 的名称被访
问时方可使用此方式。）

Python有两个内置函数可被用于继承机制：

* 使用 "isinstance()" 来检查一个实例的类型: "isinstance(obj, int)"
  仅 会在 "obj.__class__" 为 "int" 或某个派生自 "int" 的类时为 "True"
  。

* Use "issubclass()" to check class inheritance: "issubclass(bool,
  int)" is "True" since "bool" is a subclass of "int".  However,
  "issubclass(unicode, str)" is "False" since "unicode" is not a
  subclass of "str" (they only share a common ancestor, "basestring").


9.5.1. 多重继承
---------------

Python supports a limited form of multiple inheritance as well.  A
class definition with multiple base classes looks like this:

   class DerivedClassName(Base1, Base2, Base3):
       <statement-1>
       .
       .
       .
       <statement-N>

For old-style classes, the only rule is depth-first, left-to-right.
Thus, if an attribute is not found in "DerivedClassName", it is
searched in "Base1", then (recursively) in the base classes of
"Base1", and only if it is not found there, it is searched in "Base2",
and so on.

(To some people breadth first — searching "Base2" and "Base3" before
the base classes of "Base1" — looks more natural.  However, this would
require you to know whether a particular attribute of "Base1" is
actually defined in "Base1" or in one of its base classes before you
can figure out the consequences of a name conflict with an attribute
of "Base2".  The depth-first rule makes no differences between direct
and inherited attributes of "Base1".)

For *new-style class*es, the method resolution order changes
dynamically to support cooperative calls to "super()".  This approach
is known in some other multiple-inheritance languages as call-next-
method and is more powerful than the super call found in single-
inheritance languages.

With new-style classes, dynamic ordering is necessary because all
cases of multiple inheritance exhibit one or more diamond
relationships (where at least one of the parent classes can be
accessed through multiple paths from the bottommost class).  For
example, all new-style classes inherit from "object", so any case of
multiple inheritance provides more than one path to reach "object".
To keep the base classes from being accessed more than once, the
dynamic algorithm linearizes the search order in a way that preserves
the left-to-right ordering specified in each class, that calls each
parent only once, and that is monotonic (meaning that a class can be
subclassed without affecting the precedence order of its parents).
Taken together, these properties make it possible to design reliable
and extensible classes with multiple inheritance.  For more detail,
see https://www.python.org/download/releases/2.3/mro/.


9.6. Private Variables and Class-local References
=================================================

“Private” instance variables that cannot be accessed except from
inside an object don’t exist in Python.  However, there is a
convention that is followed by most Python code: a name prefixed with
an underscore (e.g. "_spam") should be treated as a non-public part of
the API (whether it is a function, a method or a data member).  It
should be considered an implementation detail and subject to change
without notice.

Since there is a valid use-case for class-private members (namely to
avoid name clashes of names with names defined by subclasses), there
is limited support for such a mechanism, called *name mangling*.  Any
identifier of the form "__spam" (at least two leading underscores, at
most one trailing underscore) is textually replaced with
"_classname__spam", where "classname" is the current class name with
leading underscore(s) stripped.  This mangling is done without regard
to the syntactic position of the identifier, as long as it occurs
within the definition of a class.

名称修改有助于让子类重载方法而不破坏类内方法调用。例如:

   class Mapping:
       def __init__(self, iterable):
           self.items_list = []
           self.__update(iterable)

       def update(self, iterable):
           for item in iterable:
               self.items_list.append(item)

       __update = update   # private copy of original update() method

   class MappingSubclass(Mapping):

       def update(self, keys, values):
           # provides new signature for update()
           # but does not break __init__()
           for item in zip(keys, values):
               self.items_list.append(item)

The above example would work even if "MappingSubclass" were to
introduce a "__update" identifier since it is replaced with
"_Mapping__update" in the "Mapping" class  and
"_MappingSubclass__update" in the "MappingSubclass" class
respectively.

请注意，修剪规则主要是为了避免事故;它仍然可以访问或修改被视为私有的变
量。这在特殊情况下甚至可能很有用，例如在调试器中。

Notice that code passed to "exec", "eval()" or "execfile()" does not
consider the classname of the invoking  class to be the current class;
this is similar to the effect of the  "global" statement, the effect
of which is likewise restricted to  code that is byte-compiled
together.  The same restriction applies to "getattr()", "setattr()"
and "delattr()", as well as when referencing "__dict__" directly.


9.7. 其余琐碎
=============

有时，使用类似于Pascal “record”或C “struct”的数据类型是有用的，将一些
命名数据项捆绑在一起。定义一个空类就很适合:

   class Employee:
       pass

   john = Employee()  # Create an empty employee record

   # Fill the fields of the record
   john.name = 'John Doe'
   john.dept = 'computer lab'
   john.salary = 1000

A piece of Python code that expects a particular abstract data type
can often be passed a class that emulates the methods of that data
type instead.  For instance, if you have a function that formats some
data from a file object, you can define a class with methods "read()"
and "readline()" that get the data from a string buffer instead, and
pass it as an argument.

Instance method objects have attributes, too: "m.im_self" is the
instance object with the method "m()", and "m.im_func" is the function
object corresponding to the method.


9.8. Exceptions Are Classes Too
===============================

User-defined exceptions are identified by classes as well.  Using this
mechanism it is possible to create extensible hierarchies of
exceptions.

There are two new valid (semantic) forms for the "raise" statement:

   raise Class, instance

   raise instance

In the first form, "instance" must be an instance of "Class" or of a
class derived from it.  The second form is a shorthand for:

   raise instance.__class__, instance

A class in an "except" clause is compatible with an exception if it is
the same class or a base class thereof (but not the other way around —
an except clause listing a derived class is not compatible with a base
class).  For example, the following code will print B, C, D in that
order:

   class B:
       pass
   class C(B):
       pass
   class D(C):
       pass

   for c in [B, C, D]:
       try:
           raise c()
       except D:
           print "D"
       except C:
           print "C"
       except B:
           print "B"

Note that if the except clauses were reversed (with "except B" first),
it would have printed B, B, B — the first matching except clause is
triggered.

When an error message is printed for an unhandled exception, the
exception’s class name is printed, then a colon and a space, and
finally the instance converted to a string using the built-in function
"str()".


9.9. 迭代器
===========

到目前为止，您可能已经注意到大多数容器对象都可以使用 "for" 语句:

   for element in [1, 2, 3]:
       print element
   for element in (1, 2, 3):
       print element
   for key in {'one':1, 'two':2}:
       print key
   for char in "123":
       print char
   for line in open("myfile.txt"):
       print line,

This style of access is clear, concise, and convenient.  The use of
iterators pervades and unifies Python.  Behind the scenes, the "for"
statement calls "iter()" on the container object.  The function
returns an iterator object that defines the method "next()" which
accesses elements in the container one at a time.  When there are no
more elements, "next()" raises a "StopIteration" exception which tells
the "for" loop to terminate. This example shows how it all works:

   >>> s = 'abc'
   >>> it = iter(s)
   >>> it
   <iterator object at 0x00A1DB50>
   >>> it.next()
   'a'
   >>> it.next()
   'b'
   >>> it.next()
   'c'
   >>> it.next()
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
       it.next()
   StopIteration

Having seen the mechanics behind the iterator protocol, it is easy to
add iterator behavior to your classes.  Define an "__iter__()" method
which returns an object with a "next()" method.  If the class defines
"next()", then "__iter__()" can just return "self":

   class Reverse:
       """Iterator for looping over a sequence backwards."""
       def __init__(self, data):
           self.data = data
           self.index = len(data)

       def __iter__(self):
           return self

       def next(self):
           if self.index == 0:
               raise StopIteration
           self.index = self.index - 1
           return self.data[self.index]

   >>> rev = Reverse('spam')
   >>> iter(rev)
   <__main__.Reverse object at 0x00A1DB50>
   >>> for char in rev:
   ...     print char
   ...
   m
   a
   p
   s


9.10. 生成器
============

*Generator*s are a simple and powerful tool for creating iterators.
They are written like regular functions but use the "yield" statement
whenever they want to return data.  Each time "next()" is called on
it, the generator resumes where it left off (it remembers all the data
values and which statement was last executed).  An example shows that
generators can be trivially easy to create:

   def reverse(data):
       for index in range(len(data)-1, -1, -1):
           yield data[index]

   >>> for char in reverse('golf'):
   ...     print char
   ...
   f
   l
   o
   g

Anything that can be done with generators can also be done with class-
based iterators as described in the previous section.  What makes
generators so compact is that the "__iter__()" and "next()" methods
are created automatically.

Another key feature is that the local variables and execution state
are automatically saved between calls.  This made the function easier
to write and much more clear than an approach using instance variables
like "self.index" and "self.data".

In addition to automatic method creation and saving program state,
when generators terminate, they automatically raise "StopIteration".
In combination, these features make it easy to create iterators with
no more effort than writing a regular function.


9.11. 生成器表达式
==================

Some simple generators can be coded succinctly as expressions using a
syntax similar to list comprehensions but with parentheses instead of
square brackets. These expressions are designed for situations where
the generator is used right away by an enclosing function.  Generator
expressions are more compact but less versatile than full generator
definitions and tend to be more memory friendly than equivalent list
comprehensions.

例如:

   >>> sum(i*i for i in range(10))                 # sum of squares
   285

   >>> xvec = [10, 20, 30]
   >>> yvec = [7, 5, 3]
   >>> sum(x*y for x,y in zip(xvec, yvec))         # dot product
   260

   >>> from math import pi, sin
   >>> sine_table = dict((x, sin(x*pi/180)) for x in range(0, 91))

   >>> unique_words = set(word  for line in page  for word in line.split())

   >>> valedictorian = max((student.gpa, student.name) for student in graduates)

   >>> data = 'golf'
   >>> list(data[i] for i in range(len(data)-1,-1,-1))
   ['f', 'l', 'o', 'g']

-[ 脚注 ]-

[1] Except for one thing.  Module objects have a secret read-only
    attribute called "__dict__" which returns the dictionary used to
    implement the module’s namespace; the name "__dict__" is an
    attribute but not a global name. Obviously, using this violates
    the abstraction of namespace implementation, and should be
    restricted to things like post-mortem debuggers.
