1、python 面向对象学习总结引言提到面向对象，总是离不开几个重要的术语：多态（Polymorphism），继承（Inheritance）和封装（Encapsulation）。Python也是一种支持OOP的动态语言，本文将简单阐述Python对面向对象的支持。在讨论Python的OOP之前，先看几个OOP术语的定义： 类：对具有相同数据和方法的一组对象的描述或定义。 对象：对象是一个类的实例。 实例(instance)：一个对象的实例化实现。 标识(identity)：每个对象的实例都需要一个可以唯一标识这个实例的标记。 实例属性（instance attribute）：一个对象就是一组属性
2、的集合。 实例方法(instance method)：所有存取或者更新对象某个实例一条或者多条属性的函数的集合。 类属性（classattribute）：属于一个类中所有对象的属性，不会只在某个实例上发生变化 类方法（classmethod）：那些无须特定的对性实例就能够工作的从属于类的函数。1.Python中的类与对象Python中定义类的方式比较简单：class类名： 类变量 def _init_(self,paramers):def函数(self,.)其中直接定义在类体中的变量叫类变量，而在类的方法中定义的变量叫实例变量。类的属性包括成员变量和方法，其中方法的定义和普通函数的定义非常类似
3、，但方法必须以self作为第一个参数。举例：class MyFirstTestClass: classSpec=it is a test class def _init_(self,word): print say +word def hello(self,name): print hello +name在Python类中定义的方法通常有三种：实例方法，类方法以及静态方法。这三者之间的区别是实例方法一般都以self作为第一个参数，必须和具体的对象实例进行绑定才能访问，而类方法以cls作为第一个参数，cls表示类本身，定义时使用classmethod；而静态方法不需要默认的任何参数,跟一般的普通
4、函数类似.定义的时候使用staticmethod。class MethodTest():count= 0def addCount(self):MethodTest.count+=1print I am an instance method,my count is + str(MethodTest.count), selfstaticmethoddefstaticMethodAdd():MethodTest.count+=1printI am a static methond,my count is+str(MethodTest.count)classmethoddefclassMethodAd
5、d(cls):MethodTest.count+=1printI am a class method,my count is+str(MethodTest.count),clsa=MethodTest()a.addCount()I am an instance method,my count is 1 a.staticMethodAdd() ;#I am a static methond,my count is2MethodTest.staticMethodAdd() ;#I am a static methond,my count is3a.classMethodAdd() ;#I am a
6、 class method,my count is4 _main_.MethodTestMethodTest.classMethodAdd() ;#I am a class method,my count is5 _main_.MethodTestMethodTest.addCount()Traceback(most recent call last):File, line 1, in MethodTest.addCount()TypeError:unbound method addCount() must be called with MethodTest instance asfirst
7、argument (got nothing instead) 从上面的例子来看，静态方法和类方法基本上区别不大，特别是有Java编程基础的人会简单的认为静态方法和类方法就是一回事，可是在Python中事实是这样的吗？看下面的例子：MethodTest.classMethodAdd() ;#I am a class method,my count is5 _main_.MethodTestclass subMethodTest(MethodTest): passb=subMethodTest()b.staticMethodAdd() ;#I am a static methond,my coun
8、t is6b.classMethodAdd() ;#I am a class method,my count is7 _main_.subMethodTesta.classMethodAdd() ;#Iam a class method,my count is8 _main_.MethodTest 如果父类中定义有静态方法a(),在子类中没有覆盖该方法的话，Sub.a()仍然指的是父类的a（）方法。而如果a()是类方法的情况下，Sub.a()指向的是子类。staticmethod只适用于不想定义全局函数的情况。看看两者的具体定义：staticmethod function is nothing
9、 morethan a function defined inside a class. It is callable withoutinstantiating the class first. Its definition is immutable viainheritance.classmethod function also callablewithout instantiating the class, but its definition follows Subclass, not Parent class, via inheritance. Thats because the fi
10、rstargument for classmethod function must always be cls (class). 封装和访问控制 与Java不同，Python的访问控制相对简单，没有public，private，protected等属性，python认为用户在访问对象的属性的时候是明确自己在做什么的，因此认为私有数据不是必须的，但是如果你必须实现数据隐藏，也是可以的，具体方法就是在变量名前加双下划线。如_privatedata=0，定义私有方法则是在方法名称前加上_下划线。但即使对于隐藏的数据，也是有一定的方法可以访问的。方法就是_className_attrName。Pyth
11、on对于私有变量会进行Namemangling是Python中为了方便定义私有的变量和方法，防止和继承类以及其他外部的变量或者方法冲突而采取的一种机制。在python中通过_spam定义的私有变量为最终被翻译成_classname_spam，其中classname为类名，当类名是以_开头的时候则不会发生Namemangling。Namemangling存在的一个问题是当字符串长度超过255的时候则会发生截断。class PrivateTest: _myownedata=12 def _myownmethod(self): printcan you see me? def sayhi(self)
12、: printsay hiclass subPrivateTest(PrivateTest): passsubPrivateTest._myownedataTraceback(most recent call last):File, line 1, in subPrivateTest._myownedataAttributeError:class subPrivateTest has no attribute _myownedatasubPrivateTest._PrivateTest_myownedata 构造函数和析构函数Python的构造函数有两种，_init_和_new_,_init_
13、的调用不会返回任何值，在继承关系中，为了保证父类实例正确的初始化，最好显示的调用父类的_init_方法。与_init_不同，_new_实际是个类方法，以cls作为第一个参数。如果类中同时定义了_init_和_new_方法，则在创建对象的时候会优先使用_new_.class A(object): def _init_(self): print(in init) def _new_(self): print(in new)A()如果_new_需要返回对象，则会默认调用_init_方法。利用new创建一个类的对象的最常用的方法为：super(currentclass,cls)._new_(cls,
14、.)class A(object): def _new_(cls): Object = super(A,cls)._new_(cls) print in New return Object def _init_(self): print in initclass B(A): def _init_(self): print in Bs initB()_new_构造函数会可变类的定制的时候非常有用，后面的小节中会体现。Python由于具有垃圾回收机制，通常不需要用户显示的去调用析构函数，即使调用，实例也不会立即释放，而是到该实例对象所有的引用都被清除掉后才会执行。class P: def _del
15、_(self): printdeletedclass S(P): def _init_(self): printinitialized def _del_(self): P._del_(self) printchild deleteda=S() #initializedb=ac=aid(a),id(b),id(c) #(18765704,18765704, 18765704)del adel bdel c #deleted #childdeleted 绑定与非绑定在前面的例子中我们讨论过类的实例方法必须通过实例调用，如果直接通过类去访问会抛出异常，这种通过实例来访问方法就叫绑定，调用的时候不需
16、要显示传入self参数，而调用非绑定方法需要显示传入self参数，比如当子类继承父类定义构造函数的时候，需要显示调用父类的构造函数，但此时该方法并未与任何实例绑定，调用的时候需要使用superclassName._init_(self)。静态方法可以直接被类或类实例调用。它没有常规方法那样的特殊行为（绑定、非绑定、默认的第一个参数规则等等）。完全可以将静态方法当成一个用属性引用方式调用的普通函数来看待。任何时候定义静态方法都不是必须的（静态方法能实现的功能都可以通过定义一个普通函数来实现）3. Python中的继承 继承Python同时支持单继承与多继承，继承的基本语法为class新类名（父类
17、1，父类2,.）,当只有一个父类时为单继承，当存在多个父类时为多继承。子类会继承父类的所有的属性和方法，子类也可以覆盖父类同名的变量和方法。在传统类中，如果子类和父类中同名的方法或者属性，在查找的时候基本遵循自左到右，深度优先的原则。如下列：class A:defsayhi(self):printI am A hiclass B:defsayhi(self):printI am B Hiclass C(A,B):passd=C()d.sayhi()Iam A hiB.sayhi(d)Iam B Hi如果想调用父类B的sayhi方法则需要使用B.sayhi(d).而在python引入新式类后，在
18、继承关系中，方法和属性的搜索有所改变，使用C3算法。具体将在MRO中详细讨论。关于继承的构造函数：1. 如果子类没有定义自己的构造函数，父类的构造函数会被默认调用，但是此时如果要实例化子类的对象，则只能传入父类的构造函数对应的参数，否则会出错classAddrBookEntry(object):addressbook entry classdef_init_(self, nm, ph):self.name= nmself.phone= phprintCreated instance for:, self.namedefupdatePhone(self, newph):self.phone =
19、newphprintUpdated phone# for:, self.nameclassEmplAddrBookEntry(AddrBookEntry):EmployeeAddress Book Entry classdefupdateEmail(self, newem):self.email= newemprintUpdated e-mail address for:, self.namejohn= EmplAddrBookEntry(John Doe, 408-555-1212)printjohn.name2. 如果子类定义了自己的构造函数，而没有显示调用父类的构造函数，则父类的属性不会
20、被初始化classAddrBookEntry(object):addressbook entry classdef_init_(self, nm, ph):self.name= nmself.phone= phprintCreated instance for:, self.namedefupdatePhone(self, newph):self.phone = newphprintUpdated phone# for:, self.nameclassEmplAddrBookEntry(AddrBookEntry):EmployeeAddress Book Entry classdef_ini
21、t_(self, nm, ph, id, em):#AddrBookEntry._init_(self, nm,ph)self.empid= idself.email= emdefupdateEmail(self, newem):self.email= newemprintUpdated e-mail address for:, self.namejohn= EmplAddrBookEntry(John Doe, 408-555-1212,42, johnspam.doe)printjohn.emailprintjohn.empid输出：johnspam.doe42Traceback(most
22、 recent call last):printjohn.nameAttributeError:EmplAddrBookEntry object has no attribute name3. 如果子类定义了自己的构造函数，显示调用父类，子类和父类的属性都会被初始化classAddrBookEntry(object):addressbook entry classdef_init_(self, nm, ph):self.name= nmself.phone= phprintCreated instance for:, self.namedefupdatePhone(self, newph):s
23、elf.phone = newphprintUpdated phone# for:, self.nameclassEmplAddrBookEntry(AddrBookEntry):EmployeeAddress Book Entry classdef_init_(self, nm, ph, id, em):AddrBookEntry._init_(self, nm,ph)self.empid= idself.email= emdefupdateEmail(self, newem):self.email= newemprintUpdated e-mail address for:, self.n
24、amejohn= EmplAddrBookEntry(John Doe, 408-555-1212,42, johnspam.doe)printjohn.emailprintjohn.empidprintjohn.name MROMRO：即methodresolutionorder.简单的说就是python针对多继承查找一个属性或者方法的一种算法。在引入新型类之前，MRO比较简单，采取自左到右，深度优先的原则。比如有如下关系的类和属性：要查找对象x的attr属性，其根据自左到右，深度优先的原则，其搜索顺序为D,B,A,C,位于树结构底层的节点具有较高的level，当从高的level向低的lev
25、el查找的时候遇到第一个属性则不再继续查找，因此上面的例子x的属性值为1. classA: attr=1 classB(A):pass classC(A):attr=2 classD(B,C):pass x=D() printx.attr1但按照多继承的理解，level高的属性应该覆盖了level低的属性，D同时继承于B,C，而C是A的子类，那么D的实例的属性值理应为attr=2而不是1，产生这个问题的主要原因是在继承关系中产生了菱形，针对经典类的MRO算法有一定的局限性，特别是在python2.2中加入了新型类后，由于object是所有对象之母，很容易形成菱形。因此python2.2采用改进
26、的C3MRO算法进行搜索。算法描述：假设C1C2.CN表示类节点C1,C2,.CN)；head=C1；tail=C2.CNC+(C1 C2.CN)=C C1C2.CN若c继承于B1，B2.BN,那么在节点C的搜索顺序LC=C加上其所有父节点的搜索顺序和各个父节点的列表之和，也即LC(B1, . , BN)= C + merge(LB1, . ,LBN, B1 . BN)其中merge的计算方法为:如果B1不在其它列表的tail中，则将其并入C的搜索列表中，同时将其从merge列表中移除，否则跳过改节点，继续B2.。如此重复知道merge为空。如果C是object对象或者没有其他的父节点，则Lo
27、bject= object.。对于单继承，则LC(B)= C + merge(LB,B) = C + LB假设有如下继承关系：则：LO= OLD= D OLE= E OLF= F OLB= B + merge(DO, EO, DE)= B+D+merge(O,EO,E)=B+D+merge(O,EO,E)=B+D+E+merge(O,O)=B D E OLA= A + merge(BDEO,CDFO,BC)=A + B + merge(DEO,CDFO,C)=A + B + C + merge(DEO,DFO)=A + B + C + D + merge(EO,FO)=A + B + C +
28、D + E + merge(O,FO)=A + B + C + D + E + F + merge(O,O)=A B C D E F O针对上面的计算方法，利用Python的mro函数也可以说明该搜索顺序：class F(object):passclass E(object):passclass D(object):passclass C(D,F):passclass B(D,E):passclass A(B,C): passA.mro(), , , , , , B.mro(), , , 对于C3的MRO算法也可以简单的理解为：深度优先，从左到右遍历基类，先遍历高level的，再遍历低leve
29、l的，如果任何类在搜索中是重复的，只有最后一个出现的位置被保留，其余会从MROlist中删除。也就是说类的共同的祖先只有在其所有的子类都已经被check之后才会check。对于A，其搜索顺序应该是AB (D) (O) C D (O) E (O) F O当然即使C3的MRO，也有其无法处理的情况，看下面的例子：class X(object):passclass Y(object):passclass A(X,Y):passclass B(Y,X):passclass C(A,B):passTraceback(most recent call last):File, line 1, in classC(A,B):TypeError:Error when calling the metaclass bases
