术语表
******

">>>"
   交互式终端中默认的 Python 提示符。往往会显示于能以交互方式在解释器
   里执行的样例代码之前。

"..."
   交互式终端中输入特殊代码行时默认的 Python 提示符，包括：缩进的代码
   块，成对的分隔符之内（圆括号、方括号、花括号或三重引号），或是指定
   一个装饰器之后。

2to3
   一个将 Python 2.x 代码转换为 Python 3.x 代码的工具，能够处理大部分
   通过解析源码并遍历解析树可检测到的不兼容问题。

   2to3 包含在标准库中，模块名为 "lib2to3"；并提供一个独立入口点
   "Tools/scripts/2to3"。参见 2to3 - 自动将 Python 2 代码转为 Python 3
   代码。

abstract base class – 抽象基类
   Abstract base classes complement *duck-typing* by providing a way
   to define interfaces when other techniques like "hasattr()" would
   be clumsy or subtly wrong (for example with magic methods).  ABCs
   introduce virtual subclasses, which are classes that don’t inherit
   from a class but are still recognized by "isinstance()" and
   "issubclass()"; see the "abc" module documentation.  Python comes
   with many built-in ABCs for data structures (in the "collections"
   module), numbers (in the "numbers" module), and streams (in the
   "io" module). You can create your own ABCs with the "abc" module.

argument – 参数
   A value passed to a *function* (or *method*) when calling the
   function.  There are two types of arguments:

   * *关键字参数*: 在函数调用中前面带有标识符（例如 "name="）或者作
     为 包含在前面带有 "**" 的字典里的值传入。举例来说，"3" 和 "5" 在
     以下 对 "complex()" 的调用中均属于关键字参数:

        complex(real=3, imag=5)
        complex(**{'real': 3, 'imag': 5})

   * *位置参数*: 不属于关键字参数的参数。位置参数可出现于参数列表的
     开 头以及/或者作为前面带有 "*" 的 *iterable* 里的元素被传入。举例
     来 说，"3" 和 "5" 在以下调用中均属于位置参数:

        complex(3, 5)
        complex(*(3, 5))

   参数会被赋值给函数体中对应的局部变量。有关赋值规则参见 调用 一节。
   根据语法，任何表达式都可用来表示一个参数；最终算出的值会被赋给对应
   的局部变量。

   See also the *parameter* glossary entry and the FAQ question on the
   difference between arguments and parameters.

attribute – 属性
   关联到一个对象的值，可以使用点号表达式通过其名称来引用。例如，如果
   一个对象 *o* 具有一个属性 *a*，就可以用 *o.a* 来引用它。

BDFL
   Benevolent Dictator For Life, a.k.a. Guido van Rossum, Python’s
   creator.

bytes-like object – 字节类对象
   An object that supports the buffer protocol, like "str",
   "bytearray" or "memoryview". Bytes-like objects can be used for
   various operations that expect binary data, such as compression,
   saving to a binary file or sending over a socket. Some operations
   need the binary data to be mutable, in which case not all bytes-
   like objects can apply.

bytecode – 字节码
   Python source code is compiled into bytecode, the internal
   representation of a Python program in the CPython interpreter.  The
   bytecode is also cached in ".pyc" and ".pyo" files so that
   executing the same file is faster the second time (recompilation
   from source to bytecode can be avoided).  This “intermediate
   language” is said to run on a *virtual machine* that executes the
   machine code corresponding to each bytecode. Do note that bytecodes
   are not expected to work between different Python virtual machines,
   nor to be stable between Python releases.

   字节码指令列表可以在 dis 模块 的文档中查看。

class – 类
   用来创建用户定义对象的模板。类定义通常包含对该类的实例进行操作的方
   法定义。

classic class
   Any class which does not inherit from "object".  See *new-style
   class*.  Classic classes have been removed in Python 3.

coercion – 强制类型转换
   The implicit conversion of an instance of one type to another
   during an operation which involves two arguments of the same type.
   For example, "int(3.15)" converts the floating point number to the
   integer "3", but in "3+4.5", each argument is of a different type
   (one int, one float), and both must be converted to the same type
   before they can be added or it will raise a "TypeError".  Coercion
   between two operands can be performed with the "coerce" built-in
   function; thus, "3+4.5" is equivalent to calling
   "operator.add(*coerce(3, 4.5))" and results in "operator.add(3.0,
   4.5)".  Without coercion, all arguments of even compatible types
   would have to be normalized to the same value by the programmer,
   e.g., "float(3)+4.5" rather than just "3+4.5".

