目录 | 上一节 (4.4 异常) | 下一节 (5.2 封装)

5.1 再谈字典

Python 对象系统主要基于字典实现。本节将对此进行讨论。

字典

字典是命名值（named values）的集合。

  1. stock = {
  2.     'name' : 'GOOG',
  3.     'shares' : 100,
  4.     'price' : 490.1
  5. }

虽然字典常用于简单的数据结构，但是字典也用于解释器的关键部分。字典可能是 Python 中最重要的数据类型。

字典和模块

在模块内，字典存储所有的全局变量和函数。

  1. # foo.py
  3. x = 42
  4. def bar():
  5.     ...
  7. def spam():
  8.     ...

可以通过 foo.__dict__ 或 globals() 查看该字典。

  1. {
  2.     'x' : 42,
  3.     'bar' : <function bar>,
  4.     'spam' : <function spam>
  5. }

字典和对象

用户定义对象的时候也使用到了实例字典和类字典。事实上，整个对象系统主要是基于字典实现的。

字典存储实例数据，如 __dict__：

  1. >>> s = Stock('GOOG', 100, 490.1)
  2. >>> s.__dict__
  3. {'name' : 'GOOG', 'shares' : 100, 'price': 490.1 }

当给 self 赋值的时候，你将填充该字典（和实例）。

  1. class Stock:
  2.     def __init__(self, name, shares, price):
  3.         self.name = name
  4.         self.shares = shares
  5.         self.price = price

实例数据 self.__dict__ 看起来像下面这样：

  1. {
  2.     'name': 'GOOG',
  3.     'shares': 100,
  4.     'price': 490.1
  5. }

每一个实例都拥有自己的私有字典。

  1. s = Stock('GOOG', 100, 490.1)     # {'name' : 'GOOG','shares' : 100, 'price': 490.1 }
  2. t = Stock('AAPL', 50, 123.45)     # {'name' : 'AAPL','shares' : 50, 'price': 123.45 }

如果你创建了某个类的 100 个实例，那么就会有 100 个存储数据的字典。

类成员

一个单独的字典也存储方法：

  1. class Stock:
  2.     def __init__(self, name, shares, price):
  3.         self.name = name
  4.         self.shares = shares
  5.         self.price = price
  7.     def cost(self):
  8.         return self.shares * self.price
  10.     def sell(self, nshares):
  11.         self.shares -= nshares

使用 Stock.__dict__ 可以查看该字典：

  1. {
  2.     'cost': <function>,
  3.     'sell': <function>,
  4.     '__init__': <function>
  5. }

实例和类

实例和类是链接在一起的。实例通过 __class__ 属性指向类。

  1. >>> s = Stock('GOOG', 100, 490.1)
  2. >>> s.__dict__
  3. { 'name': 'GOOG', 'shares': 100, 'price': 490.1 }
  4. >>> s.__class__
  5. <class '__main__.Stock'>
  6. >>>

实例字典存储的数据对每个实例而言是唯一的。但是，类字典存储的数据被该类的所有实例共享。

属性访问

使用对象时，可以通过 . 运算符访问数据和方法。

  1. x = obj.name          # Getting
  2. obj.name = value      # Setting
  3. del obj.name          # Deleting

这些操作直接与字典绑定到一起。

修改实例

修改对象的操作会更新底层字典：

  1. >>> s = Stock('GOOG', 100, 490.1)
  2. >>> s.__dict__
  3. { 'name':'GOOG', 'shares': 100, 'price': 490.1 }
  4. >>> s.shares = 50       # Setting
  5. >>> s.date = '6/7/2007' # Setting
  6. >>> s.__dict__
  7. { 'name': 'GOOG', 'shares': 50, 'price': 490.1, 'date': '6/7/2007' }
  8. >>> del s.shares        # Deleting
  9. >>> s.__dict__
  10. { 'name': 'GOOG', 'price': 490.1, 'date': '6/7/2007' }
  11. >>>

