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])