complex number – 复数
   对普通实数系统的扩展，其中所有数字都被表示为一个实部和一个虚部的和
   。虚数是虚数单位（"-1" 的平方根）的实倍数，通常在数学中写为 "i"，在
   工程学中写为 "j"。Python 内置了对复数的支持，采用工程学标记方式；虚
   部带有一个 "j" 后缀，例如 "3+1j"。如果需要 "math" 模块内对象的对应
   复数版本，请使用 "cmath"，复数的使用是一个比较高级的数学特性。如果
   你感觉没有必要，忽略它们也几乎不会有任何问题。

context manager – 上下文管理器
   在 "with" 语句中使用，通过定义 "__enter__()" 和 "__exit__()" 方法来
   控制环境状态的对象。参见 **PEP 343**。

CPython
   Python 编程语言的规范实现，在 python.org 上发布。”CPython” 一词用于
   在必要时将此实现与其他实现例如 Jython 或 IronPython 相区别。

decorator – 装饰器
   返回值为另一个函数的函数，通常使用 "@wrapper" 语法形式来进行函数变
   换。 装饰器的常见例子包括 "classmethod()" 和 "staticmethod()"。

   装饰器语法只是一种语法糖，以下两个函数定义在语义上完全等价:

      def f(...):
          ...
      f = staticmethod(f)

      @staticmethod
      def f(...):
          ...

   同的样概念也适用于类，但通常较少这样使用。有关装饰器的详情可参见 函
   数定义 和 类定义 的文档。

descriptor – 描述符
   Any *new-style* object which defines the methods "__get__()",
   "__set__()", or "__delete__()".  When a class attribute is a
   descriptor, its special binding behavior is triggered upon
   attribute lookup.  Normally, using *a.b* to get, set or delete an
   attribute looks up the object named *b* in the class dictionary for
   *a*, but if *b* is a descriptor, the respective descriptor method
   gets called.  Understanding descriptors is a key to a deep
   understanding of Python because they are the basis for many
   features including functions, methods, properties, class methods,
   static methods, and reference to super classes.

   有关描述符的方法的详情可参看 实现描述器。

dictionary – 字典
   An associative array, where arbitrary keys are mapped to values.
   The keys can be any object with "__hash__()"  and "__eq__()"
   methods. Called a hash in Perl.

dictionary view – 字典视图
   The objects returned from "dict.viewkeys()", "dict.viewvalues()",
   and "dict.viewitems()" are called dictionary views. They provide a
   dynamic view on the dictionary’s entries, which means that when the
   dictionary changes, the view reflects these changes. To force the
   dictionary view to become a full list use "list(dictview)".  See
   Dictionary view objects.

docstring – 文档字符串
   作为类、函数或模块之内的第一个表达式出现的字符串字面值。它在代码执
   行时会被忽略，但会被解释器识别并放入所在类、函数或模块的 "__doc__"
   属性中。由于它可用于代码内省，因此是对象存放文档的规范位置。

duck-typing – 鸭子类型
   指一种编程风格，它并不依靠查找对象类型来确定其是否具有正确的接口，
   而是直接调用或使用其方法或属性（“看起来像鸭子，叫起来也像鸭子，那么
   肯定就是鸭子。”）由于强调接口而非特定类型，设计良好的代码可通过允许
   多态替代来提升灵活性。鸭子类型避免使用 "type()" 或 "isinstance()"
   检测。(但要注意鸭子类型可以使用 *抽象基类* 作为补充。)  而往往会采
   用 "hasattr()" 检测或是 *EAFP* 编程。

EAFP
   “求原谅比求许可更容易”的英文缩写。这种 Python 常用代码编写风格会假
   定所需的键或属性存在，并在假定错误时捕获异常。这种简洁快速风格的特
   定就是大量运用 "try" 和 "except" 语句。于其相对的则是所谓 *LBYL* 风
   格，常见于 C 等许多其他语言。

