第七章 类及面向对象编程

类 是用来创建数据结构和新类型对象的主要机制.本章的主题就是类,面向对象编程和设计不是本章的重点。本章假定你具有数据结构的背景知识及一定的面向对象的 编程经验(其它面向对象的语言，比如java,c++).(参见第三章,类型和对象 了解对象这个术语及其内部实现的附加信息)

WeiZhong补充：
 这本书出版于2001年，虽然Python有极佳的向下兼容性，但我们应该学习最新的知识。本章很多地方已经明显过时，为了保证大家学到新的知识并维持这本书的完整性，我会在必要的地方说明哪些地方已经过时，哪些地方新增了功能。
 Python从2.2起引入了new-style对象模型，以逐步替代已经使用多年的classic对象模型。
 由于 classic class 已经行将废止，所以我对本章的例子均作为了适当的修改以支持 new-style对象模型。 

参考文档:《Python In a Nutshell》中的一节Python中的新型类及其实例

1.1. class语句

一个类定义了一系列与其实例对象密切关联的属性.典型的属性包括变量(也被称为类变量)和函数(又被称为方法).

class语句用来定义一个类.类的主体中语句在类定义同时执行.(如 Listing 7.1)

Listing 7.1 类

 1 class Account(object):
 2  "一个简单的类"
 3  account_type = "Basic"
 4  def __init__(self,name,balance):
 5  "初始化一个新 Account 实例"
 6  self.name = name
 7  self.balance = balance
 8  def deposit(self,amt):
 9  "存款"
 10  self.balance = self.balance + amt
 11  def withdraw(self,amt):
 12  "取款"
 13  self.balance = self.balance - amt
 14  def inquiry(self):
 15  "返回当前余额"
 16  return self.balance

1.2. 访问类属性

类对象作为一个名字空间，存放在类定义语句运行时创建的对象.例如,Account里的内容可以这样访问:

Account.account_type
Account.__init__
Account.deposit
Account.withdraw
Account.inquiry

需要注意的是, class语句并不创建类的实例(例如上边的例子,并没有创建任何帐户).它用来定义所有实例都应该有的属性.

在 类中定义的常规方法的第一个参数总是该类的实例,通常这个参数记为self。你也可能用其它任何合法的变量名，不过为了符合惯例，你最好还是用self. 类中定义的变量,即类变量，如account_type, 它被所有该类的实例共享. 虽然类定义了一个名字空间,但这个名字空间并不是为类主体中的代码服务的.因此在类中引用一个类的属性必须使用类的全名:

 1 class Foo(object):
 2  def bar(self):
 3  print "bar!"
 4  def spam(self):
 5  bar(self) # 错误,引发NameError
 6  Foo.bar(self) # 合法的

最后，你不能定义一个不操作实例的方法:

 1 class Foo(object):
 2  def add(x,y):
 3  return x+y
 4 a = Foo.add(3,4) # TypeError. 需要一个类实例作为第一个参数

=======================================================================================

以下为WeiZhong增补部分： 静态方法和类方法(Python2.2以上)

• 静态方法: 可 以直接被类或类实例调用。它没有常规方法那样的特殊行为（绑定、非绑定、默认的第一个参数规则等等）。你完全可以将静态方法当成一个用属性引用方式调用的 普通函数。任何时候定义静态方法都不是必须的（静态方法能实现的功能都可以通过定义一个普通函数来实现）. 有些程序员认为，当有一堆函数仅仅为某一特定类编写时，将这些函数包装成静态这种方式可以提供使用上的一致性。

根据python2.4最新提供的新语法，你可以用下面的方式创建一个静态方法：

class AClass(object):
 @staticmethod #静态方法修饰符，表示下面的方法是一个静态方法
 def astatic( ): print 'a static method'
anInstance = AClass( )
AClass.astatic( ) # prints: a static method
anInstance.astatic( ) # prints: a static method

注:staticmethod是一个内建函数,用来将一个方法包装成静态方法,在2.4以前版本,只能用下面这种方式定义一个静态方法(不再推荐使用):

class AClass(object):
 def astatic( ): print 'a static method'
 astatic=staticmethod(astatic)

这种方法在函数定义本身比较长时经常会忘记后面这一行.

