9.1. 名称和对象¶

对象是独立的，多个名字（在多个作用域中）可以绑定到同一个对象。这在其他语言中称为别名。第一次粗略浏览 Python 时经常不会注意到这个特性，而且处理不可变的基本类型（数字，字符串，元组）时忽略这一点也没什么问题。然而， 在Python 代码涉及可变对象如列表、 字典和大多数其它类型时，别名可能具有意想不到语义效果。这通常有助于优化程序，因为别名的行为在某些方面类似指针。例如，传递一个对象的开销是很小的，因为在实现上只是传递了一个指针；如果函数修改了参数传递的对象，调用者也将看到变化 —— 这就避免了类似 Pascal 中需要两个不同参数的传递机制。

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

在介绍类之前，我首先要告诉你一些有关 Python 作用域的规则。类的定义非常巧妙的运用了命名空间，要完全理解接下来的知识，需要先理解作用域和命名空间的工作原理。另外，这一切的知识对于任何高级 Python 程序员都非常有用。

让我们从一些定义开始。

命名空间是从名称到对象的映射。当前命名空间主要是通过 Python 字典实现的，不过通常不会引起任何关注（除了性能方面），它以后也有可能会改变。以下有一些命名空间的例子：内置名称集（包括函数名例如abs()和内置异常的名称）；模块中的全局名称；函数调用中的局部名称。在某种意义上，对象的属性也形成一个命名空间。关于命名空间需要知道的重要一点是不同命名空间内的名称(如函数名)绝对没有任何关系；例如，两个不同模块可以都定义函数maximize而不会产生混淆 —— 模块的使用者必须以模块名为前缀引用它们。

顺便说一句，我使用属性 这个词称呼点后面的任何名称 —— 例如，在表达式z.real中，real是z对象的一个属性。严格地说，对模块中的名称的引用是属性引用：在表达式modname.funcname中， modname是一个模块对象，funcname是它的一个属性。在这种情况下，模块的属性和模块中定义的全局名称之间碰巧是直接的映射：它们共享同一命名空间 ！[1]

属性可以是只读的也可以是可写的。在后一种情况下，可以对属性赋值。模块的属性都是可写的：你可以这样写modname.the_answer = 42。可写的属性也可以用del语句删除。例如，del modname.the_answer将会删除对象modname中的the_answer属性。

各个命名空间创建的时刻是不一样的，且有着不同的生命周期。包含内置名称的命名空间在 Python 解释器启动时创建，永远不会被删除。模块的全局命名空间在读入模块定义时创建；通常情况下，模块命名空间也会一直保存到解释器退出。在解释器最外层调用执行的语句，不管是从脚本文件中读入还是来自交互式输入，都被当作模块__main__的一部分，所以它们有它们自己的全局命名空间。(内置名称实际上也存在于一个模块中，这个模块叫__builtin__。)

函数的局部命名空间在函数调用时创建，在函数返回或者引发了一个函数内部没有处理的异常时删除。（实际上，用遗忘来形容到底发生了什么更为贴切。)当然，每个递归调用有它们自己的局部命名空间。

作用域 是 Python 程序中可以直接访问一个命名空间的代码区域。这里的“直接访问”的意思是用没有前缀的引用在命名空间中找到的相应的名称。

虽然作用域的确定是静态的，但它们的使用是动态的。程序执行过程中的任何时候，至少有三个嵌套的作用域，它们的命名空间是可以直接访问的：

• 首先搜索最里面包含局部命名的作用域
• 其次搜索所有调用函数的作用域，从最内层调用函数的作用域开始，它们包含非局部但也非全局的命名
• 倒数第二个搜索的作用域是包含当前模块全局命名的作用域
• 最后搜索的作用域是最外面包含内置命名的命名空间

如果一个命名声明为全局的，那么对它的所有引用和赋值会直接搜索包含这个模块全局命名的作用域。否则，在最里面作用域之外找到的所有变量都是只读的（对这样的变量赋值会在最里面的作用域创建一个新 的局部变量，外部具有相同命名的那个变量不会改变）。

通常情况下，局部作用域引用当前函数的本地命名。函数之外，局部作用域引用的命名空间与全局作用域相同：模块的命名空间。类定义在局部命名空间中创建了另一个命名空间。

