Python自定义序列类型

1. 序列类型

1.1 序列之间有什么区别?

序列的类型表：

序列类别	序列类型
容器序列	list ，tuple，deque
扁平序列	str，bytes，bytearray，array.array
可变序列	list，deque，bytearray，array
不可变序列	str，tuple，bytes

这里简单的解释一下各个序列的作用：

1.容器序列

🌙可以存放不同的数据类型和不同的对象引用，举个代码例子：

class Demo:
    pass

class Demo01:
    pass

if __name__ == '__main__':
   a = [Demo01, Demo, 5, "name", 0.01]
   print(type(a)) #list类型
   b = (Demo01, Demo, 5, "name", 0.01)
   print(type(b)) #tuple类型
   c=collections.deque([Demo01, Demo, 5, "name", 0.01]) 
   print(type(c)) #deque类型
   print(a)  #测试输出结果 都能打印出对应的值
   print(b)
   print(c)

2.扁平序列

🌙该序列只能容纳一种类型，存放的只有值类型，下表中的 str(字符串)不过多解释，bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本，bytearray字节数组也是可变的字节序列，这里主要解释array.array关于array.array的初始化类型：

# 只举几个例子
arr1 = array.array("I") #表示存放int类型
arr1.append(5)
arr1.append(8)
print(arr1)
print(type(arr1))
arr2 = array.array("b") #表示存放int类型
print(arr2)
print(type(arr2))
arr3 = array.array("B") #表示存放int类型
arr3.append(10)
arr3.append(5)
print(arr3)
print(type(arr3))
arr4 = array.array("f") #表示存放float类型
arr4.append(0.5)
arr4.append(1)
print(arr4) 
print(type(arr4))  #类型都是array.array 通过传递的字符串参数确定要使用的存储类型

🌙上述代码中( I b B )都是int类型，其实在它们的底层是用C语言存放的不同类型。

3.可变序列

🌙可以进行增删改地址不会变化这里举list和array的例子：

a = [1, 2, 3, 4, 5, 6]
b = array.array('I', [6, 7, 8, 9, 10])

if __name__ == '__main__':
    print("list初始地址", id(a))
    print("array初始地址", id(b))
    a.append(10)
    b.append(6)
print(a)
print("list添加值后的地址", id(a))
print(b)
print("array添加值后的地址", id(b))

输出结果：

4.不可变序列

🌙只能重新申请新的空间地址，无法增删改初始的值
str，tuple，bytes这些类型初始定义就不能进行直接的修改或者删除某个值，所有被定义为不可变序列

2. 序列+、+=、extend的区别

2.1 +和+=的区别

a = [1, 2]
c = a + [3, 4]  
print(id(c))
print(id(a))
print(c) #重新创建了一个list

# += 就地加
print(id(a))
a += [3, 4]
print(a)
print(id(a)) #同一个地址

输出结果：

第二个重点区别：

from collections import abc

a = [1, 2]
a += (3, 4)  #把[] 改成()  
print(a) #执行成功

c = a + (3, 4)  #把[] 改成()
#报错 TypeError: can only concatenate list (not "tuple") to list

🌙“+=” 能成功添加的原因是因为MutableSequence中的iadd魔法函数调用了extend这个方法，extend可以添加任意可迭代的数据。
看一下extend方法的使用：

a = [1, 2]

if __name__ == '__main__':
    a.extend((1, 2, 3)) #添加tuple
    a.extend([5, 6, 7]) #添加 list
    a.extend(({"Name": "张三"})) #添加dict
    a.extend(range(5, 10)) #range添加
    b = a.extend((7, 7, 7)) #注意此时的b是一个返回值类型
    print(b) #None extend不存在放回值
    print(a)

2.2 extend和append方法的区别

a = [1, 2]

if __name__ == '__main__':
    a.extend((1, 2, 3))
    print(a) #输出[1, 2, 1, 2, 3]
    a.append((5, 6, 7))
    print(a) #输出[1, 2, 1, 2, 3, (5, 6, 7)] 

🌙 extend内部会循环添加的类型，append直接添加不会遍历插入

3. 可切片对象

alist = [1, 2, 3, 4, 5, 6]