• 类方法 一个类方法就可以通过类或它的实例来调用的方法, 不管你是用类来调用这个方法还是类实例调用这个方法,该方法的第一个参数总是定义该方法的类对象。 记住:方法的第一个参数都是类对象而不是实例对象. 按照惯例,类方法的第一个形参被命名为 cls. 任何时候定义类方法都不是必须的（类方法能实现的功能都可以通过定义一个普通函数来实现,只要这个函数接受一个类对象做为参数就可以了）. 你可以象下面这样来生成一个类方法:

class ABase(object):
 @classmethod #类方法修饰符
 def aclassmet(cls): print 'a class method for', cls.__name__
class ADeriv(ABase): pass
bInstance = ABase( )
dInstance = ADeriv( )
ABase.aclassmet( ) # prints: a class method for ABase
bInstance.aclassmet( ) # prints: a class method for ABase
ADeriv.aclassmet( ) # prints: a class method for ADeriv
dInstance.aclassmet( ) # prints: a class method for ADeriv

注:classmethod是一个内建函数,用来将一个方法封装成类方法,在2.4以前版本,你只能用下面的方式定义一个类方法:

class AClass(object):
 def aclassmethod(cls): print 'a class method'
 aclassmethod=classmethod(aclassmethod)

并没有人要求必须封装后的方法名字必须与封装前一致,但建议你总是这样做(如果你使用python2.4版本以下时). 这种方法在函数定义本身比较长时经常会忘记后面这一行.

=======================================================================================

增补部分至此结束

1.3. 类实例

像调用函数一样调用类，可以得到类的实例。生成实例的过程会自动调用类的__init__方法（如果你的类定义了这个方法的话）。

 1 # 创建一些帐户
 2 a = Account("Guido", 1000.00) # 调用 Account.__init__(a,"Guido",1000.00)
 3 b = Account("Bill", 100000000000L)

实例创建之后,就可以使用点(.)操作符来访问它的属性和方法:

 1 a.deposit(100.00) # 调用 Account.deposit(a,100.00)
 2 b.withdraw(sys.maxint) # 调用 Account.withdraw(b,sys.maxint)
 3 name = a.name # 得到帐户名称
 4 print a.account_type # 显示帐户类型

在系统内部,每个类实例都拥有一个字典(即实例的 dict 属性,在第三章中有介绍).这个字典包含每个实例的信息.例如:

>>> print a.__dict__
{'balance': 1100.0, 'name': 'Guido'}
>>> print b.__dict__
{'balance': 97852516353L, 'name': 'Bill'}

若一个实例的属性被修改,这个字典也随之改变.上例中，属性通过Account类中定义的方法__init()__, deposit(),以及withdraw()中对self变量赋值被改变. 不过对于类实例可以随时添加私有属性。

a.number = 123456 # 把 'number' 加入到 a.__dict__

属性的赋值总是发生在实例字典中,而属性访问则比属性赋值复杂一些。当访问一个属性的时候,解释器首先在实例的字典中搜索，若找不到则去创建这个实例的类的字典中搜索，若还找不到就到类的基类中搜索(在后边 '继承' 一节中会讲到)，如果还找不到最后会尝试调用类的__getattr__方法来获取属性值(若类中定义了该方法的话).如果这个过程也失败,则引发AttributeError异常

1.4. 引用记数与实例销毁

所有实例都是引用记数的.若一个实例引用记数变成零,该实例就被销毁.当实例将被销毁前,解释器会搜索该对象的 __del__方法并调用它。但在实际应用中,极少有需要给一个类定义__del__方法, 除非这个对象在销毁前需要执行一些清除操作(如关闭文件,断开网络,或者释放其他系统资源).即使是在这种情况下,依赖__del__()来执行清除和关闭操作也是危险的，因为不能保证在解释器关闭时会自动调用这个方法.更好的选择是定义一个close()方法,在需要时显式的调用这个方法来执行这个过程. 最后注意一点, 如果一个实例拥有__del__方法，则它永远不会被Python的垃圾收集器回收(这也是不推荐定义 __del__()的理由).关于垃圾回收请参阅附录A中的gc模块。

有时会使用del语句来删除对象的引用，如果这导致该对象引用记数变为零,就会自动调用__del__(). del语句并不直接调用__del__().

1.5. 继承