读取属性

假设你要读取实例上的属性：

  1. x = obj.name

该属性可能位于两个地方：

  • 局部实例字典
  • 类字典

两种字典都会被检查到。首先，检查局部实例字典 __dict__。如果没有找到，通过 __class__ 查找类字典 __dict__。

  1. >>> s = Stock(...)
  2. >>> s.name
  3. 'GOOG'
  4. >>> s.cost()
  5. 49010.0
  6. >>>

通过这样的查找模式，类成员被所有实例共享。

继承的工作原理

一个类可能继承自其它类：

  1. class A(B, C):
  2.     ...

在每个类中，父类存储在一个元组中：

  1. >>> A.__bases__
  2. (<class '__main__.B'>, <class '__main__.C'>)
  3. >>>

子类通过 __bases__ 属性可以链接到父类。

多继承中的属性查找

从逻辑上讲，查找属性的过程如下：首先，检查局部字典 __dict__。如果没有找到，检查类字典 __dict__。如果在类中还是没有找到，通过 __bases__ 属性在父类中查找。这里面有一些小细节，我们接下来讨论。

单继承中的属性查找

在继承层级结构中，通过按顺序遍历继承树来找到属性。

  1. class A: pass
  2. class B(A): pass
  3. class C(A): pass
  4. class D(B): pass
  5. class E(D): pass

在单继承中，因为到达上层父类的路径只有一条，所以当找到第一个匹配的属性时即可停止。

方法解析顺序（MRO）

Python 会预先计算继承链并将其存储到类的 MRO 属性中。你可以像这样查看：

  1. >>> E.__mro__
  2. (<class '__main__.E'>, <class '__main__.D'>,
  3.  <class '__main__.B'>, <class '__main__.A'>,
  4.  <type 'object'>)
  5. >>>

该继承链称为 方法解析顺序（Method Resolution Order）。为了找到属性，Python 按顺序遍历 MRO，第一个匹配的属性即是要找的属性。（译注：有关 MRO 的更多信息，请查看 https://www.python.org/download/releases/2.3/mro/）。

多继承中的方法解析顺序

使用多继承时，到达上层父类的路径有很多条，请看示例：

  1. class A: pass
  2. class B: pass
  3. class C(A, B): pass
  4. class D(B): pass
  5. class E(C, D): pass

访问属性时会发生什么？

  1. e = E()
  2. e.attr

会执行属性查找，那么按什么顺序查找呢？这是个问题。

Python 使用的是 协作多重继承（cooperative multiple inheritance），协作多继承遵守的类排序规则如下：

  • 总是在检查父类之前检查子类
  • 父类（如果有多个）总是按照列出的顺序检查

根据该规则， 通过按层级结构对所有的类进行排序，然后计算出方法解析顺序。

  1. >>> E.__mro__
  2. (
  3.   <class 'E'>,
  4.   <class 'C'>,
  5.   <class 'A'>,
  6.   <class 'D'>,
  7.   <class 'B'>,
  8.   <class 'object'>)
  9. >>>

底层算法称为“C3线性化算法（C3 Linearization Algorithm）”，确切的细节不重要，只要记住类层级结构遵守的排序规则与你家房子着火后必须撤离时遵守的规则相同：首先是孩子，其次是父母。

奇怪的代码重用（涉及多继承）

考虑以下两个完全不相关的对象：

  1. class Dog:
  2.     def noise(self):
  3.         return 'Bark'
  5.     def chase(self):
  6.         return 'Chasing!'
  8. class LoudDog(Dog):
  9.     def noise(self):
  10.         # Code commonality with LoudBike (below)
  11.         return super().noise().upper()

和

  1. class Bike:
  2.     def noise(self):
  3.         return 'On Your Left'
  5.     def pedal(self):
  6.         return 'Pedaling!'
  8. class LoudBike(Bike):
  9.     def noise(self):
  10.         # Code commonality with LoudDog (above)
  11.         return super().noise().upper()