expression – 表达式
   A piece of syntax which can be evaluated to some value.  In other
   words, an expression is an accumulation of expression elements like
   literals, names, attribute access, operators or function calls
   which all return a value.  In contrast to many other languages, not
   all language constructs are expressions.  There are also
   *statement*s which cannot be used as expressions, such as "print"
   or "if".  Assignments are also statements, not expressions.

extension module – 扩展模块
   以 C 或 C++ 编写的模块，使用 Python 的 C API 来与语言核心以及用户代
   码进行交互。

file object – 文件对象
   对外提供面向文件 API 以使用下层资源的对象（带有 "read()" 或
   "write()" 这样的方法）。根据其创建方式的不同，文件对象可以处理对真
   实磁盘文件，对其他类型存储，或是对通讯设备的访问（例如标准输入/输出
   、内存缓冲区、套接字、管道等等）。文件对象也被称为 *文件类对象* 或
   *流*。

   There are actually three categories of file objects: raw binary
   files, buffered binary files and text files.  Their interfaces are
   defined in the "io" module.  The canonical way to create a file
   object is by using the "open()" function.

file-like object – 文件类对象
   *file object* 的同义词。

finder – 查找器
   An object that tries to find the *loader* for a module. It must
   implement a method named "find_module()". See **PEP 302** for
   details.

floor division – 向下取整除法
   向下舍入到最接近的整数的数学除法。向下取整除法的运算符是 "//" 。例
   如，表达式 "11 // 4" 的计算结果是 "2" ，而与之相反的是浮点数的真正
   除法返回 "2.75" 。注意 "(-11) // 4" 会返回 "-3" 因为这是 "-2.75" *
   向下* 舍入得到的结果。见 **PEP 238** 。

function – 函数
   可以向调用者返回某个值的一组语句。还可以向其传入零个或多个 *参数*
   并在函数体执行中被使用。另见 *parameter*, *method* 和 函数定义 等节
   。

__future__
   A pseudo-module which programmers can use to enable new language
   features which are not compatible with the current interpreter.
   For example, the expression "11/4" currently evaluates to "2". If
   the module in which it is executed had enabled *true division* by
   executing:

      from __future__ import division

   the expression "11/4" would evaluate to "2.75".  By importing the
   "__future__" module and evaluating its variables, you can see when
   a new feature was first added to the language and when it will
   become the default:

      >>> import __future__
      >>> __future__.division
      _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

garbage collection – 垃圾回收
   The process of freeing memory when it is not used anymore.  Python
   performs garbage collection via reference counting and a cyclic
   garbage collector that is able to detect and break reference
   cycles.

generator – 生成器
   A function which returns an iterator.  It looks like a normal
   function except that it contains "yield" statements for producing a
   series of values usable in a for-loop or that can be retrieved one
   at a time with the "next()" function. Each "yield" temporarily
   suspends processing, remembering the location execution state
   (including local variables and pending try-statements).  When the
   generator resumes, it picks up where it left off (in contrast to
   functions which start fresh on every invocation).

generator expression – 生成器表达式
   An expression that returns an iterator.  It looks like a normal
   expression followed by a "for" expression defining a loop variable,
   range, and an optional "if" expression.  The combined expression
   generates values for an enclosing function:

      >>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81
      285

GIL
   参见 *global interpreter lock*。

global interpreter lock – 全局解释器锁
   *CPython* 解释器所采用的一种机制，它确保同一时刻只有一个线程在执行
   Python *bytecode*。此机制通过设置对象模型（包括 "dict" 等重要内置类
   型）针对并发访问的隐式安全简化了 CPython 实现。给整个解释器加锁使得
   解释器多线程运行更方便，其代价则是牺牲了在多处理器上的并行性。

   不过，某些标准库或第三方库的扩展模块被设计为在执行计算密集型任务如
   压缩或哈希时释放 GIL。此外，在执行 I/O 操作时也总是会释放 GIL。

   创建一个（以更精细粒度来锁定共享数据的）“自由线程”解释器的努力从未
   获得成功，因为这会牺牲在普通单处理器情况下的性能。据信克服这种性能
   问题的措施将导致实现变得更复杂，从而更难以维护。