继 承(Inheritance)是创建新类的机制之一,它通过一个已有类进行修改和扩充来生成新类。这个原始的类被称为基类(base class)或超类(superclass).新生成的类称为该类的派生类(derived class)或子类(subclass).当通过继承创建一个类时,它会自动'继承'在基类中定义的属性。一个子类也可以重新定义父类中已有的属性或定义 新的属性.

Python支持多继承，如果一个类有多个父类，在class语句中就使用逗号来分隔这个父类列表。例如:

 1 class D(oject): pass #D继承自object
 2 class B(D): #B是D的子类
 3  varB = 42
 4  def method1(self):
 5  print "Class B : method1"
 6 class C(D): #C也是D的子类
 7  varC = 37
 8  def method1(self):
 9  print "Class C : method1"
 10  def method2(self):
 11  print "Class C : method2"
 12 class A(B,C): #A是B和C的子类
 13  varA = 3.3
 14  def method3(self):
 15  print "Class A : method3"

当搜索在基类中定义的某个属性时，Python采用深度优先的原则、按照子类定义中的基类顺序进行搜索。**注意**（new-style类已经改变了这种行为）。上边例子中，如果访问 A.varB ,就会按照A-B-D-C-D这个顺序进行搜索，只要找到就停止搜索.若有多个基类定义同一属性的情况,则只使用第一个被找到属性值:

 1 a = A() # 创建 'A' 的实例
 2 a.method3() # 调用 A.method3(a)
 3 a.method1() # 调用 B.method1(c)
 4 a.varB # 得到 B.varB

重要提示：新旧对象模型的差异:

 注意：Python 中现在有两种对象模型均在使用中即classic对象模型和new-style对象模型，也有两种类：classic class 及 new-style class
 在classic对象模型中,方法和属性按 从左至右 深度优先 的顺序查找（上文中已经提到）.显然,当多个父类继承自同一个基类时,这会产生我们不想要的结果.
 就上例来说,D是一个new-style类（继承自object），B和C是D的子类, 而A是B和C的子类,如果按classic对象模型(原文中的提到的对象模型)的属性查找规则是搜索顺序是 A-B-D-C-D. 由于Python先查找D后查找C,即使C对D中的属性进行了重定义,也只能使用D中定义的版本.这是classic数据模型的固有问题,在实际应用中会造成一些麻烦.为了解决这个及其它一些问题，Python从2.2版本开始引入new-style对象模型。

 在new-style对象模型中,所有内建类型均是object的直接或间接子类. new-style对象模型改变了传统对象模型中的解析顺序,上面的例子我已经改写为new-style类,因此,这个例子实际的搜索顺序是 A-B-C-D.

 每个内建类型及new-style类均内建有一个特殊的只读属性 `__mro__ `,这是一个tuple,它保存着方法解析类型. 只能通过类来引用 `__mro__`(通过实例无法访问).
 --WeiZhong Added@20060210

如果一个子类定义了一个和基类具有相同名称的属性,则子类的实例将使用子类中定义的属性.如果需要访问原来的属性,则必须使用全名来限制访问区域:

 1 class D(A):
 2  def method1(self):
 3  print "Class D : method1"
 4  A.method1(self) # 调用基类属性

需要注意的一点是子类实例的初始化.当一个子类实例被创建时, 基类的 init()方法并不会被自动调用.也就是子类必须自力更生来解决实例的初始化.例如:

 1 class D(A):
 2  def __init__(self, args1):
 3  # 初始化基类
 4  A.__init__(self)
 5  # 初始化自己
 6  ...

__del__() 与 __init__() 类似.

1.6. 多态

Python通过上文中提到的属性查询规则来实现多态.当使用obj.method() 来访问一个方法时,方法的搜索顺序为:实例的 dict 属性,实例的类定义,基类. 第一个被找到的方法被执行。

1.7. 数据隐藏

默认情况下,所有的属性都是'公开'的.这意味着一个类的所有属性均可不受任何限制的访问.这也意味着基类中定义的所有内容都能被子类继承。 在面向对象编程实践中，这种行为是我们不希望的。因为它不但暴露了对象的内部实现，而且容易在派生类对象及基类对象之间产生名字空间冲突。

