参考：

https://www.cnblogs.com/studyDetail/p/6446180.html  （python的类）https://www.cnblogs.com/zunchang/p/7965685.html （面向过程和面向对象编程，推荐）http://xukaizijian.blog.163.com/blog/static/170433119201111894228877/ （python类的内置方法）

类的定义有点像以下的格式：

class  ClassName([BaseClass]):    ClassAttribute=xx    def Method(self[,arg1,arg2...]):        self.instanceAttribute=xx    
    
             ...    ...class是关键字ClassName:表示定义的类的名字BaseClass：这个是指要继承的基类的名字，如果为空，则默认继承object类ClassAttribute：定义在类的作用域则代表类的自有属性def Method(self[,arg1,arg2...]):这个是类里面的方法，只有类里面的方法才能对实例出来的数据进行操作self.instanceAttribute：实例属性,每个实例的值不一样，这是因为self关键字的缘故
    

例子1：(self字段的作用)

In [8]: class c1():   ...:     info='from class'   ...:     def __init__(self,myname):   ...:         self.name=myname   ...:     def printName(self):   ...:         print self.name   ...:             In [9]: i1=c1('tom')In [10]: i1.nameOut[10]: 'tom'In [11]: i2=c1('jerry')In [12]: i2.nameOut[12]: 'jerry'In [13]: i1.info,i2.infoOut[13]: ('from class', 'from class')__init__() :这个是类的内置方法，从超类object继承而来，作用是在类实例化的时候，自动执行一遍（这也是为什么要以两个下划线开头的原因，python解释器根据这些标记知道其有特殊含义，会执行特殊的操作），如果没有这个函数，我们就得手动执行函数里面的内容。self的作用：self起到类似记录实例名的作用，比如在本例中 i1=c1（'tom'），python解释器会自动执行 c1.__init_(i1,'tom') 操作，所以这里self就被替换成了i1实例名，而且因为python强制self放在第一位，由此，我们可以猜想，python是根据位置来传递实例名，而不是根据self关键字来传递的，事实也证明确实如此。证明：In [19]: class c1():...:     info='from class'...:     def __init__(s,myname):...:         s.name=myname...:     def printName(s):...:         print s.name...:             In [20]: i3=c1('hello')In [21]: i3.nameOut[21]: 'hello'In [22]: i4=c1('word')In [23]: i4.nameOut[23]: 'word'In [24]: i3.info,i4.infoOut[24]: ('from class', 'from class')In [25]: c1.__init__(i4,'jerry')In [26]: i4.nameOut[26]: 'jerry'其实类跟函数是很相似的，它也只是个可执行对象，只不过多了一些相关的控制机制

例子2：(类的继承和回调)

In [28]: class c1():    ...:     info='from c1'    ...:     def __init__(self,x):    ...:         self.name=x    ...:     def printInfo(self):    ...:         print self.name    ...:         In [30]: class c2(c1):    ...:     def printInfo(self):    ...:         print "hello,my name is : "    ...:         c1.printInfo(self)    ...:         In [31]: ins1=c2('jane')In [32]: ins1.printInfo()hello,my name is : janeIn [34]: c2.infoOut[34]: 'from c1'c2类继承了c1类的所有属性和方法，但是c2改写了c1的printInfo方法，在c2的方法中对c1的printInfo进行调用也就是所谓的"回调"

例子3：(类属性的影响)

In [11]: class c1():    ...:     info='from c1'    ...:     def __init__(self,x):    ...:         self.name=x    ...:     def printInfo(self):    ...:         print self.name    ...:         In [12]: ins1=c1('tom')In [13]: ins2=c1('jerry')In [14]: ins3=c1('boyka')In [15]: ins1.info,ins2.info,ins3.infoOut[15]: ('from c1', 'from c1', 'from c1')In [16]: ins2.info='change one'In [17]: ins1.info,ins2.info,ins3.infoOut[17]: ('from c1', 'change one', 'from c1')In [18]: c1.info='change all ins'In [19]: ins1.info,ins2.info,ins3.infoOut[19]: ('change all ins', 'change one', 'change all ins')

从上面可以看到ins2这个实例改变自身的info属性，不会影响到ins1和ins3，而c1类的info的改变，则改变了ins1和ins3，这是因为在实例化ins1,ins2,ins3的时候，（借用c语言的指针概念）它们都指向了类的info指针，而info指针指向了'from c1'这个数据块。默认情况下，当我们访问ins2.info的时候，python通过ins2的info指针找到类的info指针，然后通过类的info指针取得'from c1'数据。 当ins2.info重新赋值的时候，它新建一个数据对象'chang one',然后把自己的info指向'change one'，所以ins1，ins3不受影响，而c1.info重新赋值的时候，它也是新建一个'change all ins'对象，然后类的info指针指向'change all ins'，而此时ins1和ins3的指针还是指向类的info指针，所以ins1和ins3的info取回的值都变了 (这个解释是错的，因为这样ins1.info和ins3.info的id应该不变，但是我测试是变化的，这里为了便于理解记忆暂时这么解释，待查明)