认识到作用域是由代码确定的是非常重要的：函数的全局作用域是函数的定义所在的模块的命名空间，与函数调用的位置或者别名无关。另一方面，命名的实际搜索过程是动态的，在运行时确定的——然而，Python 语言也在不断发展，以后有可能会成为静态的“编译”时确定，所以不要依赖动态解析！（事实上，本地变量是已经确定静态。）

Python的一个特别之处在于——如果没有使用global语法——其赋值操作总是在最里层的作用域。赋值不会复制数据——只是将命名绑定到对象。删除也是如此：del x只是从局部作用域的命名空间中删除命名x。事实上，所有引入新命名的操作都作用于局部作用域： 特别是import语句和函数定义将模块名或函数绑定于局部作用域。(可以使用   Global 语句将变量引入到全局作用域。)

9.3. 初识类¶

类引入了少量的新语法、三种新对象类型和一些新语义。

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

class MyClass:
    """A simple example class"""
    i = 12345
    def f(self):
        return 'hello world'

x = MyClass()

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

x = MyClass()

>>> 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)

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

x.f()

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

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'

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. 补充说明¶

数据属性会覆盖同名的方法属性；为了避免意外的命名冲突，这在大型程序中可能带来极难发现的 bug，使用一些约定来减少冲突的机会是明智的。可能的约定包括大写方法名称的首字母，使用一个小写的独特字符串（也许只是一个下划线）作为数据属性名称的前缀，或者方法使用动词而数据属性使用名词。

数据属性可以被方法引用，也可以由一个对象的普通用户（“客户端”）使用。换句话说，类是不能用来实现纯抽象数据类型。事实上，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)

方法可以像普通函数那样引用全局命名。与方法关联的全局作用域是包含类定义的模块。（类本身永远不会做为全局作用域使用。）尽管很少有好的理由在方法中使用全局数据，全局作用域确有很多合法的用途：其一是方法可以调用导入全局作用域的函数和模块，也可以调用定义在其中的类和函数。通常，包含此方法的类也会定义在这个全局作用域，在下一节我们会了解为何一个方法要引用自己的类。

每个值都是一个对象，因此每个值都有一个类（也称为类型）。它存储为object.__class__。

9.5. 继承¶

当然，号称是“类”，却不支持继承，是配不上“类”这个名字的。派生类定义的语法如下所示：

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

BaseClassName必须与派生类定义在一个作用域内。用其他任意表达式代替基类的名称也是允许的。这会很有用，例如，当基类定义在另一个模块中时：

class DerivedClassName(modname.BaseClassName):

派生类定义的执行过程和基类是相同的。类对象创建后，基类会被保存。这用于解析属性的引用：如果在类中找不到请求的属性，搜索会在基类中继续。如果基类本身是由别的类派生而来，这个规则会递归应用。

派生类的实例化没有什么特殊之处：DerivedClassName()创建类的一个新的实例。方法的引用按如下规则解析： 搜索对应的类的属性，必要时沿基类链逐级搜索，如果找到了函数对象这个方法引用就是合法的。

派生的类能够重写其基类的方法。因为方法调用本对象中的其它方法时没有特权，基类的方法调用本基类的方法时，可能实际上最终调用了派生类中的覆盖方法。（对于 C++ 程序员：Python 中的所有方法实际上都是虚的。)

子类中的覆盖方法可能是想要扩充而不是简单的替代基类中的重名方法。有一个简单的方法可以直接调用基类方法：只要调用BaseClassName.methodname(self, arguments)。有时这对于客户端也很有用。（要注意只有BaseClassName在同一全局作用域定义或导入时才能这样用。）

Python 有两个与继承相关的内置函数：

• 使用isinstance()来检查实例类型：isinstance(obj, int)只有obj.__class__是int或者是从int派生的类时才为True。
• 使用issubclass()来检查类的继承: issubclass(bool， int)是True因为bool是int的子类。然而， issubclass （unicode， str)是False因为unicode不是str的一个子类（它们只是共享一个祖先， basestring） 。

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

9.6. 私有变量和类本地引用¶

