Python 点滴 IV

【继承示意图】

类是实例的工厂, OOP就是在树中搜索属性,类其实就是变量名与函数打成的包

. 每个class语句会生成一个新的类对象

. 每次类调用时，就会生成一个新的实例对象

. 实例自动连接到创建这些实例的类

. 类连接到超类的方式是，将超类列在类头部(),其从左到右的顺序会决定树中的次序

有几点需要注意:

. 属性通常是在class语句中通过赋值语句添加在类中，而不是嵌入函数的def语句中

. 属性通常是在类中，对传给函数的特殊参数self，做赋值运算而添加在实例中的

【方法调用的两种方式】

def 语句出现在类中，通常称为方法:

通过实例调用:bob.giveRise()

通过类来调用:Employee.giveRise(bob)

【类与模块】

从最底层来看，类几乎就是命名空间，很像模块。但和模块不同的之处是:

1. 类也支持多个对象的产生（多态）

2. 命名空间继承（继承）

3. 运算符重载（重载）   

【PYTHON类的主要特点】

. class语句创建对象并将其赋值给变量名(类似于def)

. class语句内的赋值语句会创建类的属性(属性获得:object.name)

. 类属性提供对象的状态和行为

【类的实例概要】

. 像函数那样调用对象会创建新的实例对象

. 每个实例对象继承类的属性并获得自己的命名空间

. 在方法内对self属性做赋值运算会产生每个实例自己的属性

【第一个例子】

class FirstClass:              #定义类的对象
    def setdata(self,value):   #定义类方法
        self.data = value      #self是个实例
    def display(self):
        print self.data        #self-data: 每个实例共享

创建两个实例，每个实例拥有自己的命名空间

>>> x = FirstClass()
>>> y = FirstClass()

会产生三个对象: 两个实例，一个类

>>> x.setdata('Hello')     #调setdata方法,self就是x本身
>>> y.setdata(100)         #运行: FirstClass.setdata(y,100)

x,y创建不同实例对象的命名空间,所以尽管都调用display方法，值却不同

>>> x.display()            #self.data在每个实例中不一样
Hello
>>> y.display()
100

另一种调用方式:

>>> x.data = "New Value"   #能够获得或设置属性
>>> x.display()
New Value

也可以设置成一个全新的属性

>>> x.anothername = 'spam'

【PYTHON类继承的核心观点】

. 超类列在类开头的括号中

. 类从超类中继承属性,当读入属性时，如果不存在于子类中，PYTHON会自动搜索这个属性

. 实例会继承所有可读取类的属性. 搜索路径: 实例 ==> 创建实例的类 ==> 所有超类

. 每个object.attribute都会开启新的独立搜索

. 逻辑的修改是通过创建子类，而不是修改超类

这种搜索的结果及主要目的就是:

第一: 类支持了程序的分解和定制，比迄今为止所见到的其他任何语言工具都要好。

第二: 可以把程序的冗余度降到最低，减少维护成本，也就是把操作分解为单一，共享的实现

第三: 这样写程序时，也可以让我们队现有的程序代码进行定制，而不是实地修改或从头开始

【第二个例子】

class SecondClass(FirstClass):     #继承FirstClass类中的setdata方法
    def display(self):             #修改display方法,也叫方法的重载
        print 'Current value = %s' % self.data

搜索从实例开始==>子类==>超类，直到找到第一个为止,所以display会覆盖父类方法

>>> z = SecondClass()
>>> z.setdata('Hello,World!')      #从FirstClass中发现setdata方法
>>> z.display()                    #SecondClass中发现display方法
Current value = Hello,World!

NOTE:作为一条规则，因为继承可以让我们在外部组件内(也就是在子类内)进行修改，类所支持的扩展和重用通常比函数或模块更好！

【第三个例子】: 关于运算符重载

定义SecondClass的子类，实现三个特殊名称的属性，让PYTHON自动调用:

当新的实例构造时，会调用__init__(self是新的ThirdClass对象)

当ThirdClass实例出现在+或*表达式中时，则分别调用__add__和__mul__

