当前位置:   article > 正文

5.Python 常见的序列_python中属于序列的有

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) # 获取指定值的索引,返回非负整数
  • 1
  • 2
  • 3
  • 4

切片

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

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
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

(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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

压缩和解压

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

zip([iterable,...])
  • 1

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

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

zip(*zip)
  • 1
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]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

枚举函数

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

enumerate(sequence,[start=0])
  • 1

参数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']
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

排序

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]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

range 对象

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

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

range(start, stop[,step])
  • 1

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 对象支持负素引,但是将其解读为从正数所确定的序列的末尾开始索引。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/Li_阴宅/article/detail/809067
推荐阅读
相关标签
  

闽ICP备14008679号