python-自定義一個序列

　　python的序列可以包含多個元素，開發者只要實現符合序列要求的特殊方法，就可以實現自己的序列

　　序列最重要的特征就是可以包含多個元素，序列有關的特使方法：

1. __len__(self):該方法的返回值決定該序列元素的個數
2. __getitem__(self,key):獲取指定索引的對應的元素。key應該是整數值，否則會引發TypeError
3. __contains__(self,item):判斷序列是否包含元素
4. __setitem__(self,key,value):設置指定索引對應的元素
5. __delitem__(self,key):刪除指定索引對應的元素

　　問題描述：自定義一個序列，該序列按順序包含52張撲克，分別是黑桃，紅心，梅花，方塊的2-A

　　要求：提供序列的各種操作方法

7 def check_key(key):           
  8     if not isinstance(key,int):raise TypeError("索引值必須是整數")
  9     if key < 0:raise IndexError("索引值必須是非負數")
 10     if key >= 52:raise IndexError("索引值不能大於%d" %52)
 11 class poker:                  
 12     def __init__(self):       
 13         #用於儲存被修改的數據 
 14         self.__change = {}    
 15         #用於存儲已經刪除元素的索引
 16         self.__delete = []    
 17     def __len__(self):        
 18         return 52             
 19                               
 20     def __getitem__(self,key):
 21         check_key(key)        
 22         if key in self.__change:   
 23             return self.__change[key]
 24         if key in self.__delete:   
 25             return None       
 26         ret = ""              
 27         i = key // 13         
 28         if i == 0:            
 29             ret = "黑桃"      
 30         elif i == 1:          
 31             ret = "紅心"      
 32         elif i == 2:          
 33             ret = "梅花"      
 34         else:                 
 35             ret = "方塊"      
 36         i = key%13            
 37         if i < 9:             
 38             ret = ret + str(i + 2)
39         if i == 9:   
 40             ret = ret + "J"  
 41         if i == 10:  
 42             ret = ret + "Q"  
 43         if i == 11:  
 44             ret = ret + "K"  
 45         if i == 12:  
 46             ret = ret + "A"  
 47         #根據計算返回元素列表
 48         return ret   
 49     def __setitem__(self,key,value):
 50         check_key(key)    
 51         self.__change[key] = value
 52     def __delitem__(self,key,value):
 53         check_key(key)    
 54         if key not in self.__delete:
 55             self.__delete.append(key)
 56         if key in self.__change:
 57             del self.__change[key]
 58 if __name__ == "__main__":
 59     sequece = poker()
 60     print(len(sequece))
 61     for i in sequece:
 62         print(i,end = "\t")
 63     print()                            

運行結果：

52
黑桃2   黑桃3   黑桃4   黑桃5   黑桃6   黑桃7   黑桃8   黑桃9   黑桃10
黑桃J   黑桃Q   黑桃K   黑桃A   紅心2   紅心3   紅心4   紅心5   紅心6
紅心7   紅心8   紅心9   紅心10  紅心J   紅心Q   紅心K   紅心A   梅花2
梅花3   梅花4   梅花5   梅花6   梅花7   梅花8   梅花9   梅花10  梅花J
梅花Q   梅花K   梅花A   方塊2   方塊3   方塊4   方塊5   方塊6   方塊7
方塊8   方塊9   方塊10  方塊J   方塊Q   方塊K   方塊A

　　大家可能會有疑問，該序列是如何生成序列中的所有元素的？

　　該序列本身並不保存序列元素，序列會根據索引動態的計算序列元素，因此序列需要被修改和被刪除的元素。該序列引用__change,__delete來保存被修改和被刪除的元素。

 7 """                  
  8 自定義一個序列，該序列順序包含所有的三位數(100,101.....999)
  9                      
 10 """                  
 11                      
 12 def check_key(key):  
 13     if not isinstance(key,int):raise TypeError("索引值必須是整數")
 14     if key < 0:raise IndexError("索引值必須是非負數")
 15     if key > 899:raise IndexError("索引值不能大於%d" %900)
 16 class third_number:  
 17     def __init__(self):
 18         #用於儲存被修改的數據
 19         self.__change = {}
 20         #用於存儲已經刪除元素的索引
 21         self.__delete = []
 22     def __len__(self):
 23         return 900   
 24                      
 25     def __getitem__(self,key):
 26         check_key(key)
 27         if key in self.__change:
 28             return self.__change[key]
 29         if key in self.__delete:
 30             return None
 31         number = key + 100
 32         return number
 33                      
 34     def __setitem__(self,key,value):
 35         check_key(key)
 36         self.__change[key] = value
 37     def __delitem__(self,key,value):
 38         check_key(key)
39         if key not in self.__delete:
 40             self.__delete.append(key)
 41         if key in self.__change:
 42             del self.__change[key]
 43 if __name__ == "__main__":
 44     sequece = third_number()
 45     print(len(sequece))
 46     for i in sequece:
 47         print(i,end = "\t")
 48     print()          
 49     print(sequece[1])