Python基础：18类和实例之二

        1：绑定和非绑定

        当存在一个实例时，方法才被认为是绑定到那个实例了。没有实例时方法就是未绑定的。在很多情况下，调用的都是一个绑定的方法。

 

        调用非绑定方法并不经常用到，其中一个主要的场景是：派生一个子类，而且要覆盖父类的方法，这时需要调用那个父类中被覆盖掉的构造方法：

class  EmplAddrBookEntry(AddrBookEntry):

        'Employee Address Book Entry class'

        def  __init__(self, nm,  ph,  em):

                AddrBookEntry.__init__(self,  nm,  ph)

                self.empid  =  id

                self.email  =  em

 

        EmplAddrBookEntry是AddrBookEntry 的子类，重载了__init__()。这是调用非绑定方法的最佳地方了。

        当一个EmplAddrBookEntry被实例化，并且调用 __init__() 时，其与AddrBookEntry的实例只有很少的差别，主要是因为我们还没有机会来自定义我们的EmplAddrBookEntry 实例，以使它与AddrBookEntry 不同。所以，可以将EmplAddrBookEntry实例传递给AddrBookEntry的__init__。

        子类中 __init__() 的第一行就是对父类__init__()的调用。通过父类名来调用它，并且传递给它 self 和其他所需要的参数。一旦调用返回，我们就能定义那些与父类不同的仅存在我们的（子）类中的（实例）定制。

 

        2：静态方法和类方法

        静态方法和类方法在Python2.2中引入。经典类及新式(new-style)类中都可以使用它。

 

        Python中的静态方法和C++或者Java这些语言中的是一样的。它们仅是类中的函数(不需要实例)。

        对于类方法而言，需要类而不是实例作为第一个参数，它是由解释器传给方法。类不需要特别地命名,类似self，不过很多人使用cls作为变量名字。

 

        下面是在经典类中创建静态方法和类方法的一些例子（也可以把它们用在新式类中）：

class  TestStaticMethod:

        def  foo():

                print  'calling  static  method foo()'

        foo  =  staticmethod(foo)

 

class  TestClassMethod:

        def  foo(cls):

                print  'calling  class  method foo()'

                print  'foo()  is  part of  class:',  cls.__name__

        foo  =  classmethod(foo)

        内建函数staticmethod和classmethod将它们转换成相应的类型，并且重新赋值给了相同的变量名。如果没有调用这两个函数，二者都会在Python 编译器中产生错误，显示需要带self 的常规方法声明。 可以通过类或者实例调用这些函数：

>>> tsm  =  TestStaticMethod()

>>>TestStaticMethod.foo()

calling  static  method foo()

>>>tsm.foo()

calling  static  method  foo()

 

>>> tcm  =  TestClassMethod()

>>>TestClassMethod.foo()

calling  class  method foo()

foo()  is  part of  class: TestClassMethod

>>>tcm.foo()

calling  class  method foo()

foo()  is  part of  class:  TestClassMethod

 

        通过使用修饰符，可以避免像上面那样的重新赋值：

class  TestStaticMethod:

        @staticmethod

        def  foo():

                print  'calling  static  method foo()'

class  TestClassMethod:

        @classmethod

        def  foo(cls):

                print  'calling  class  method foo()'

                print  'foo()  is  part of  class:',  cls.__name__

 

        3：有两种方法可以在代码中利用类。第一种是组合(composition)。就是让不同的类混合并加入到其它类中，来增加功能和代码重用性。另一种方法是通过派生。

 

        组合的例子如下：

class  NewAddrBookEntry(object):   

        'new  address  book  entry class'

        def  __init__(self, nm,  ph):  

                self.name  =  Name(nm)         #创建Name实例

                self.phone  =  Phone(ph)         #创建Phone实例

                print  'Created  instance  for:',  self.name

 

        NewAddrBookEntry类由其它类组合而成。这就在一个类和其它组成类之间定义了一种“有一个”的关系。比如，我们的NewAddrBookEntry 类“有一个” Name 类实例和一个Phone实例。

 

        4：子类和派生

        OOP的更强大方面之一是能够使用一个已经定义好的类，扩展它或者对其进行修改，而不会影响系统中使用现存类的其它代码片段。允许类特征在子孙类或子类中进行继承。

        新式类创建子类的语法：