LoudDog.noise() 方法和LoudBike.noise() 方法中有一些通用的代码。事实上，这些通用的代码是完全一样的。自然，这样的代码势必会吸引软件工程师。

“Mixin” 模式

Mixin 模式（pattern）是包含一部分代码片段的类。

  1. class Loud:
  2.     def noise(self):
  3.         return super().noise().upper()

该类不能单独使用。通过继承和其它类混合使用。

  1. class LoudDog(Loud, Dog):
  2.     pass
  4. class LoudBike(Loud, Bike):
  5.     pass

神奇的是，noise() 方法只实现了一次，却在两个完全不相关的类中使用。这种技巧是 Python 多继承的主要用途之一。

为什么使用 super()

当要覆盖一个方法的时候，总是使用 super() 函数。

  1. class Loud:
  2.     def noise(self):
  3.         return super().noise().upper()

super() 函数代表 MRO 中的下一个类（译注：LoudDog 的 MRO 是 LoudDog>Loud>Dog>object。因为 Loud 的父类 object 没有定义 noise() 方法，所以 LoudDog 的实例在 Loud 中找不到 noise() 方法。然后 LoudDog 的实例就会到 MRO 中 Loud 的下一个类 Dog 中寻找）。

麻烦的是你不知道它是什么，尤其是使用多继承的时候。

注意事项

多继承是一种强大的机制。使用这种强大的机制时请牢记“权利越大，责任越大”。有时候，框架或者库使用多继承来实现一些高级特性，如组件组合。

练习

在第 4 节中，定义了一个表示股票持有信息的类 Stock。在本节练习中，我们将使用该类。请重新启动解释器并创建一些 Stock 类的实例：

  1. >>> ================================ RESTART ================================
  2. >>> from stock import Stock
  3. >>> goog = Stock('GOOG',100,490.10)
  4. >>> ibm  = Stock('IBM',50, 91.23)
  5. >>>

练习 5.1：实例的表示

在交互式 shell 中，检查 goog 和 ibm 两个实例的底层字典：

  1. >>> goog.__dict__
  2. ... look at the output ...
  3. >>> ibm.__dict__
  4. ... look at the output ...
  5. >>>

练习 5.2：修改实例属性

尝试给上述其中一个实例添加新属性：

  1. >>> goog.date = '6/11/2007'
  2. >>> goog.__dict__
  3. ... look at output ...
  4. >>> ibm.__dict__
  5. ... look at output ...
  6. >>>

在上述输出中，你会发现 goog 实例具有 date 属性，但是 ibm 实例没有。重要的是要注意，Python 对实例属性确实没有任何限制。例如，实例属性不限于 __init__() 方法中设置的属性。

尝试直接添加一个新的值到 __dict__ 对象中：

  1. >>> goog.__dict__['time'] = '9:45am'
  2. >>> goog.time
  3. '9:45am'
  4. >>>

在这里，你会发现一个事实，实例仅仅是字典顶部的一层。注意：应该强调的是，直接操作字典并不常见——你应该始终使用语法 (.) 编写代码。

练习 5.3：类的作用

类中的定义被类的所有实例所共享。所有的实例都有一个链接，指向它们的关联类：

  1. >>> goog.__class__
  2. ... look at output ...
  3. >>> ibm.__class__
  4. ... look at output ...
  5. >>>

尝试在实例上调用方法：

  1. >>> goog.cost()
  2. 49010.0
  3. >>> ibm.cost()
  4. 4561.5
  5. >>>

名字 ‘cost’ 既不在 goog.__dict__ 中定义，也不在 ibm.__dict__中定义。相反，而是由类字典提供的。请尝试以下代码：

  1. >>> Stock.__dict__['cost']
  2. ... look at output ...
  3. >>>

尝试直接通过字典调用 cost() 方法：

  1. >>> Stock.__dict__['cost'](goog)
  2. 49010.0
  3. >>> Stock.__dict__['cost'](ibm)
  4. 4561.5
  5. >>>