class ThirdClass(SecondClass):                 #ThirdClass类，继承自SecondClass
    def __init__(self,value):                  #ThirdClass类中的值
        self.data = value
    def __add__(self,other):                   #注意这种调用方式 self + other
        return ThirdClass(self.data + other)
    def __mul__(self,other):
        self.data = self.data * other          #self * other

执行结果:

>>> a = ThirdClass('AB')                       #调用__init__构造函数
>>> a.display()                                #继承的方法
Current value = AB
>>> b = a + 'XY'                               #新的__add__:造一个新的实例
>>> b.display()
Current value = ABXY
>>> a * 3                                      #新的__mul__:在当地改变实例
>>> a.display()
Current value = ABABAB

NOTE:

__add__方法创建并返回这个类的新的实例对象

__mul__方法会在原处修改当前的实例对象

【OOP最重要的两个概念】

方法函数中的特殊self参数和__init__构造器方法是PYTHON中OOP的两个基石

【最常用的运算符重载】

运算符重载是由特定名称的方法写成的。这些方法的开头和结尾都是双下划线，通过这种方法使其变得独特。这些不是内置或保留字。当实例出现在相应的运算中时，PYTHON就会自动执行它们。PYTHON为这些运算和特殊方法的名称定义了对应的关系。

__init__构造器是最常用的。几乎每个类都使用这个方法为实例属性进行初始化，以及执行其他的启动任务。

【变量名相同的例子】

class MixedNames:                  #定义类:MixedNames
data = 'spam'              #赋值类属性:data

def __init__(self,value):  #赋值方法名:  
self.data = value  #赋值实例属性:data

def display(self):
print MixNames.data,self.data   #类属性,实例属性

输出结果:

>>> ins1 = MixedNames(1)       #类工厂造两个实例对象x,y
>>> ins2 = MixedNames(2)       #每个实例对象有自己的数据
>>> ins1.display();ins2.display() #self.data不同,subclass.data却是相同的，都是从data = 'spam'继承而来
spam 1
spam 2

>>> MixedNames.display(ins1)   #这种写也是可以的        

【另一个例子】

message = 'Global Message!'
class NextClass:
    message = 'Class Message'

    def printer(self,value):
self.message = value
print 'message', message
print 'NextClass.message',NextClass.message
print 'self.message',self.message

输出结果:

>>> x = NextClass()                     #造实例
>>> x.printer('Instance Message!')      #调实例的方法
message is:            Global Message!
NextClass.message is:  Class Message!
self.message is:       Instance Message!

其他调用:

>>> NextClass.printer(x,'class call')    #正确:直接调用类
>>> NextClass.printer('class call')      #错误:必须在第一个位置放实例名
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method printer() must be called with NextClass instance as first argument (got str instance instead)

【调用超类的构造器】

如果除了想调用自身的构造函数，还想调用超类的，那么就必须用下面的方式

class Super:
def __init__(self,x):
pass

class Sub(Super):
def __init__(self,x,y):
Super.__init__(self.x)
pass

I = Sub(1,2)

【继承方法的专有化】

继承树搜索模式是将系统专有化的最好的方式，继承会先在子类中寻找变量名，然后才查找超类，子类可以对超类的属性重新定义来取代默认的行为。实际上，可以把整个系统做成类的层次，再新增外部的子类来对其进行扩展，而不是在原处修改已重载的逻辑。

. 子类可以完全取代继承的属性

. 子类可以找到并获得超类属性

. 子类可以通过已覆盖的方法回调超类来扩展超类的方法

class Super:
def method(self):
print 'start Super.method'

class Sub(Super):
def method(self):                           #重写方法
print 'starting Sub.method'         #增加行为
Super.method(self)                  #运行默认的行为,NOTE:self的使用
print 'ending Super.method'

直接调用超类方法是这里的重点。Sub类取代了Super的方法函数.但是，取代时，Sub又回调了Super所导出的版本，从而实现了默认的行为。也就是说：Sub.method只是扩展了Super.method的行为，而不是完全取代。

输出结果:

>>> x = Super()                                     #造一个Super实例
>>> x.method()                                      #调Super类中的method方法
Start Super.method