hashable – 可哈希
   An object is *hashable* if it has a hash value which never changes
   during its lifetime (it needs a "__hash__()" method), and can be
   compared to other objects (it needs an "__eq__()" or "__cmp__()"
   method). Hashable objects which compare equal must have the same
   hash value.

   可哈希性使得对象能够作为字典键或集合成员使用，因为这些数据结构要在
   内部使用哈希值。

   All of Python’s immutable built-in objects are hashable, while no
   mutable containers (such as lists or dictionaries) are.  Objects
   which are instances of user-defined classes are hashable by
   default; they all compare unequal (except with themselves), and
   their hash value is derived from their "id()".

IDLE
   Python 的 IDE，“集成开发与学习环境”的英文缩写。是 Python 标准发行版
   附带的基本编程器和解释器环境。

immutable – 不可变
   具有固定值的对象。不可变对象包括数字、字符串和元组。这样的对象不能
   被改变。如果必须存储一个不同的值，则必须创建新的对象。它们在需要常
   量哈希值的地方起着重要作用，例如作为字典中的键。

integer division
   Mathematical division discarding any remainder.  For example, the
   expression "11/4" currently evaluates to "2" in contrast to the
   "2.75" returned by float division.  Also called *floor division*.
   When dividing two integers the outcome will always be another
   integer (having the floor function applied to it). However, if one
   of the operands is another numeric type (such as a "float"), the
   result will be coerced (see *coercion*) to a common type.  For
   example, an integer divided by a float will result in a float
   value, possibly with a decimal fraction.  Integer division can be
   forced by using the "//" operator instead of the "/" operator.  See
   also *__future__*.

importing – 导入
   令一个模块中的 Python 代码能为另一个模块中的 Python 代码所使用的过
   程。

importer – 导入器
   查找并加载模块的对象；此对象既属于 *finder* 又属于 *loader*。

interactive – 交互
   Python 带有一个交互式解释器，即你可以在解释器提示符后输入语句和表达
   式，立即执行并查看其结果。只需不带参数地启动 "python" 命令（也可以
   在你的计算机开始菜单中选择相应菜单项）。在测试新想法或检验模块和包
   的时候用这种方式会非常方便（请记得使用 "help(x)"）。

interpreted – 解释型
   Python 一是种解释型语言，与之相对的是编译型语言，虽然两者的区别由于
   字节码编译器的存在而会有所模糊。这意味着源文件可以直接运行而不必显
   式地创建可执行文件再运行。解释型语言通常具有比编译型语言更短的开发/
   调试周期，但是其程序往往运行得更慢。参见 *interactive*。

iterable – 可迭代对象
   An object capable of returning its members one at a time. Examples
   of iterables include all sequence types (such as "list", "str", and
   "tuple") and some non-sequence types like "dict" and "file" and
   objects of any classes you define with an "__iter__()" or
   "__getitem__()" method.  Iterables can be used in a "for" loop and
   in many other places where a sequence is needed ("zip()", "map()",
   …).  When an iterable object is passed as an argument to the built-
   in function "iter()", it returns an iterator for the object.  This
   iterator is good for one pass over the set of values.  When using
   iterables, it is usually not necessary to call "iter()" or deal
   with iterator objects yourself.  The "for" statement does that
   automatically for you, creating a temporary unnamed variable to
   hold the iterator for the duration of the loop.  See also
   *iterator*, *sequence*, and *generator*.

iterator – 迭代器
   An object representing a stream of data.  Repeated calls to the
   iterator’s "next()" method return successive items in the stream.
   When no more data are available a "StopIteration" exception is
   raised instead.  At this point, the iterator object is exhausted
   and any further calls to its "next()" method just raise
   "StopIteration" again.  Iterators are required to have an
   "__iter__()" method that returns the iterator object itself so
   every iterator is also iterable and may be used in most places
   where other iterables are accepted.  One notable exception is code
   which attempts multiple iteration passes.  A container object (such
   as a "list") produces a fresh new iterator each time you pass it to
   the "iter()" function or use it in a "for" loop.  Attempting this
   with an iterator will just return the same exhausted iterator
   object used in the previous iteration pass, making it appear like
   an empty container.

   更多信息可查看 迭代器类型。

