python中类的全面分析

面向对象重要的概念就是类(Class)和实例(Instance)，类是抽象的模板，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

先回顾下 OOP 的常用术语：

类：对具有相同数据和方法的一组对象的描述或定义。 对象：对象是一个类的实例。 实例(instance)：一个对象的实例化实现。 实例属性(instance attribute)：一个对象就是一组属性的集合。 实例方法(instance method)：所有存取或者更新对象某个实例一条或者多条属性的函数的集合。 类属性(classattribute)：属于一个类中所有对象的属性，不会只在某个实例上发生变化 类方法(classmethod)：那些无须特定的对象实例就能够工作的从属于类的函数。 类概述

在python中，定义类是通过class关键字：

classStudent(object): pass

class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的。通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。

定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：

>>>bart=Student() >>>bart <__main__.Studentobjectat0x10a67a590> >>>Student <class'__main__.Student'>

可以看到，变量bart指向的就是一个Student的object，后面的0x10a67a590是内存地址，每个object的地址都不一样，而Student本身则是一个类。

可以自由地给一个实例变量绑定属性，比如，给实例bart绑定一个name属性：

>>>bart.name='BartSimpson' >>>bart.name 'BartSimpson'

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的init方法，在创建实例的时候，就把name，score等属性绑上去。

classStudent(object): def__init__(self,name,score): self.name=name self.score=score

注意到init方法的第一个参数永远是self，表示创建的实例本身，因此，在init方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。

有了init方法，在创建实例的时候，就不能传入空的参数了，必须传入与init方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：

>>>bart=Student('BartSimpson',59) >>>bart.name 'BartSimpson' >>>bart.score 59

和普通的函数相比，在类中定义的对象函数(还有静态方法，类方法)只有一点不同，就是第一个参数永远是实例变量self，并且，调用时不用传递该参数。

新式类、旧式类

python的新式类是2.2版本引进来的，之前的类叫做经典类或者旧类。Python 2.x 中如果一个类继承于一个基类(可以是自定义类或者其它类)或者继承自 object，则该类为新式类;没有继承的类为经典类。Python 3.x 则全部为新式类。

新式类被赋予了很多新的特性(如：统一了types和classes)，并改变了以往经典类的一些内容(如：改变了多继承下方法的执行顺序)。

关于统一类(class)和类型(type)，具体看下面的例子

classOldClass(): pass o=OldClass() printo.__class__#__main__.OldClass printtype(o)#<type'instance'> classnewClass(object): pass n=newClass() printn.__class__#<class'__main__.newClass'> printtype(n)#<class'__main__.newClass'> 对象属性

Python 中对象的属性包含对象的所有内容：方法和数据，注意方法也是对象的属性。查找对象的属性时，首先在对象的__dict__ 里面查找，然后是对象所属类的dict，再往后是继承体系中父类(MRO解析)的dict，任意一个地方查找到就终止查找，并且调用 __getattribute__(也有可能是__getattr__) 方法获得属性值。

方法

在 Python 类中有3种方法，即静态方法(staticmethod)，类方法(classmethod)和实例方法：

对于实例方法，在类里每次定义实例方法的时候都需要指定实例(该方法的第一个参数，名字约定成俗为self)。这是因为实例方法的调用离不开实例，我们必须给函数传递一个实例。假设对象a具有实例方法 foo(self, *args, **kwargs)，那么调用的时候可以用 a.foo(*args, **kwargs)，或者 A.foo(a, *args, **kwargs)，在解释器看来它们是完全一样的。 类方法每次定义的时候需要指定类(该方法的第一个参数，名字约定成俗为cls)，调用时和实例方法类似需要指定一个类。 静态方法其实和普通的方法一样，只不过在调用的时候需要使用类或者实例。之所以需要静态方法，是因为有时候需要将一组逻辑上相关的函数放在一个类里面，便于组织代码结构。一般如果一个方法不需要用到self，那么它就适合用作静态方法。

具体的例子如下：

deffoo(x): print"executingfoo(%s)"%(x) classA(object): deffoo(self): print"executingfoo(%s)"%self @classmethod defclass_foo(cls): print"executingclass_foo(%s)"%cls @staticmethod defstatic_foo(): print"executingstatic_foo()" a=A() printa.foo printA.foo printa.class_foo printA.class_foo printA.static_foo printa.static_foo printfoo #<boundmethodA.fooof<__main__.Aobjectat0x10d5f90d0>> #<unboundmethodA.foo> #<boundmethodtype.class_fooof<class'__main__.A'>> #<boundmethodtype.class_fooof<class'__main__.A'>> #<functionstatic_fooat0x10d5f32a8> #<functionstatic_fooat0x10d5f32a8> #<functionfooat0x10d5f1ed8>

在访问类方法的时候有两种方法，分别叫做 未绑定的方法(unbound method) 和 绑定的方法(bound method)：