class  SubClassName (ParentClass1[, ParentClass2,...]):

        'optional  class  documentation  string'

        class_suite

        如果你的类没有从任何祖先类派生，可以使用object 作为父类的名字。

 

        经典类的声明唯一不同之处在于其没有从祖先类派生－－此时，没有圆括号：

class  ClassicClassWithoutSuperclasses:

        pass

 

        下面还有一个简单的例子：

class  Parent(object):          

        def  parentMethod(self):

                print  'calling  parent  method'

 

class  Child(Parent):            

        def  childMethod(self):

                print  'calling  child  method'

>>> p  =  Parent()                    

>>> p.parentMethod()

calling  parent  method

>>> 

>>> c  =  Child()

>>> c.childMethod()                     

calling  child  method

>>>c.parentMethod()   

calling  parent  method

 

        5：继承

        一个子类可以继承它的基类的任何属性，不管是数据属性还是方法。举个例子如下。P 是一个没有属性的简单类。C 从P 继承而来，也没有属性：

class  P(object):

        pass

class  C(P):

        pass

>>> c  =  C()

>>> c.__class__

<class  '__main__.C'>

>>>C.__bases__

(<class  '__main__.P'>,)

 

        下面给 P 添加一些属性：

class  P:

         'P  class'

        def  __init__(self):

                print  'created  an  instance of',  self.__class__.__name__

class  C(P):

        pass

 

        现在P 有文档字符串__doc__和__init__：

>>> p  =  P()

created  an  instance of  P

>>> p.__class__

<class  '__main__.P'>

>>> P.__bases__

(<type  'object'>,)

>>> P.__doc__

'P  class'

 

>>> c  =  C()

created  an  instance of  C

>>> c.__class__

<class  '__main__.C'>

>>> C.__bases__

(<class  '__main__.P'>,)

>>>C.__doc__

>>> 

        C没有声明__init__()方法，然而在类C 的实例c 被创建时，还是会有输出信息。原因在于C 继承了P 的__init__()。

