第七章 类及面向对象编程

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

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

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

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

访问类属性

类对象作为一个名字空间,存放在类定义语句运行时创建的对象.例如,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)

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

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版本以下时). 这种方法在函数定义本身比较长时经常会忘记后面这一行.

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

增补部分至此结束

类实例

像调用函数一样调用类,可以得到类的实例。生成实例的过程会自动调用类的__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异常

引用记数与实例销毁

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

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

继承

继承(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__() 类似.

多态

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

数据隐藏

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

要解决这个问题,只需要在类中将需要隐藏的属性名字以两个下划线开头,例如 __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,因为在某些特定的场合这非常有用,比如调试时,所以系统一直保留这个所谓的*问题*)

操作符重载

用户自定义对象可以通过在类中实现特殊方法(第三章中已介绍)来重载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

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

类,类型,和成员检测

目前,类型和类是分开的.内建类型,如列表和字典是不能被继承的,类也不能定义一个新类型.事实上,所有的类定义都属于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

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


::-andelf(Feather) 修改了个别排版错误