未绑定的方法：通过类来引用实例方法返回一个未绑定方法对象。要调用它，你必须显示地提供一个实例作为第一个参数，比如 A.foo。 绑定的方法：通过实例访问方法返回一个绑定的方法对象。Python自动地给方法绑定一个实例，所以调用它时不用再传一个实例参数，比如 a.foo。 数据属性

下面创建了一个Student的类，并且实现了这个类的初始化函数"__init__":

classStudent(object): count=0 books=[] def__init__(self,name,age): self.name=name self.age=age

在上面的Student类中，count, books, name 和 age 都被称为类的数据属性，但是它们又分为类数据属性和实例数据属性。直接定义在类体中的属性叫类属性，而在类的方法中定义的属性叫实例属性。

首先看下面代码，展示了对类数据属性和实例数据属性的访问：

Student.books.extend(["python","javascript"]) print"Studentbooklist:%s"%Student.books #classcanaddclassattributeafterclassdefinition Student.hobbies=["reading","jogging","swimming"] print"Studenthobbylist:%s"%Student.hobbies printdir(Student) #classinstanceattribute wilber=Student("Wilber",28) print"%sis%dyearsold"%(wilber.name,wilber.age) #classinstancecanaddnewattribute #"gender"istheinstanceattributeonlybelongstowilber wilber.gender="male" print"%sis%s"%(wilber.name,wilber.gender) #classinstancecanaccessclassattribute wilber.books.append("C#") printwilber.books

通过内建函数dir()，或者访问类的字典属性__dict__，这两种方式都可以查看类或者实例有哪些属性。对于类数据属性和实例数据属性，可以总结为：

类数据属性属于类本身，可以通过类名进行访问/修改; 类数据属性也可以被类的所有实例访问/修改; 在类定义之后，可以通过类名动态添加类数据属性，新增的类属性也被类和所有实例共有; 实例数据属性只能通过实例访问; 在实例生成后，还可以动态添加实例数据属性，但是这些实例数据属性只属于该实例;

再看下面的程序

classPerson: name="aaa" p1=Person() p2=Person() p1.name="bbb" printp1.name#bbb printp2.name#aaa printPerson.name#aaa

上面程序中，p1.name="bbb"是实例调用了类变量，p1.name一开始是指向的类变量name="aaa"，但是在实例的作用域里把类变量的引用改变了，就变成了一个实例变量。self.name不再引用Person的类变量name了。

classPerson: name=[] p1=Person() p2=Person() p1.name.append(1) printp1.name#[1] printp2.name#[1] printPerson.name#[1] 特殊的类属性

对于所有的类，都有一组特殊的属性：

通过这些属性，可以得到 Student类的一些信息，如下：

类的继承

Python 是面向对象语言，支持类的继承(包括单重和多重继承)，继承的语法如下：

classDerivedClass(BaseClass1,[BaseClass2...]): <statement-1> . <statement-N>

子类可以覆盖父类的方法，此时有两种方法来调用父类中的函数：

调用父类的未绑定的构造方法。在调用一个实例的方法时，该方法的self参数会被自动绑定到实例上(称为绑定方法)。但如果直接调用类的方法(比如A.init)，那么就没有实例会被绑定。这样就可以自由的提供需要的self参数，这种方法称为未绑定(unbound)方法。大多数情况下是可以正常工作的，但是多重继承的时候可能会重复调用父类。 通过 super(cls, inst).method() 调用 MRO中下一个类的函数，这里有一个非常不错的解释，看完后对 super 应该就熟悉了。

未绑定(unbound)方法调用如下：

classBase(object): def__init__(self): print("Base.__init__") classDerived(Base): def__init__(self): Base.__init__(self) print("Derived.__init__")

supper 调用如下：

classBase(object): def__init__(self): print"Base.__init__" classDerived(Base): def__init__(self): super(Derived,self).__init__() print"Derived.__init__" classDerived_2(Derived): def__init__(self): super(Derived_2,self).__init__() print"Derived_2.__init__" 继承机制 MRO

MRO 主要用于在多继承时判断调用的属性来自于哪个类。Python2.2以前的类为经典类，它是一种没有继承的类，实例类型都是type类型，如果经典类被作为父类，子类调用父类的构造函数时会出错。这时MRO的方法为DFS(深度优先搜索)，子节点顺序：从左到右。inspect.getmro(A)可以查看经典类的MRO顺序。

两种继承模式在DFS下的优缺点:

第一种，两个互不相关的类的多继承，这种情况DFS顺序正常，不会引起任何问题;

第二种，棱形继承模式，存在公共父类(D)的多继承，这种情况下DFS必定经过公共父类(D)。如果这个公共父类(D)有一些初始化属性或者方法，但是子类(C)又重写了这些属性或者方法，那么按照DFS顺序必定是会先找到D的属性或方法，那么C的属性或者方法将永远访问不到，导致C只能继承无法重写(override)。这也就是新式类不使用DFS的原因，因为他们都有一个公共的祖先object。

为了使类和内置类型更加统一，Python2.2版本引入了新式类。新式类的每个类都继承于一个基类，可以是自定义类或者