>>> x = Sub()                                       #造一个Sub实例
>>> x.method()                                      #调Sub类中的method,其中又回调了父类的方法
Start Sub.method
Start Super.method
Ending Super.method

【类接口技术】

扩展只是一种同超类接口的方式，下面示范了specialize.py文件定义了多个类，示范了一些常用的技巧

Super:     定义了一个method函数以及一个delegate函数

Inheritor: 没有提供任何新的变量名，因此会获得Super中定义的一切内容

Replacer:  用自己的版本来覆盖Super的method

Extender:  覆盖并回调默认的method，从而定制Super的method

Provider:  实现Super的delegate方法预期的action方法

#File:  specialize.py

<span style="font-family:SimHei;font-size:14px;">class Super:
	def method(self):
		print 'in Super.method'
	def delegate(self):
		self.action()

class Inheritor(Super): 
	pass

class Replacer(Super):
	def method(self):
		print 'in Replacer.method'

class Extender(Super):
	def method(self):
		print 'starting Extender.method'
		Super.method(self)
		print 'ending Extender.method'

class Provider(Super):
	def action(self):
		print 'in Provider.action'

if __name__=='__main__':
	for klass in (Inheritor,Replacer,Extender):
		print '\n' + klass.__name__ + '...'
		klass().method()
		print '\nProvider...'
		x = Provider()
		x.delegate()</span>

NOTE:

1. 末尾的自我测试代码在for循环中建立三个不同类的实例

2. 类也有特殊的__name__属性，就像模块。它默认类首行中的类名称的字符串
运行结果:

D:\>python specialize.py

Inheritor...
in Super.method

Provider...
in Provider.action

Replacer...
in Replacer.method

Provider...
in Provider.action

Extender...
starting Extender.method
in Super.method
ending Extender.method

Provider...
in Provider.action

【抽象超类】

上例中的Provider类中，当通过Provider实例调用delegate方法时，两个独立的继承搜索将会发生:

1. 在最初的x.delegate调用中，PYTHON会搜索Provider实例和它上层的对象，知道在Super中找到delegate的方法。实例x会像往常一样传递给这个方法的self参数

2. 在Super.delegate方法中,self.action会对self以及它上层的对象启动新的独立继承搜索。因为self指的是Provider实例，就会找到Provider子类中的action

这种填空式的代码结构一般就是OOP的软件框架。从delegate方法的角度来看，这个例子中的超类也称为抽象类--也就是类的部分行为默认是由其子类来实现。如果逾期的方法没有在子类中定义，当继承搜索失败时，PYTHON会引发未定义变量名的异常。一般会使用assert语句，使这种子类需要更为明显，或者引发内置的异常NotImplementedError:

<span style="font-family:SimHei;font-size:14px;">class Super:
	
	def method(self):
		print 'In Super.method'

	def delegate(self):
		self.action

	def action(self):
		assert 0, 'action must be defined!'</span>

【运算符重载】

. 运算符重载让类拦截常规的PYTHON运算

. 类可重载所有PYTHON表达式运算符

. 类可重载打印、函数调用、属性点号运算等运算

. 重载使类实例的行为像内置类型

. 重载是通过特殊名称的类方法实现的

简单例子

<span style="font-family:SimHei;font-size:14px;">class Number:
	def __init__(self,start):                  #on Number(start)
		self.data = start

	def __sub__(self,other):                   #On instance - other       
		return Number(self.data - other)   #Result is a new instance</span>

输出结果:

>>> from number import Number  #Fetch class from Module
>>> X = Number(5)              #Number.__init__(X,5)
>>> Y = X -2                   #Number.__sub__(X,2)
>>> Y.data                     #Y is new Number instance
3

【常见的运算符重载】

【__getitem__拦截索引运算】

下面的类将返回索引值的平方

<span style="font-family:SimHei;font-size:14px;">class indexer:
	def __getitem__(self,index):
		return index ** 2</span>

输出结果:

<span style="font-family:SimHei;font-size:14px;">>>> X = indexer()
>>> X[2]
4
>>> for i in range(5):
...   print X[i],
...
0 1 4 9 16</span>

【__getitem__和__iter__实现迭代】

