【继承示意图】
类是实例的工厂, 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