key function – 键函数
   键函数或称整理函数，是能够返回用于排序或排位的值的可调用对象。例如
   ，"locale.strxfrm()" 可用于生成一个符合特定区域排序约定的排序键。

   A number of tools in Python accept key functions to control how
   elements are ordered or grouped.  They include "min()", "max()",
   "sorted()", "list.sort()", "heapq.nsmallest()", "heapq.nlargest()",
   and "itertools.groupby()".

   There are several ways to create a key function.  For example. the
   "str.lower()" method can serve as a key function for case
   insensitive sorts.  Alternatively, an ad-hoc key function can be
   built from a "lambda" expression such as "lambda r: (r[0], r[2])".
   Also, the "operator" module provides three key function
   constructors: "attrgetter()", "itemgetter()", and "methodcaller()".
   See the Sorting HOW TO for examples of how to create and use key
   functions.

keyword argument – 关键字参数
   参见 *argument*。

lambda
   由一个单独 *expression* 构成的匿名内联函数，表达式会在调用时被求值
   。创建 lambda 函数的句法为 "lambda [parameters]: expression"

LBYL
   “先查看后跳跃”的英文缩写。这种代码编写风格会在进行调用或查找之前显
   式地检查前提条件。此风格与 *EAFP* 方式恰成对比，其特点是大量使用
   "if" 语句。

   在多线程环境中，LBYL 方式会导致“查看”和“跳跃”之间发生条件竞争风险。
   例如，以下代码 "if key in mapping: return mapping[key]" 可能由于在
   检查操作之后其他线程从 *mapping* 中移除了 *key* 而出错。这种问题可
   通过加锁或使用 EAFP 方式来解决。

list – 列表
   Python 内置的一种 *sequence*。虽然名为列表，但更类似于其他语言中的
   数组而非链接列表，因为访问元素的时间复杂度为 O(1)。

list comprehension – 列表推导式
   A compact way to process all or part of the elements in a sequence
   and return a list with the results.  "result = ["0x%02x" % x for x
   in range(256) if x % 2 == 0]" generates a list of strings
   containing even hex numbers (0x..) in the range from 0 to 255. The
   "if" clause is optional.  If omitted, all elements in "range(256)"
   are processed.

loader – 加载器
   An object that loads a module. It must define a method named
   "load_module()". A loader is typically returned by a *finder*. See
   **PEP 302** for details.

magic method
   An informal synonym for *special method*.

mapping – 映射
   A container object that supports arbitrary key lookups and
   implements the methods specified in the "Mapping" or
   "MutableMapping" abstract base classes.  Examples include "dict",
   "collections.defaultdict", "collections.OrderedDict" and
   "collections.Counter".

metaclass – 元类
   一种用于创建类的类。类定义包含类名、类字典和基类列表。元类负责接受
   上述三个参数并创建相应的类。大部分面向对象的编程语言都会提供一个默
   认实现。Python 的特别之处在于可以创建自定义元类。大部分用户永远不需
   要这个工具，但当需要出现时，元类可提供强大而优雅的解决方案。它们已
   被用于记录属性访问日志、添加线程安全性、跟踪对象创建、实现单例，以
   及其他许多任务。

   更多详情参见 自定义类创建。

method – 方法
   在类内部定义的函数。如果作为该类的实例的一个属性来调用，方法将会获
   取实例对象作为其第一个 *argument* (通常命名为 "self")。参见
   *function* 和 *nested scope*。

method resolution order – 方法解析顺序
   方法解析顺序就是在查找成员时搜索全部基类所用的先后顺序。请查看
   Python 2.3 方法解析顺序 了解自 2.3 版起 Python 解析器所用相关算法的
   详情。

module – 模块
   此对象是 Python 代码的一种组织单位。各模块具有独立的命名空间，可包
   含任意 Python 对象。模块可通过 *importing* 操作被加载到 Python 中。

   另见 *package*。

MRO
   参见 *method resolution order*。

mutable – 可变
   可变对象可以在其 "id()" 保持固定的情况下改变其取值。另请参见
   *immutable*。

