python定制数据类型（继承与授权)两种方式

A.授权方式 ：

import time
class Open:
    def __init__(self,filepath,mode = 'r',encoding='utf-8'):
        self.x = open(filepath, mode=mode, encoding=encoding)
        self .filepath = filepath
        self.mode = mode
        self.encoding = encoding
    def write(self,line):
        t = time.strftime('%Y-%m-%d-%X')
        self.x.write('%s %s'%(t,line))
    def __getattr__(self, item):
        return getattr(self.x,item)
f = Open('b.txt','r+')
f.write('[error] ddddddd
')
f.write('[error] ddddddd
')
f.write('[error] ddddddd
')
f.write('[error] ddddddd
')
f.write('[error] ddddddd
')
f.seek(0)
print(f.read())
print("读取完了"+f.read())

2017-04-24-23:29:26 [error] ddddddd
2017-04-24-23:29:26 [error] ddddddd
2017-04-24-23:29:26 [error] ddddddd
2017-04-24-23:29:26 [error] ddddddd
2017-04-24-23:29:26 [error] ddddddd

读取完了

 授权案例二

# 基于授权定制自己的列表类型，要求定制的自己的__init__方法，
#     定制自己的append：只能向列表加入字符串类型的值
#     定制显示列表中间那个值的属性（提示：property）
#     其余方法都使用list默认的（提示：__getattr__加反射）
# import traceback,sys
class List:
    """定制名为List类,继承自 list类型"""
    def __init__(self,panda=None):
        self.panda = panda
        # if(type(panda) == list): #如果给进来的值是列表，就迭代
        #     for i,v in enumerate (panda):
        #         if v and type(v) == str :
        #             self.panda.append(v)
        #             # super().append(v)  # 调用父类append将每项值写入
        # else:
        #     self.panda.append(panda)
        #     # super().append(panda)
    @property
    def middle(self):
        """猎取列表的中间值"""
        return self.panda[int(len(self.panda) / 2)]
    def append(self, p_object):
        """追加选项到列表"""
        if not isinstance(p_object,str):
            raise  TypeError("must be int")
        self.panda.append(p_object)
        # super().append(p_object)   #调用父类的append方法追加
    def __getattr__(self, item):
        #利用反射，如果没有定义的item项，
        # 就把它作为字符返回对象
        return getattr(self.panda,item)

    def __str__(self):  #这个是把对象转字符串（反序列）
        return str(self.panda)
l = List([1,2,"bb"])
l.append("a")
l.append("["a1",23,"a2"]")
l.append("e")
l.insert(0,'33333')
l.insert(1,'aaaa')
print(l)
p = ['a','b','c']
p=List(p)
p.append('k')
print(p)
print(p.middle)

l1 = List(['aa','ddd',1,2,"bb"])
print(l1.middle)

 B.继承方式:

 1 # 基于授权定制自己的列表类型，要求定制的自己的__init__方法，
 2 #     定制自己的append：只能向列表加入字符串类型的值
 3 #     定制显示列表中间那个值的属性（提示：property）
 4 #     其余方法都使用list默认的（提示：__getattr__加反射）
 5 # import traceback,sys
 6 class List(list):
 7     """定制名为List类,继承自 list类型"""
 8     def __init__(self,panda=None):
 9         if(type(panda) == list): #如果给进来的值是列表，就迭代
10             for i,v in enumerate (panda):
11                 if v and type(v) == str :
12                     super().append(v)  # 调用父类append将每项值写入
13         else:
14             super().append(panda)
15     @property
16     def middle(self):
17         """猎取列表的中间值"""
18         return self[int(len(self) / 2)]
19     def append(self, p_object):
20         """追加选项到列表"""
21         if not isinstance(p_object,str):
22             raise  TypeError("must be int")
23         super().append(p_object)   #调用父类的append方法追加
24     def __getattr__(self, item):
25         #利用反射，如果没有定义的item项，
26         # 就把它作为字符返回对象
27         return getattr(self,item)
28 l = List([1,2,"bb"])
29 l.append("a")
30 l.append("["a1",23,"a2"]")
31 l.append("e")
32 l.insert(0,'33333')
33 l.insert(1,'aaaa')
34 print(l)
35 # p = ['a','b','c']
36 # p=List(p)
37 # print(p.middle)
38 # print(l[int(len(l)/2)])
39 # l1 = List(['aa','ddd',1,2,"bb"])
40 # print(l1.middle)

class List(list):
    """定制名为List类,继承自 list类型"""

    def __init__(self, panda=None):
        if (type(panda) == list):  # 如果给进来的值是列表，就迭代
            for i, v in enumerate(panda):
                if v and type(v) == str:
                    super().append(v)  # 调用父类append将每项值写入
        else:
            super().append(panda)

    @property
    def middle(self):
        """猎取列表的中间值"""
        return self[int(len(self) / 2)]

    def append(self, p_object):
        """追加选项到列表"""
        if not isinstance(p_object, str):
            raise TypeError("must be int")
        super().append(p_object)  # 调用父类的append方法追加
l = List(['a','b','c','d','l','m'])
l.append('keep')
l.append('keep')
l.insert(0,'dddd')  #继承list类型的insert
print(l.middle)
print(l)