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。