5.Python 常见的序列

认识序列

序列 (sequence），是指一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的索引访问它们。即一类数据结构，用来存储一组有序排列元素。

在Python中，序列主要包括列表（list）、元组（tuple）和range对象、字符串（str）、字节串（bytes）、字节数组（bytearray)，，其中，list、tuple 利 range 对象是3种基本序列类型，也是最常用的对象。

序列通用操作

其中s 和 t 是具有相同类型的序列，n、i、j 和 k 是整数，x 是满足 s 所规定的类型和值限制的任意对象。

根据是否允许写操作，序列可分为可变序列和不可变序列：

• 可变序列：可读可写，主要包括列表、字节数组；
• 不可变序列：只读，主要包括元组、字符串、字节串和range对象。

可变序列专属的操作

其中s是可变序列类型的实例，t是任意可迭代对象，x是符合对s所规定类型与值限制的任何对象，如bytearray 仅接受满足0≤x≤255 值限制的整数。

相同类型的序列也支持比较，tuple 和list 可以通过字典顺序比较对应元素，只有每个元素结果都相等，且两个序列长度相同，两个序列才相等。

所有可变类型都是不可hash（哈希）的，所有不可变的类型都可以hash。

操作序列

序列是以非负整数作为索引的有限有序集。使用内置函数 len(sequence)，可以获取一个序列的条目数道，当一个序列的长度为n时，索引集包含数字0、1、⋯、n-1；当下标为负数时，索引顺序替换为len(sequence)+n，如下：

序列的读取、写入和查看索引

语法格式如下：

# 序列 sequence，value表示数值，i 表示条目索引
variable = sequence[i] # 读取指定元素的值，当下标超出序列的索引范围，将抛出IndexError异常
sequence[i] = value # 为指定元素写入值
sequence.index(value) # 获取指定值的索引，返回非负整数

切片

使用索引可以操作单个条目，使用切片可以操作指定范围内的多个条目。语法如下：

sequence[start_index:end_index:step]

l = [1,2,3,4,5,6,7]
print(l[0:5]) # 输出为[1,2,3,4,5]
print(l[5:8]) # 输出为[6,7]
print(l[2:2]) # 输出为[]
print(l[-3:-1]) # 输出为[5,6]
print(l[-1:-3]) # 输出为[]
print(l[:]) # 输出为[1,2,3,4,5]
print(l[:5]) # 输出为[1,3,5,7]
print(l[::2]) # 输出为[1,3,5,7]