需要注意的是,文档字符串对类，函数/方法，还有模块来说都是唯一的，所以特殊属性__doc__不会从基类中继承过来。

 

        对任何(子）类，其__bases__类属性是一个包含其父类（parent）的集合的元组。

        那些没有父类的类，它们的__bases__属性为空。下面我们看一下如何使用__bases__的。

 

>>> class  A(object):  pass

...

>>> class  B(A):  pass

...

>>> class  C(B):  pass

...

>>> class  D(A, B):  pass

...

>>> A.__bases__

(<type  'object'>, )

>>> B.__bases__

(<class  '__main__.A'>,)

>>> C.__bases__

(<class  '__main__.B'>,)

>>> D.__bases__

(<class  '__main__.B'>,  <class  '__main__.A'>)

 

        在上面的例子中，尽管C 是A 和B 的子类（通过B 传递继承关系），但C的父类是B，所以，只有B 会在C.__bases__中显示出来。

 

        在父类 P 中再写一个函数，然后在其子类中对它进行覆盖：

class  P(object):

        def  foo(self):

                print  'Hi,  I  am  P-foo()'

>>> p  =  P()

>>> p.foo()

Hi,  I  am  P-foo()

 

class  C(P):

        def  foo(self):

                print  'Hi,  I  am  C-foo()'

>>> c  =  C()

>>> c.foo()

Hi,  I  am  C-foo()

        尽管C继承了P 的foo()方法，但因为C 定义了它自已的foo()方法，所以 P 中的foo() 方法被覆盖。

        尽管父类中的foo被覆盖了，但是还是可以调用那个被覆盖的基类方法。这时就需要去调用一个未绑定的基类方法，需要明确给出子类的实例，例如下边：

>>> P.foo(c)

Hi,  I am  P-foo()

 

        典型情况下,你不会以这种方式调用父类方法,你会在子类的重写方法里显式地调用基类方法。

class  C(P):

        def  foo(self):

                P.foo(self)

                print  'Hi, I am C-foo()'

 

        在这个（未绑定）方法调用中我们显式地传递了self. 一个更好的办法是使用super()内建方法：

class  C(P):

        def  foo(self):

                super(C,  self).foo()

                print  'Hi,  I am C-foo()'

 

        super()不但能找到基类方法，而且还为我们传进self：

>>> c  =  C()

>>> c.foo()

Hi,  I  am  P-foo()

Hi,  I  am  C-foo()

 

        类似于上面的覆盖非特殊方法，当从一个带__init()__的类派生，如果不覆盖__init__()，它将会被继承并自动调用。但如果在子类中覆盖了__init__()，子类被实例化时基类的__init__()就不会被自动调用。

class  P(object):

        def  __init__(self):

                print  "calling  P's  constructor"

class  C(P):

        def  __init__(self):

                print  "calling  C's  constructor"

>>> c  =  C()

calling  C's  constructor

        如果还想调用基类的 __init__()，需要明确指出，使用一个子类的实例去调用基类（未绑定）方法。相应地更新类C，会出现下面预期的执行结果：

class  C(P):

        def  __init__(self):

                P.__init__(self)

                print  "calling C's  constructor"

>>> c  =  C()

calling  P's  constructor

calling  C's  constructor

        上边的例子中，子类的__init__()方法首先调用了基类的的__init__()方法。这是相当普遍（不是强制）的做法，用来设置初始化基类，然后可以执行子类内部的设置。super()内建函数引入到Python中，可以这样写：

class  C(P):

        def  __init__(self):

                super(C,  self).__init__()

                print  "calling  C's  constructor"

        使用super()的漂亮之处在于，不需要明确提供父类。这意味着如果改变了类继承关系，只需要改一行代码（class 语句本身）而不必在大量代码中去查找所有被修改的那个类的名字。

 

        如果一个类的构造方法被重写，那么就需要调用超类(你所继承的类)的构造方法，否则对象可能不会被正确地初始化。比如下面的例子：

>>> class  Bird:

...     def  __init__(self):

...        self.hungry=True

...     def  eat(self):

...        if  self.hungry:

...            print  'aaah...'

...            self.hungry=False

...        else:

...            print  'no thanks'

>>> b=Bird()

>>> b.eat()

aaah...

>>> b.eat()

no  thanks

 

        现在考虑子类SongBird，它添加了唱歌的行为:

>>> class  SongBird(Bird):

...     def  __init__(self):

...        self.sound='Squawk'

...     def  sing(self):

...        print  self.sound

...

>>> s=SongBird()

>>> s.sing()

Squawk

        因为SongBird是Bird的一个子类，它继承了eat方法，但如果调用eat方法，就会产生一个问题:

>>> s.eat()

Traceback (most recent calllast):

File"<input>", line 1, in <module>

File"<input>", line 5, in eat

AttributeError:SongBird instance has no attribute 'hungry'

        原因是：在SongBird中，构造方法被重写，但新的构造方法没有任何关于初始化hungry特性的代码。为了达到预期的效果，SongBird的构造方法必须调用其超类Bird的构造方法来确保进行基本的初始化。

        6：继承标准类型

        经典类中的一个问题是，不能对标准类型进行子类化。幸运的是，随着类型（types）和类（class）的统一和新式类的引入。这一点已经被修正。下面，介绍两个子类化Python 类型的相关例子。

        一个处理浮点数的子类，它带两位小数位：

class  RoundFloat(float):

        def  __new__(cls,  val):

                return  float.__new__(cls,  round(val,  2))

 

        覆盖__new__()特殊方法来定制对象，使之和标准Python 浮点数（float）有一些区别。最好是使用super()内建函数去捕获对应的父类以调用它的__new()__方法，下面，对它进行这方面的修改：

class  RoundFloat(float):

        def  __new__(cls,  val):

                return  super(RoundFloat,  cls).__new__(cls,  round(val,  2))

 

下面是一些样例输出：

>>>RoundFloat(1.5955)

1.6

>>>RoundFloat(1.5945)

1.59

>>>RoundFloat(-1.9955)

-2.0

        object.__new__(cls, ...)，它会创建cls的实例，__new__是静态方法（因其特殊性，不需要显示声明）。而且它的第一个参数是要创建实例的类型。他返回一个cls的实例。

        一般的用法中，创建子类的实例，可以调用父类的new：

super(currentcls, cls).__new__(cls, ...)。比如：

float.__new__(cls, 3.456)，创建的就是cls的实例。

 

        7：多重继承

        Python允许子类继承多个基类。也就是多重继承。这里的难点在于：如何正确找到没有在当前（子）类定义的属性。也就是所谓的：方法解释顺序（MRO）。

        在Python 2.2 以前的版本中，算法非常简单：深度优先，从左至右进行搜索，多重继承则取找到的第一个名字。

        由于类，类型和内建类型的子类，都经过全新改造, 有了新的结构，这种算法不再可行。这样一种新的MRO 算法被开发出来，新的查询方法是采用广度优先，而不是深度优先。

        下面的示例，展示经典类和新式类中，方法解释顺序有什么不同。

class  P1:   #（object）

        def  foo(self):

                print  'called  P1-foo()'

class  P2:   #（object）

        def  foo(self):

                print  'called  P2-foo()'

        def  bar(self):

                print  'called P2-bar()'

class  C1(P1,  P2):          pass

class  C2(P1,  P2):

        def  bar(self):

                print  'called  C2-bar()'

class  GC(C1,  C2):       pass

 

    上面这些类的关系如下图所示：

 

        首先来使用经典类，可以验证经典类使用的解释顺序，深度优先，从左至右：

>>> gc  =  GC()

>>> gc.foo()                            # GC ==> C1 ==> P1

called  P1-foo()

>>> gc.bar()                            # GC ==> C1 ==> P1 ==> P2

called  P2-bar()

 

        当调用foo()时，它首先在当前类(GC)中查找。如果没找到，就向上查找最亲的父类，C1。查找未遂，就继续沿树上访到父类P1，foo()被找到。

        同样，对bar()来说，它通过搜索GC，C1，P1 然后在P2 中找到。因为使用这种解释顺序的缘故，C2.bar()根本就不会被搜索了。

        如果需要调用C2 的bar()方法，则必须调用它的合法的全名，采用典型的非绑定方式去调用，并且提供一个合法的实例：

>>> C2.bar(gc)

called  C2-bar()

 

        对于新式类，取消类P1 和类P2 声明中的对(object)的注释，重新执行一下。新式方法的查询有一些不同：

>>> gc  =  GC()

>>> gc.foo()                            # GC==> C1 ==> C2 ==> P1

called  P1-foo()

>>> gc.bar()                            # GC ==> C1 ==> C2

called  C2-bar()

        与沿着继承树一步一步上溯不同，它首先查找同胞兄弟，采用一种广度优先的方式。当查找foo()，它检查GC，然后是C1 和C2，然后在P1 中找到。如果P1 中没有，查找将会到达P2。

        然而，bar()的结果是不同的。它搜索GC 和C1，紧接着在C2 中找到了。这样，就不会再继续搜索到祖父P1 和P2。

 

        新式类有一个__mro__属性，告诉你查找顺序是怎样的。它是类属性，实例没有该属性。它是新式类的属性，经典类没有：

>>> GC.__mro__

(<class '__main__.GC'>, <class'__main__.C1'>, <class '__main__.C2'>, <class '__main__.P1'>,  <class '__main__.P2'>, <type'object'>)

 

        为什么经典类MRO 会失败？在版本2.2 中，类型与类的统一，带来了一个新的“问题”，波及所有从object派生出来的（根）类，一个简单的继承结构变成了一个菱形。

        比如，有经典类B 和C，C 覆盖了构造器，B 没有，D 从B 和C 继承而来：

class  B:

        pass

class  C:

        def  __init__(self):

                print  "the  default  constructor"

class  D(B,  C):

        pass

当我们实例化D，得到：

>>> d  = D()

the  default  constructor

        上图为B，C 和D 的类继承结构，现在把代码改为采用新式类的方式，问题也就产生了：

class  B(object):

        pass

class  C(object):

        def  __init__(self):

                print  "the  default  constructor"

 

        由于在新式类中，需要出现基类，这样就在继承结构中，形成了一个菱形。D 的实例上溯时，不应当错过C， 但不能两次上溯到A（因为B 和C 都从A 派生）。

        继承结构已变成了一个菱形，如果使用经典类的MRO，当实例化D 时，不再得到C.__init__()的结果，而是得到object.__init__()！这就是为什么MRO 需要修改的真正原因。

        尽管我们看到了，在上面的例子中，类GC的属性查找路径被改变了，但你不需要担心会有大量的代码崩溃。经典类将沿用老式MRO，而新式类将使用它自己的MRO。