你是如何调用类中定义的函数，那么 self 就是怎么调用实例的。

尝试给 Stock 类添加新属性：：

  1. >>> Stock.foo = 42
  2. >>>

该新属性会出现在所有实例中：

  1. >>> goog.foo
  2. 42
  3. >>> ibm.foo
  4. 42
  5. >>>

但是，foo 并不属于实例字典：

  1. >>> goog.__dict__
  2. ... look at output and notice there is no 'foo' attribute ...
  3. >>>

你可以访问 foo 属性的原因是：当 Python 在实例字典中查找不到某个属性时，那么它就会到类字典中查找。

注意：本部分主要阐明什么是类变量。假设你有这样一个类：

  1. class Foo(object):
  2.      a = 13                  # Class variable
  3.      def __init__(self,b):
  4.          self.b = b          # Instance variable

在 Foo 类中，因为变量 a 在类体（body of the class）中被赋值，所以 a 是“类变量（class variable）”。变量 a 可以被 Foo 类的所有实例所共享。示例：

  1. >>> f = Foo(10)
  2. >>> g = Foo(20)
  3. >>> f.a          # Inspect the class variable (same for both instances)
  4. 13
  5. >>> g.a
  6. 13
  7. >>> f.b          # Inspect the instance variable (differs)
  8. 10
  9. >>> g.b
  10. 20
  11. >>> Foo.a = 42   # Change the value of the class variable
  12. >>> f.a
  13. 42
  14. >>> g.a
  15. 42
  16. >>>

练习 5.4：绑定方法

Python 有一个微妙的特性：调用方法实际上涉及两个步骤以及一个称为绑定方法的东西。示例：

  1. >>> s = goog.sell
  2. >>> s
  3. <bound method Stock.sell of Stock('GOOG', 100, 490.1)>
  4. >>> s(25)
  5. >>> goog.shares
  6. 75
  7. >>>

实际上，绑定方法包含调用一个方法的所需的所有内容。例如，它们记录了实现方法的函数：

  1. >>> s.__func__
  2. <function sell at 0x10049af50>
  3. >>>

这与在 Stock 字典中找到的值是一样的：

  1. >>> Stock.__dict__['sell']
  2. <function sell at 0x10049af50>
  3. >>>

绑定方法还记录实例，即 self：

  1. >>> s.__self__
  2. Stock('GOOG',75,490.1)
  3. >>>

你可以使用 () 一起调用所有的函数。例如，调用 s(25) 实际是这样做的：

  1. >>> s.__func__(s.__self__, 25)    # Same as s(25)
  2. >>> goog.shares
  3. 50
  4. >>>

练习 5.5：继承

创建一个继承自 Stock 的类：

  1. >>> class NewStock(Stock):
  2.         def yow(self):
  3.             print('Yow!')
  5. >>> n = NewStock('ACME', 50, 123.45)
  6. >>> n.cost()
  7. 6172.50
  8. >>> n.yow()
  9. Yow!
  10. >>>

通过扩展属性的搜索过程来实现继承。__bases__ 属性是一个包含直接父类的元组：

  1. >>> NewStock.__bases__
  2. (<class 'stock.Stock'>,)
  3. >>>

__mro__ 属性是一个包含所有父类的元组，父类按查找顺序排列。

  1. >>> NewStock.__mro__
  2. (<class '__main__.NewStock'>, <class 'stock.Stock'>, <class 'object'>)
  3. >>>

实例 n 是这找到 cost() 方法的： 

  1. >>> for cls in n.__class__.__mro__:
  2.         if 'cost' in cls.__dict__:
  3.             break
  5. >>> cls
  6. <class '__main__.Stock'>
  7. >>> cls.__dict__['cost']
  8. <function cost at 0x101aed598>
  9. >>>

目录 | 上一节 (4.4 异常) | 下一节 (5.2 封装)