(1）start index：表示开始索引位置，默认为 0，包含该索引位置。如果省略或为 None，则使用0；如果大于 len(sequence)，则使用 len(sequence)。

(2) end index：表示结束索引位置，默认为序列长度 len(sequence)，不包含该索引位置。

如果省略或为 None，则使用0。

如果大于 len(sequence)，则使用 len(sequence)。

当 step 不为负值时，如果 start_index 索引位置位于 end index 索引位置的右侧，则返回空序列。

当 step 为负值时，如果start_index 索引位置位于end_ index 索引位置的左侧，则返回空序列。

(3）step：表示步长，默认为 1，但是不能为 0。当步长省略时，可以同步省略最后一个冒号。如果step为 None，则当作1处理。

如果start_index 或end_index 为负值，则索引顺序相对于序列的末尾：索引号被替换为 len(s)+start_index或len(s)+end_index，但要注意-0仍然为0。

切片操作不回因为下标超出而抛出异常，而是简单地在序列尾部截断或者返回一个空序列。

运算

s1 + s2 ：两个相同类型的序列可以执行加法运算，相当于合并操作；

s * n 或 n * s：一个序列乘以一个整数n，表示重复合并该序列n次。如果n为负数，则当做0处理，生成一个同类型的空序列。

max(s)：获取序列包含的最大值；

min(s)：获取序列包含的最小值；

sum(s)：计算序列中包含元素的和（只有数字型才可以）；

x in s 和x not in s：判断指定的元素是否存在于指定的序列中；

any(s)：返回布尔值，序列中有一个元素的值为真就返回 True， 都为假时才返回 False.

all(s)：返回布尔值，序列中全部为真时返回 True，只要有一个假就返回 False。

a = [1,2,3]
b = [4,5,6]
print(a+b) # 输出为[1,2,3,4,5,6]
l = [1,2,3]
print(l*4) # 输出为[1,2,3,1,2,3,1,2,3,1,2,3]
print(l*-4) # 输出为[]
print(max(s)) # 输出为3
print(min(s)) # 输出为1
print(sum(s)) # 输出为6
print(1 in a) # 输出为True
print(4 not in a) # 输出为True

压缩和解压

使用zip()函数可以将多个可迭代的对象压缩为一个对象，多个对象中的元素根据对应索引位置组成一个元组，然后返回由这些元组组成的可迭代对象。

zip([iterable,...])

参数 iterable 是一个或多个迭代器。返回一个可迭代的zip对象，使用list()函数可以把zip对象转换为列表。如果各参数 iterable 的元素个数不一致，则返回zip对象的长度与最短的 iterable 对象相同。

使用*号运算符，可以对zip对象进行解压，返回值为多维矩阵式；

zip(*zip)

a = [1,2,3]
b = [4,5,6]
c = [7,8,9,10.11]
d = zip(a,b) # 返回zip对象
print(list(d)) # 将zip对象转换为列表：[(1,4),(2,5),(3,6)]
e = zip(a,b,c) # 返回zip对象
a1,b1,c1 = zip(*e) # 解压
print(list(a1)) # 输出[1,2,3]
print(list(b1)) # 输出[4,5,6]
print(list(c1)) # 输出[7,8,9]

枚举函数

使用enumerate()函数可以将一个序列对象组合为一个索引序列，常用在for循环中，语法如下：

enumerate(sequence,[start=0])

参数sequence表示一个序列、迭代器，或者其他支持迭代的对象；start 表示下标起始位置；返回一个enumerate枚举对象。

list1 = ['a','b','c','d'] # 定义列表
enum = enumerate(list1) # 转换为枚举对象
list2 = list(enum) # 转换为列表
print(list2) # 输出为[(0,'a'),(1,'b'),(2,'c'),(3,'d')]
for index,value in enumerate(list1): # 遍历enumerate对象
    list1[index] = value.upper() # 读取每个元素，然后转换为大写形式，再写入
    print(list1) # 输出['A','B','C','D']

排序

sequence.reverse()：翻转顺序。直接在调用对象上改动，没有返回值，因此不可变对象不能调用。

reversed(sequence)：翻转顺序。返回翻转后的序列对象。

sequence.sort()：自定义排序。直接在调用对象上改动，没有返回值，因此不可变对象不能调用。

sorted(sequence[,key[,reverse])：自定义排序。reverse = True 降序，reverse = False 升序（默认）。

a = [1,2,3]
a.reverse()
print(a) # 输出为[3,2,1]
r = range(4)
print(list(reversed(r)) # 输出[3,2,1,0]
b = [5,2,3,1,4]
print(sorted(b,reverse = False)) # 输出 [5,4,3,2,1]
b.sort()
print(b) # 输出 [1,2,3,4,5]

range 对象

range 表示不可变的数字序列，通常用于 for循环中设计循环次数。与list、tuple 相比，range的优势为不论表示的数字范国有多大，range对象占用的内存空间非常小且周定，因为它只需要保存3个值，即start、stop 和step，然后根据这3个值计算每个元素的值。

range 对象只能通过range 构造器创建，语法格式如下：

range(start, stop[,step])

range()的参数必须为整数，具体说明如下：

(1) start：表示数字开始值，默认值为 0，生成的数字序列包含该值。

(2) stop：表示数字结束值，生成的数字序列不包含该值。

(3) step：表示步长，默认为1，但是不能为0，否则会抛出 ValueError 异常。

• 如果step 为正值，确定 range 对象内元素的公式为：r[i]=start+step*I，其中条件为：i>=0，且r[I]<stop。
• 如果step 为负值，确定range 对象内元素的公式为：r[I]=start+step*i， 其中条件为：I>=0，且r[I]>stop。

如果r[0]不符合值的限制条件，则该range 对象为空。range 对象支持负素引，但是将其解读为从正数所确定的序列的末尾开始索引。