<span style="font-family:SimHei;font-size:14px;">class stepper:
	def __getitem__(self,i):
		return self.data[i]
</span>

输出结果:

<span style="font-family:SimHei;font-size:14px;">>>> X = stepper()         #X is a stepper object
>>> X.data = 'spam'
>>> X[1]                  #Indexing calls __getitem__
'p'
>>> for item in X:        #for loops call __getitem__
...   print item,         #for index items 0..N
...
s p a m</span>

其他的一些引用:

>>> 'p' in X
True
>>> [c for c in X]
['s', 'p', 'a', 'm']
>>> map(None,X)
['s', 'p', 'a', 'm']
>>> (a,b,c,d) = X
>>> a,c,d
('s', 'a', 'm')
>>> list(X);tuple(X);''.join(X)
['s', 'p', 'a', 'm']
('s', 'p', 'a', 'm')
'spam'
>>> X
<number.stepper instance at 0x00000000025EE088>

【__getattr__和__setattr__捕捉属性的引用】

__getattr__方法是拦截属性点号运算。当通过未定义属性名称和实例进行点号运算时，就会用属性名称为字符串调用这个方法。

__getattr__例子:

class empty:
def __getattr__(self,attrname):
if attrname == "age":
return 40
else:
raise AttributeError,attrname

运行结果

>>> X = empty()
>>> X.age
40
>>> X.name
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "number.py", line 6, in __getattr__
    raise AttributeError,attrname
AttributeError: name

__setattr__例子:

class accesscontrol:
def __setattr__(self,attr,value):
if attr == 'age':
self.__dict__[attr] = value
else:
raise AttributeError,attr + 'not allowed'

运行结果:

>>> X = accesscontrol()
>>> X.age = 40
>>> X.age
40
>>> X.name = 'bob'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "number.py", line 6, in __setattr__
    raise AttributeError,attr + 'not allowed'
AttributeError: namenot allowed

【__call__拦截调用】

当实例调用时，使用__call__方法。可以让实例的外观和用法类似于函数。

class Prod:
def __init__(self,value):
self.value = value


def __call__(self,other):
return self.value * other

>>> X = Prod(2)
>>> X(3)
6

下面的例子也能提供类似功能:

class Prod:
def __init__(self,value):
self.value = value


def comp(self,other):
return self.value * other

>>> X = Prod(2)
>>> X.comp(3)
6

当需要为函数的API编写接口时，__call__就变得很有用:这可以编写遵循所需要的函数来调用接口对象，同时又能保留状态信息。这是除了__init__构造方法以及__str__和__repr__显示格式外，第三个最常用的运算符重载方法了。

【__del__析构器】

每当实例产生时，就会调用__init__构造方法。

每当实例收回时，就会调用__del__析构方法来自动执行。

class Life:
def __init__(self,name='unknown'):
print 'Hello',name
self.name = name


def __del__(self):
print 'Goodbye',self.name

执行结果:

>>> name = Life('Jerry')
Hello Jerry
>>> name = 'Alice'
Goodbye Jerry

基于某些原因，在PYTHON中，析构方法不像其他OOP语言那么常用。

原因之一: 因为PYTHON在实例收回时，会自动回收实例所拥有的的所有空间，对于空间管理来说是不需要析构方法的。

原因之二: 无法轻易地预测实例何时收回

【命名空间完整例子】

X = 11

def f():
    print X

def g():
    X = 22
    print X

class C:
    X = 33
    def m(self):
        X = 44
        self.X = 55

if __name__=='__main__':
    print X
    f()
    g()
    print X

    obj = C()
    print obj.X

    obj.m()
    print obj.X
    print C.X

这个程序5个不同位置的X是5个不同的变量

X=11    #模块属性

X=22    #函数内的本地变量

X=33    #类属性

X=44    #方法中的本地变量

X=55    #实例属性

【命名空间字典】

类和实例都具有内置属性__dict__,看一个例子：

class super:
    def hello(self):
        self.data1 = 'spam'

class sub(super):
    def hola(self):
        self.data2 = 'eggs'

当造子类的实例时，该实例一开始会是空的命名空间字典，但是有链接会指向它的类，让继承搜索能顺着寻找。