if __name__ == '__main__':
# 第一个: 表示起始默认0  第二个: 表示截取长度默认len  第3个表示截取步长默认1
print(alist[::])  # 截取从0开始 len长度 步长为1 所有直接输出原列表
print(alist[::-1])  # 返回原列表的逆序排列 步长为负数 从后往前
print(alist[::2])  # 返回原列表的偶数位数据 (2为步长) 0为起始位
print(alist[1::2])  # 获取奇数位置的数据 0为起始位
print(alist[3:6])  # 从3开始截取长度为6
print(alist[0:100])  # 切片位置大于列表长度时,从列表尾部截断 返回所有元素
print(alist[100:])  # 切片开始位置大于列表长度时,返回空列表
alist[len(alist):] = [9]  # 在列表尾部增加元素
print(alist)
alist[:0] = [1, 2]  # 前面的0省略了,相当于是alist[0:0] = [1,2]
print(alist)      # 在列表的头部增加元素
alist[3:3] = [4]  # 在列表中间插入元素
print(alist)
alist[:3] = [1, 2]  # 相当于是alist[0:3] = [1,2] 替换列表元素
alist[3:] = [4, 5, 6]  # 替换元素,结果按照两边的最短元素来决定.
print(alist)
alist[:3] = []  # 删除列表中前三个元素 置为空
del alist[:3]     #切片元素连续
del alist[::2]     #隔一个删除一个,切片元素不连续

4. bisect处理已排序序列

import bisect
# bisect 处理(维持)已排序序列 升序
# 查找原理 二分查找

#内部方法
# insort = insort_right
# bisect = bisect_right
# insort_left
# bisect_left 

inter_lis = [] #可以定义任意可变序列

if __name__ == '__main__':

    bisect.insort(inter_lis, 3)
    bisect.insort(inter_lis, 4)
    bisect.insort(inter_lis, 1)
    bisect.insort(inter_lis, 9)
    a = bisect.bisect(inter_lis, 4)  # bisect就是bisect_right
    b = bisect.bisect_left(inter_lis, 4)
    print(b)  # 返回索引2 在left插入
    print(a)  # 返回索引3 在right插入
    print(inter_lis)  # 自动排序

🌙为什么要存在left和right两个方法：

inter_lis = [] #可以定义任意可变序列
inter_lis1 = []

#在操作 1和1.0时 内部认为两个值是相同的 这时候就需要left和right来选择插入
if __name__ == '__main__':
    
    bisect.insort(inter_lis, 1)
    bisect.insort(inter_lis, 1.0)
    print(inter_lis) #输出[1, 1.0]
    
    bisect.insort(inter_lis1, 1)
    bisect.insort_left(inter_lis1, 1.0)
    print(inter_lis1) #输出[1.0, 1]

5. 什么情况下不使用list

🌙 上述可变类型解释过array的用法，这里单独区分一下使用list和array的选择：

import array

add_list = []
add_array = array.array("I")

if __name__ == '__main__':
    add_list.extend([1, 2, "Name"])
    # add_array.extend([1, 2, "Name"]) 报错
    add_array.extend(range(3, 5))

🌙在存放不同类型的数据时选择list，在相同数据存储的情况下array的性能大于list

6. Python 生成式的写法

6.1 列表生成式

odd_list = []
odd_list = [i for i in range(21) if i % 2 == 1] #列表生成式
print(odd_list) #输出[0,21)的奇数集合

#在逻辑复杂的情况
def demo(x):
    return x*x
odd_list = [demo(x) for x in  range(21) if x % 2 == 1]

在复杂的情况 列表生成式性能高于列表操作

6.2 生成器表达式

odd_list = (i for i in range(21) if i % 2 == 1) #生成器
odd_list1 = list(odd_list) #生成list
print("奇数集合", oddlist1)

6.3 字典推导式

My_dict = {"name":"张三", "Age":19}
My_dic = {value:key for key ,value in My_dict.items()}
print("输出整个dict", My_dic)

6.4 集合推导式子

My_dict = {"name":"张三", "Age":19}
my_set ={key for key, value in My_dict.items()}
print("输出key", my_set)
my_set ={value for key, value in My_dict.items()} # items
print("输出value", my_set)
my_set = {value: key for key, value in My_dict.items()}  # items
print(type(my_set))
print("反向输出dict", my_set)