参考：

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.name

Out[10]: 'tom'

In [11]: i2=c1('jerry')

In [12]: i2.name

Out[12]: 'jerry'

In [13]: i1.info,i2.info

Out[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.name

Out[21]: 'hello'

In [22]: i4=c1('word')

In [23]: i4.name

Out[23]: 'word'

In [24]: i3.info,i4.info

Out[24]: ('from class', 'from class')

In [25]: c1.__init__(i4,'jerry')

In [26]: i4.name

Out[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 :

jane

In [34]: c2.info

Out[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.info

Out[15]: ('from c1', 'from c1', 'from c1')

In [16]: ins2.info='change one'

In [17]: ins1.info,ins2.info,ins3.info

Out[17]: ('from c1', 'change one', 'from c1')

In [18]: c1.info='change all ins'

In [19]: ins1.info,ins2.info,ins3.info

Out[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应该不变，但是我测试是变化的，这里为了便于理解记忆暂时这么解释，待查明)