在 Python 中不存在只能从对象内部访问的“私有”实例变量。然而，有一项大多数 Python 代码都遵循的公约：带有下划线（例如_spam）前缀的名称应被视为非公开的 API 的一部分（无论是函数、 方法还是数据成员）。它应该被当做一个实现细节，将来如果有变化孰不另行通知。

因为有一个合理的类私有成员的使用场景（即为了避免名称与子类定义的名称冲突），Python 对这种机制有简单的支持，叫做name mangling。__spam 形式的任何标识符(前面至少两个下划线，后面至多一个下划线）将被替换为_classname__spam，classname是当前类的名字。此mangling会生效而不考虑该标识符的句法位置，只要它出现在类的定义的范围内。

Name mangling 有利于子类重写父类的方法而不会破坏类内部的方法调用。例如：

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)

请注意 mangling 规则的目的主要是避免发生意外；它仍然有可能访问或修改一个被认为是私有的变量。这在特殊情况下，例如调试的时候，还是有用的。

请注意传递给exec、 eval()或execfile()的代码没有考虑要将调用类的类名当作当前类；这类似于global语句的效果，影响只限于一起进行字节编译的代码。相同的限制适用于getattr()、 setattr()和delattr()，以及直接引用__dict__时。

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

某一段 Python 代码需要一个特殊的抽象数据结构的话，通常可以传入一个类来模拟该数据类型的方法。例如，如果你有一个用于从文件对象中格式化数据的函数，你可以定义一个带有read ()和readline () 方法的类，以此从字符串缓冲读取数据，然后将该类的对象作为参数传入前述的函数。

实例的方法对象也有属性： m.im_self是具有方法m()的实例对象，m.im_func是方法的函数对象。

9.8. 异常也是类¶

用户定义的异常类也由类标识。利用这个机制可以创建可扩展的异常层次。

raise语句有两种新的有效的（语义上的）形式：

raise Class, instance
raise instance

第一种形式中，instance必须是Class或者它的子类的实例。第二种形式是一种简写：

raise instance.__class__, instance

except子句中的类如果与异常是同一个类或者是其基类，那么它们就是相容的（但是反过来是不行的——except子句列出的子类与基类是不相容的）。例如，下面的代码将按该顺序打印 B、 C、 D：

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"

请注意，如果except 子句的顺序倒过来 (excpet B B在最前面），它就会打印B，B，B —— 第一个匹配的异常被触发。

打印一个异常类的错误信息时，先打印类名，然后是一个空格、一个冒号，然后是用内置函数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,

这种风格的访问明确、 简洁和方便。迭代器的用法在 Python 中普遍而且统一。在后台， for语句在容器对象上调用iter() 。该函数返回一个定义了next ()方法的迭代器对象，它在容器中逐一访问元素。没有后续的元素时， next()会引发StopIteration异常，告诉for循环终止。此示例显示它是如何工作：

>>> 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 ?
    it.next()
StopIteration

看过迭代器协议背后的机制后，将很容易将迭代器的行为添加到你的类中。定义一个__iter__()方法，它返回一个有next()方法的对象。如果类定义了next()，__iter__() 可以只返回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. 生成器¶

生成器是创建迭代器的一种简单而强大的工具。它们写起来就像是正规的函数，只是需要返回数据的时候使用yield语句。每次next()调用时，生成器再恢复它离开的位置（它记忆语句最后一次执行的位置和所有的数据值）。以下示例演示了生成器可以非常简单地创建出来：

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

生成器能做到的所有事，前一节所述的基于类的迭代器也能做到。生成器这么紧凑的原因是因为__iter__()和next ()方法是自动创建的。

另一个关键功能是调用时自动保存局部变量和执行状态。这使得该函数相比实例变量，如self.index和self.data方法，更容易写，更清楚地使用。

除了自动方法创建和保存的程序状态外，当创建完成，他们会自动抛出StopIteration。组合起来，这些功能使得创建迭代器如同编写函数般简单。

9.11. 生成器表达式¶

使用类似列表表示式的语法，一些简单的生成器可以写成简洁的表达式，但是使用圆括号代替方括号。这些表达式用于生成器在封闭的函数中使用的情况。生成器表达式更紧凑但没有完整定义的生成器用途广泛，而且比同等的列表表示式消耗更少的内存。

例子：

>>> 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']

脚注