named tuple – 具名元组
   任何类似元组的类，其中的可索引元素也能使用名称属性来访问。（例如，
   "time.localtime()" 会返回一个类似元组的对象，其中的 *year* 既可以通
   过索引访问如 "t[0]" 也可以通过名称属性访问如 "t.tm_year"）。

   具名元组可以是一个内置类型例如 "time.struct_time"，也可以通过正规的
   类定义来创建。一个完备的具名元组还可以通过工厂函数
   "collections.namedtuple()" 来创建。后面这种方式会自动提供一些额外特
   性，例如 "Employee(name='jones', title='programmer')" 这样的自包含
   文档表示形式。

namespace – 命名空间
   The place where a variable is stored.  Namespaces are implemented
   as dictionaries.  There are the local, global and built-in
   namespaces as well as nested namespaces in objects (in methods).
   Namespaces support modularity by preventing naming conflicts.  For
   instance, the functions "__builtin__.open()" and "os.open()" are
   distinguished by their namespaces.  Namespaces also aid readability
   and maintainability by making it clear which module implements a
   function.  For instance, writing "random.seed()" or
   "itertools.izip()" makes it clear that those functions are
   implemented by the "random" and "itertools" modules, respectively.

nested scope – 嵌套作用域
   The ability to refer to a variable in an enclosing definition.  For
   instance, a function defined inside another function can refer to
   variables in the outer function.  Note that nested scopes work only
   for reference and not for assignment which will always write to the
   innermost scope.  In contrast, local variables both read and write
   in the innermost scope.  Likewise, global variables read and write
   to the global namespace.

new-style class – 新式类
   Any class which inherits from "object".  This includes all built-in
   types like "list" and "dict".  Only new-style classes can use
   Python’s newer, versatile features like "__slots__", descriptors,
   properties, and "__getattribute__()".

   More information can be found in New-style and classic classes.

object – 对象
   任何具有状态（属性或值）以及预定义行为（方法）的数据。object 也是任
   何 *new-style class* 的最顶层基类名。

package – 包
   一种可包含子模块或递归地包含子包的 Python *module*。从技术上说，包
   是带有 "__path__" 属性的 Python 模块。

parameter – 形参
   A named entity in a *function* (or method) definition that
   specifies an *argument* (or in some cases, arguments) that the
   function can accept.  There are four types of parameters:

   * *positional-or-keyword*：位置或关键字，指定一个可以作为 *位置参
     数 * 传入也可以作为 *关键字参数* 传入的实参。这是默认的形参类型，
     例 如下面的 *foo* 和 *bar*:

        def func(foo, bar=None): ...

   * *positional-only*：仅限位置，指定一个只能按位置传入的参数。
     Python 中没有定义仅限位置形参的语法。但是一些内置函数有仅限位置形
     参（比 如 "abs()"）。

   * *var-positional*：可变位置，指定可以提供由一个任意数量的位置参
     数 构成的序列（附加在其他形参已接受的位置参数之后）。这种形参可通
     过 在形参名称前加缀 "*" 来定义，例如下面的 *args*:

        def func(*args, **kwargs): ...

   * *var-keyword*：可变关键字，指定可以提供任意数量的关键字参数（附
     加 在其他形参已接受的关键字参数之后）。这种形参可通过在形参名称前
     加 缀 "**" 来定义，例如上面的 *kwargs*。

   形参可以同时指定可选和必选参数，也可以为某些可选参数指定默认值。

   See also the *argument* glossary entry, the FAQ question on the
   difference between arguments and parameters, and the 函数定义
   section.

PEP
   “Python 增强提议”的英文缩写。一个 PEP 就是一份设计文档，用来向
   Python 社区提供信息，或描述一个 Python 的新增特性及其进度或环境。
   PEP 应当提供精确的技术规格和所提议特性的原理说明。

   PEP 应被作为提出主要新特性建议、收集社区对特定问题反馈以及为必须加
   入 Python 的设计决策编写文档的首选机制。PEP 的作者有责任在社区内部
   建立共识，并应将不同意见也记入文档。

   参见 **PEP 1**。

positional argument – 位置参数
   参见 *argument*。

Python 3000
   Python 3.x 发布路线的昵称（这个名字在版本 3 的发布还遥遥无期的时候
   就已出现了）。有时也被缩写为“Py3k”。

