python的类（简介，没什么内容）

参考：

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

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

原文地址：http://blog.51cto.com/linzb/2089843