要解决这个问题,只需要在类中将需要隐藏的属性名字以两个下划线开头,例如 __Foo。这样系统会自动实时生成一个新的名字 _Classname__Foo 并用于内部使用。这样在某种程度上就提供了私有属性(其实这个 _Classname__Foo 仍然是不受限制访问的嘿嘿),也解决了名字空间冲突的问题.例如:

 1 class A:
 2  def __init__(self):
 3  self.__X = 3 # self._A__X
 4 
 5 class B(A):
 6  def __init__(self):
 7  A.__init__(self)
 8  self.__X = 37 # self._B__X

这是一个小技巧,并没有真正阻止访问一个类的*私有*属性.如果已知一个类的名称和它某个私有属性的名称,我们还是可以使用_Classname__Foo 来访问到这个属性.(这不是bug,因为在某些特定的场合这非常有用,比如调试时,所以系统一直保留这个所谓的*问题*)

1.8. 操作符重载

用户自定义对象可以通过在类中实现特殊方法(第三章中已介绍)来重载Python内建操作符.例如 Listing 7.2 中的类,它使用标准的数学运算符实现了复数的运算及类型转换.

Listing 7.2 数学运算及类型转换

 1 class Complex(object):
 2  def __init__(self,real,imag=0):
 3  self.real = float(real)
 4  self.imag = float(imag)
 5  def __repr__(self):
 6  return "Complex(%s,%s)" % (self.real, self.imag)
 7  def __str__(self):
 8  return "(%g+%gj)" % (self.real, self.imag)
 9  # self + other
 10  def __add__(self,other):
 11  return Complex(self.real + other.real, self.imag + other.imag)
 12  # self - other
 13  def __sub__(self,other):
 14  return Complex(self.real - other.real, self.imag - other.imag)
 15  # -self
 16  def __neg__(self):
 17  return Complex(-self.real, -self.imag)
 18  # other + self
 19  def __radd__(self,other):
 20  return Complex.__add__(other,self)
 21  # other - self
 22  def __rsub__(self,other):
 23  return Complex.__sub__(other,self)
 24  # 将其他数值类型转换为复数
 25  def __coerce__(self,other):
 26  if isinstance(other,Complex):
 27  return self,other
 28  try: # 检测是否可以被转换为浮点数
 29  return self, Complex(float(other))
 30  except ValueError:
 31  pass

在这个例子中,有一些值得研究的地方:

• 首先__repr__() 用于返回对象的表达式字符串表示,这个返回字符串可以用于再次得到该对象.在本例中,会创建一个类似"Complex(r,i)"的字符串.另外__str__()方法创建一个字符串用于较美观的输出。(通常用于print语句)

  然后,要处理复数在运算符左边或右边这两种情况,必须同时提供 __op__()和 __rop__()方法.

  最后, __ceorco__ 方法用于处理混合类型运算.在本例中,其他的数值类型均被转换为复数,这样才可以继续进行复数的运算.

1.9. 类,类型,和成员检测

目前,类型和类是分开的.内建类型,如列表和字典是不能被继承的,类也不能定义一个新类型.事实上,所有的类定义都属于ClassType类型,同样地,类的实例属于InstanceType类型.所以,下面这个表达式对于两个类永远为真(即使这两个实例是由不同的类创建的): type(a) == type(b)

 Python 2.4 已经支持内建类型的继承，类与类型还有差别，但越来越微妙了。
 对 new-style 类来说，类的实例并不是 InstanceType 类型。它的类型与类的名字有关。也因此，对new-style类来说，上面的等式只有同一个类的两个不同实例才为真。 --WeiZhong

内建函数isinstance(obj ,cname)用来测试obj对象是否是cname的实例。.如果是,函数就返回True.例如:

 1 class A(object): pass
 2 class B(A): pass
 3 class C(object): pass
 4 
 5 a = A() # 'A'的实例
 6 b = B() # 'B'的实例 
 7 c = C() # 'C'的实例 
 8 
 9 isinstance(a,A) # 返回 True
 10 isinstance(b,A) # 返回 True, B 源自 A
 11 isinstance(b,C) # 返回 False, C 与 A 没有派生关系

同样地,内建函数issubclass(A ,B)用来测试类A是否是类B的子类:

issubclass(B,A) # 返回 True
issubclass(C,A) # 返回 False
issubclass(A,A) # 永远返回True

isinstance()函数也可以用于检查任意内建类型:

 1 import types
 2 isinstance(3, types.IntType) # 返回 True
 3 isinstance(3, types.FloatType) # 返回 False

这是一个被推荐的类型检查方法,这样类型和类的差别就可以忽略.