Pythonic
   指一个思路或一段代码紧密遵循了 Python 语言最常用的风格和理念，而不
   是使用其他语言中通用的概念来实现代码。例如，Python 的常用风格是使用
   "for" 语句循环来遍历一个可迭代对象中的所有元素。许多其他语言没有这
   样的结构，因此不熟悉 Python 的人有时会选择使用一个数字计数器:

      for i in range(len(food)):
          print food[i]

   而相应的更简洁更 Pythonic 的方法是这样的:

      for piece in food:
          print piece

reference count – 引用计数
   对特定对象的引用的数量。当一个对象的引用计数降为零时，所分配资源将
   被释放。引用计数对 Python 代码来说通常是不可见的，但它是 *CPython*
   实现的一个关键元素。"sys" 模块定义了一个 "getrefcount()" 函数，程序
   员可调用它来返回特定对象的引用计数。

__slots__
   A declaration inside a *new-style class* that saves memory by pre-
   declaring space for instance attributes and eliminating instance
   dictionaries.  Though popular, the technique is somewhat tricky to
   get right and is best reserved for rare cases where there are large
   numbers of instances in a memory-critical application.

sequence – 序列
   An *iterable* which supports efficient element access using integer
   indices via the "__getitem__()" special method and defines a
   "len()" method that returns the length of the sequence. Some built-
   in sequence types are "list", "str", "tuple", and "unicode". Note
   that "dict" also supports "__getitem__()" and "__len__()", but is
   considered a mapping rather than a sequence because the lookups use
   arbitrary *immutable* keys rather than integers.

slice – 切片
   An object usually containing a portion of a *sequence*.  A slice is
   created using the subscript notation, "[]" with colons between
   numbers when several are given, such as in "variable_name[1:3:5]".
   The bracket (subscript) notation uses "slice" objects internally
   (or in older versions, "__getslice__()" and "__setslice__()").

special method – 特殊方法
   一种由 Python 隐式调用的方法，用来对某个类型执行特定操作例如相加等
   等。这种方法的名称的首尾都为双下划线。特殊方法的文档参见 特殊方法名
   称。

statement – 语句
   语句是程序段（一个代码“块”）的组成单位。一条语句可以是一个
   *expression* 或某个带有关键字的结构，例如 "if"、"while" 或 "for"。

struct sequence – 结构序列
   A tuple with named elements. Struct sequences expose an interface
   similiar to *named tuple* in that elements can be accessed either
   by index or as an attribute. However, they do not have any of the
   named tuple methods like "_make()" or "_asdict()". Examples of
   struct sequences include "sys.float_info" and the return value of
   "os.stat()".

triple-quoted string – 三引号字符串
   首尾各带三个连续双引号（”）或者单引号（’）的字符串。它们在功能上与
   首尾各用一个引号标注的字符串没有什么不同，但是有多种用处。它们允许
   你在字符串内包含未经转义的单引号和双引号，并且可以跨越多行而无需使
   用连接符，在编写文档字符串时特别好用。

type – 类型
   类型决定一个 Python 对象属于什么种类；每个对象都具有一种类型。要知
   道对象的类型，可以访问它的 "__class__" 属性，或是通过 "type(obj)"
   来获取。

universal newlines – 通用换行
   A manner of interpreting text streams in which all of the following
   are recognized as ending a line: the Unix end-of-line convention
   "'\n'", the Windows convention "'\r\n'", and the old Macintosh
   convention "'\r'".  See **PEP 278** and **PEP 3116**, as well as
   "str.splitlines()" for an additional use.

virtual environment – 虚拟环境
   一种采用协作式隔离的运行时环境，允许 Python 用户和应用程序在安装和
   升级 Python 分发包时不会干扰到同一系统上运行的其他 Python 应用程序
   的行为。

virtual machine – 虚拟机
   一台完全通过软件定义的计算机。Python 虚拟机可执行字节码编译器所生成
   的 *bytecode*。

Zen of Python – Python 之禅
   列出 Python 设计的原则与哲学，有助于理解与使用这种语言。查看其具体
   内容可在交互模式提示符中输入 “"import this"”。