实例有个__class__属性链接到它的类

而类有个__bases__属性是一个元祖，其中包含了通往更高的超类的链接
>>> X = sub()
>>> X.__dict__
{}
>>> X.__class__
<class __main__.sub at 0x0000000002EA2588>
>>> sub.__bases__
(<class __main__.super at 0x0000000002EA2528>,)

>>> super.__bases__
()

当类为self属性赋值时，会填入实例对象。也就是说，属性会最后会位于实例的属性命名空间字典内，而不是类的。实例对象的命名空间保存了数据，会随实例的不同而不同，而self正是进入其命名空间的钩子.

>>> Y = sub()
>>> X.hello()
>>> X.__dict__
{'data1': 'spam'}
>>> X.hola()
>>> X.__dict__
{'data1': 'spam', 'data2': 'eggs'}
>>> Y = sub()
>>> X.hello()
>>> X.__dict__
{'data1': 'spam', 'data2': 'eggs'}
>>> sub.__dict__
{'__module__': '__main__', '__doc__': None, 'hola': <function hola at 0x0000000002EAB6D8>}
>>> super.__dict__
{'__module__': '__main__', 'hello': <function hello at 0x0000000002EAB0B8>, '__doc__': None}
>>> sub.__dict__.keys();super.__dict__.keys()
['__module__', '__doc__', 'hola']
['__module__', 'hello', '__doc__']
>>> Y.__dict__
{}

属性是PYTHON的字典键，因此有两种方式可以读取并对其进行赋值:

. 通过点号运算

. 通过键索引运算

>>> X.data1;X.__dict__['data1']
'spam'
'spam'
>>> X.data3 = 'toast'
>>> X.__dict__
{'data1': 'spam', 'data3': 'toast', 'data2': 'eggs'}
>>> X.__dict__['data3'] = 'ham'
>>> X.data3
'ham'

其他的还有dir函数

>>> X.__dict__
{'data1': 'spam', 'data3': 'ham', 'data2': 'eggs'}
>>> X.__dict__.keys()
['data1', 'data3', 'data2']
>>> dir(X)
['__doc__', '__module__', 'data1', 'data2', 'data3', 'hello', 'hola']
>>> dir(sub)
['__doc__', '__module__', 'hello', 'hola']
>>> dir(super)
['__doc__', '__module__', 'hello']

【PYTHON和OOP】

PYTHON的OOP实现可以概括为三个概念:

继承:   继承是基于PYTHON中的属性查找的

多态:   在X.method方法中,method的意义取决于X的类型

封装:   方法和运算符实现行为，数据隐藏默认是一种惯例

【通过调用标志重载】

下面的方法不提倡:

class C:

    def meth(self,x): ...

    def meth(self,x,y,z): ...

下面的方法同样不提倡:

class C:

    def meth(self,*args):

        if len(args) == 1:

            ...

        elif type(arg[0]) == int:

            ...

通常来讲，不应该这样做:而应该把程序代码写成预期的对象接口，而不是特定的数据类型。这样一来，不论现在还是以后，都可在更多的类型和应用中使用。

class C:

    def method(self,x):

        x.operation       #假设x具有这种操作

  

【绑定方法】

绑定方法即带self.方法，结合实例和方法函数；

调用时候，不用刻意传入实例对象，因为原始实例依然可用.

【新式类】

class newStytle(object): ...

所有以object做为超类的类，称为新式类。和经典类几乎没什么区别。

PYTHON 3.0开始，所有的类都将试为超类.

【钻石继承例子】

由上述新式类衍生出来的经典例子:

>>> class A: attr = 1
>>> class B(A): pass
>>> class C(A): attr = 2
>>> class D(B,C): pass
>>> X = D()
>>> X.attr
1

如果是经典类，搜索的路径是D-B-A, 然后才是C，搜索到A的属性后停止

>>> class A(object): attr = 1    #新式类
>>> class B(A): pass
>>> class C(A): attr = 2
>>> class D(B,C): pass
>>> X = D()
>>> X.attr

2

如果是新式类，搜索的路径是D-B-C，然后才是A，搜索到C的属性后停止