在寫排序演算法的時候，想到使用繼承來定義一個頂層父類，來為各種排序演算法定義一個演算法框架，然後讓各種排序演算法繼承基類，覆蓋演算法規則，實現自己的排序。所以稍微學習了python的繼承實現機制

首先是頂層的父類：

1. # -*- coding:utf-8 -*-
2. #所有排序方法的基類
3. import random  
4. class MySort(object):  
5.     def __init__(self, name, initial_len):  
6.         self.name = name  
7.         self.initial_len = initial_len  
8.         print"init..."
9.     def init(self):  
10.         self.data = []  
11.         i = self.initial_len  
12.         while (i > 0):  
13.             i = i - 1
14.             r = random.randint(0, 99)  
15.             self.data.append(r)  
16.         returnself.data  
17.     def sort(self):  
18.         pass
19.     def outName(
    self):  
20.         printself.name  
21.     def outData(self):  
22.         printself.data  

然後是具體的子類歸併排序，非遞迴實現：

1. #-*- coding:utf-8 -*-
2. import MySort  
3. class MergeSort(MySort.MySort):  
4.     def __init__(self):  
5.         super(MergeSort, self).__init__("mergeSort", 11)  
6.         self.pre()  
7.     def pre(self
   ):  
8.         self.data = self.init()  
9.         printself.data  
10.     def sort(self):  
11.         data = self.data  
12.         tmp = [0for i in range(11)]  
13.         i = 1#子序列長度
14.         size = len(data)  
15.         while i < size:  
16.             self.mergeSort(data, tmp, i, size)  
17.             i = i * 2
18.             self.mergeSort(tmp, data, i, size)  
19.             i = i * 2
20.     def mergeSort(self, data, tmp, s, e):  
21.         i = 0
22.         while i + 2 * s < e:  
23.             self.ms(data, tmp, i, i + s, i + 2 * s)  
24.             i = i + 2 * s  
25.         if i + s < e:  
26.             self.ms(data, tmp, i, i + s, e)  
27.         else:  
28.             while i < e:  
29.                 tmp[i] = data[i]  
30.                 i = i + 1
31.     def ms(self, data, tmp, s, m, e):  
32.         k = s  
33.         len = m  
34.         while (len - s) > 0and (e - m) > 0:  
35.             if data[s] < data[m]:  
36.                 tmp[k] = data[s]  
37.                 s = s + 1
38.             else:  
39.                 tmp[k] = data[m]  
40.                 m = m + 1
41.             k = k + 1
42.         if (len - s) > 0:  
43.             while s < len:  
44.                 tmp[k] = data[s]  
45.                 k = k + 1
46.                 s = s + 1
47.         else:  
48.             while m < e:  
49.                 tmp[k] = data[m]  
50.                 k = k + 1
51.                 m = m + 1
52.     def outName(self):  
53.         super(MergeSort,self).outName()  
54.     def outData(self):  
55.         super(MergeSort,self).outData()  
56. if __name__ == "__main__":  
57.     s = MergeSort()  
58.     s.outName()  
59.     s.sort()  
60.     s.outData()   

其中對於繼承來說，如果父類有__init__方法，那麼子類定義了__init__方法的時候必須通過super關鍵字顯式呼叫父類的init的方法，用以對父類進行初始化。對於super，其是python的一個內建方法，可以直接呼叫。python的所有內建函式可以檢視https://docs.python.org/3.4/library/functions.html。在舊的類風格中呼叫就是FatherClass.__init__()方法。

當想通過super呼叫父類初始化方法的時候，必須使用在新的類風格中。新的類風格從python2.2引入，而舊的類風格在python3中將徹底去除。新的類是所有的類都預設繼承一個頂層父類object類，這一點類似與java的設計思想。在python3之前，通過原始的建立類的方式是採用的預設的舊風格的類，即通過class ClassName方式建立；要想使用新的類風格，則必須指定一個整合的父類(如果沒有，則繼承object)，即class ClassName(object)。

這裡呼叫父類的初始化方法就像java中子類中定義了非預設建構函式則必須呼叫父類的建構函式是一個概念。但是需要注意的是，編譯器在你不主動呼叫的時候，它是不會給出錯誤警告。

使用super的好處之一，當繼承的父類更改之後，不用在每個子類都去修改父類名字。就如本例，MergeSort繼承MySort，如果不使用 super(MergeSort,self).outName()來呼叫頂層方法，那就必須使用MySort.outName()。如果父類改名之後，那必須在每個子類中都修改此處呼叫才可以。但是使用super的話就不必如此麻煩。

對於一箇舊的類風格，當通過子類訪問一個屬性的時候，比如subClass.value，它首先會在本類中進行查詢，查詢到則返回；否則去父類查詢，如果多個父類，則是從左到有依次進行查詢。其實可以從此看出python和java的整合在很多情況下都是差不多的。但是相對與新的類風格，通過子類訪問屬性的時候就比較複雜。

附錄：