谁能跟我讲讲为什么要继承父类，什么意思呢。谢谢

lhx19901216

1. class CountList(list):
   
2.     def __init__(self, *args):
   
3.         [color=DarkRed]super().__init__(args)[/color]
   
4.         self.count = []
   
5.         for i in args:
   
6.             self.count.append(0)
   
7. 
   
8.     def __len__(self):
   
9.         return len(self.count)
   
10. 
    
11.     def __getitem__(self, key):
    
12.         self.count[key] += 1
    
13.         return super().__getitem__(key)
    
14. 
    
15.     def __setitem__(self, key, value):
    
16.         self.count[key] += 1
    
17.         super().__setitem__(key, value)
    
18. 
    
19.     def __delitem__(self, key):
    
20.         del self.count[key]
    
21.         [color=Red]super().__delitem__(key)[/color]
    
22. 
    
23.     def counter(self, key):
    
24.         return self.count[key]
    
25. 
    
26.     def append(self, value):
    
27.         self.count.append(0)
    
28.      [color=Red]   super().append(value)[/color]
    
29. 
    
30.     def pop(self, key=-1):
    
31.         del self.count[key]
    
32.         return super().pop(key)
    
33. 
    
34.     def remove(self, value):
    
35.         key = super().index(value)
    
36.         del self.count[key]
    
37.       [color=Red]  super().remove(value)[/color]
    
38. 
    
39.     def insert(self, key, value):
    
40.         self.count.insert(key, 0)
    
41.         super().insert(key, value)
    
42. 
    
43.     def clear(self):
    
44.         self.count.clear()
    
45.         super().clear()
    
46. 
    
47.     def reverse(self):
    
48.         self.count.reverse()
    
49.         super().reverse()
    

复制代码

隨鈊乄鎍慾

我谈谈我的看法吧：1.因为继承了父类，才可以使用下面的super().xxx方法，省了很多事；2.继承了父类就可能直接通过实例名访问到列表了。关于第二点我给你两段代码作一个比较你就清楚了

1. 第一段代码继承了父类：
   
2. class CountList(list):
   
3.     def __init__(self, *args):
   
4.         super().__init__(args)
   
5.         self.count = []
   
6.         for i in args:
   
7.             self.count.append(0)
   
8. 
   
9.     def __len__(self):
   
10.         return len(self.count)
    
11. 
    
12.     def __getitem__(self, key):
    
13.         self.count[key] += 1
    
14.         return super().__getitem__(key)
    
15. 
    
16.     def __setitem__(self, key, value):
    
17.         self.count[key] += 1
    
18.         super().__setitem__(key, value)
    
19. 
    
20.     def __delitem__(self, key):
    
21.         del self.count[key]
    
22.         super().__delitem__(key)
    
23. 
    
24.     def counter(self, key):
    
25.         return self.count[key]
    
26. 
    
27.     def append(self, value):
    
28.         self.count.append(0)
    
29.         super().append(value)
    
30. 
    
31.     def pop(self, key=-1):
    
32.         del self.count[key]
    
33.         return super().pop(key)
    
34. 
    
35.     def remove(self, value):
    
36.         key = super().index(value)
    
37.         del self.count[key]
    
38.         super().remove(value)
    
39. 
    
40.     def insert(self, key, value):
    
41.         self.count.insert(key, 0)
    
42.         super().insert(key, value)
    
43. 
    
44.     def clear(self):
    
45.         self.count.clear()
    
46.         super().clear()
    
47. 
    
48.     def reverse(self):
    
49.         self.count.reverse()
    
50.         super().reverse()
    
51. 
    
52. list1=CountList("one","two","there",5,4,3,"five","four")
    
53. 
    
54. 第二段代码不继承父类：
    
55. class Mylist:
    
56.     def __init__(self,*args):
    
57.         self.values=[x for x in args]
    
58.         value=[0 for x in args]
    
59.         self.count=dict(zip(self.values,value))
    
60.     def __len__(self):
    
61.         return len(self.values)
    
62.         
    
63.     def __getitem__(self,key):
    
64.         self.count[self.values[key]]+=1
    
65.         return self.values[key]
    
66.     def __setitem__(self,key,value):
    
67.         self.values[key]=value
    
68. 
    
69.     def __delitem__(self,key):
    
70.         self.count.pop(self.values[key])
    
71.         self.values.remove(self.values[key])
    
72. 
    
73.     def counter(self,index):
    
74.         return self.count[self.values[index]]
    
75.         
    
76.     def append(self,value):
    
77.         self.values.append(value)
    
78.         self.count[value]=0
    
79. 
    
80.     def pop(self,index):
    
81.         self.count.pop(self.values[index])
    
82.         self.values.pop(index)        
    
83. 
    
84.     def remove(self,value):
    
85.         self.count.pop(value)
    
86.         self.values.remove(value)
    
87. 
    
88.     def insert(self,index,value):
    
89.         self.count[value]=0
    
90.         self.values.insert(index,value)
    
91. 
    
92.     def clear(self):
    
93.         self.count.clear()
    
94.         self.values.clear()
    
95. 
    
96.     def reverse(self):
    
97.         self.values.reverse()
    
98.         
    
99. 
    
100. list2=Mylist("one","two","there",5,4,3,"five","four")
     

复制代码

隨鈊乄鎍慾

看下它们的执行后的区别：

1. 第一段代码执行了结果是这样的：
   
2. >>> list1
   
3. ['one', 'two', 'there', 5, 4, 3, 'five', 'four']
   
4. 第二段代码没继承父类执行结果如下：
   
5. >>> list2
   
6. <__main__.Mylist object at 0x0000000002B34828>
   
7. >>>
   
8. >>>
   
9. >>>
   

复制代码