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應該不變，但是我測試是變化的，這裏爲了便於理解記憶暫時這麼解釋，待查明)