[3]自定义序列类

序列分类

按存储的数据进行分类

• 容器序列，能够存储任何类型的数据
  list,tuple,deque
• 扁平序列，只能存储同一种类型的数据
  str,bytes,bytearray,array.array

按照存储的数据是否能改变进行分类

• 可变序列
  list,deque,bytearray,array
• 不可变序列
  str,tuple,bytes

+,+=、extend、append的区别

• +号两边的类必须一致。例如，如果一个list加tuple会报错
• +=允许两边的类型不一致，内部会通过调用extend，迭代添加元素
• extend，迭代添加元素
• append，在列表中追加指定的一个元素

切片操作

list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]


# [开始位置:结束位置:步长]
#开始位置默认为0
print("list[:3] => ", list[:3])
#结束位置默认为切片末尾
print("list[1:] => ", list[1:])
#开始、结束都省略截取完整的序列
print("list[:] => ", list[:])
#截取下标为偶数
print("list[::2] => ", list[::2])
#截取下标为基奇数
print("list[1::2] => ", list[1::2])
#反序
print("list[::-1] => ", list[::-1])
#删除尾部
l = list[:]
l[3:] = []
print('l[3:] = [] => ', l)
#删除头部
l = list[:]
l[:3] = []
print('l[:3] = [] => ', l)
#删除中间
l = list[:]
l[5:6] = []
print('l[5:6] = []=> ', l)
#头部添加
l = list[:]
l[:0] = ["a", "b"]
print('l[:0] = ["a", "b"]=> ', l)
#尾部追加
l = list[:]
l[len(l):] = ["a", "b"]
print('l[len(l):] = ["a", "b"]=> ', l)
#替换
l = list[:]
l[7:8] = ["a", "b", "d"]
print('l[3:5] = ["a", "b"]=> ', l)
#每隔一个，替换一个
l = list[:]
l[::2] = [0]*5
print('l[::2] = []=> ', l)

自定义序列类

import numbers

class Group:
    def __init__(self, company_name, group_name, staff):
        self.company_name = company_name
        self.group_name = group_name
        self.staff = staff
        pass
    
    # 需要实现__getitem__协议才能使用切片操作
    def __getitem__(self, item):
        # 希望切片返回的是Group实例而不是序列
        cls = type(self)
        if isinstance(item, slice):
            #重新将序列分装成Group实例
            return cls(self.company_name, self.group_name, self.staff[item])
        elif isinstance(item, numbers.Integral):
            #如果是通过下标访问Group，需要获取序列中的某个值，转成序列，再分装成Group实例
            return cls(self.company_name, self.group_name, [self.staff[item]])
    def __reversed__(self):
        pass
    def __iter__(self):
        pass

group = Group('HOME', "STUDY", ['tom', 'cat', 'fish', 'dog'])

print(group[:2].staff)
print(group[0].staff)

bisect 维护已排序的序列

通过bisect提供的方法实现

方法	作用
insort_right(list,item)	插入元素item，如果序列中存在相同的数值，向右边插入
insort_left(list,item)	插入元素item，如果序列中存在相同的数值，向左边插入
ibisect_left(list,item)	插入元素item，如果序列中存在相同的数值，向左边返回待插入的位置
bisect_right(list,item)	插入元素item，如果序列中存在相同的数值，向右边返回待插入的位置

import bisect

list = [1, 3, 4, 5, 6, 6, 6, 7, 8, 9]

l1 = list[:]
bisect.insort_right(l1, 6.0)
print(l1)

l1 = list[:]
bisect.insort_left(l1, 6.0)
print(l1)

l1 = list[:]
print(bisect.bisect_right(l1, 6.0))#待插入的位置是7
l1 = list[:]
print(bisect.bisect_left(l1, 6.0))#待插入的位置是4

数组

数组的处理比列表高效，数组只能存放同一种数据

import array

arr = array.array('i')

arr.append(10)
arr.append(20)

for i in arr:
    print(i)

列表推导式、字典推导式、集合推导式、列表生成器

# 列表推导式
# 获取10以内的偶数
l = [i for i in range(10) if i % 2 == 0]
print(l)

# 字典推导式
# 将key和value 交换
dist = {10: 'tom', 20: 'cat', 30: 'pig'}
d = {value: key for key, value in dist.items()}
print(d)

# 集合推导式
# 获取字典的key
dist = {'name': 'tom', 'age': 10, 'sex': 'boy'}
s = {k for k in dist}
print(s)

# 列表生成器
gen = (i for i in range(20))
print(gen)