Python数据结构——序列（超详细版）
在计算机程序中会有很多数据，使用数据结构可以管理这些数据，Python中的数据结构主要有序列、集合和字典。常见的数据结构有：数组（array）、集合（set）、列表（list）、队列（queue）、链表（linkedlist）、树（tree）、堆（heap）、栈（stack）和字典（dictionary）。
注意：
Python中并没有数组结构，因为数组要求元素类型是一致的。而Python作为动态类型语言，不强制声明变量的数据类型，也不强制检查元素的数据类型，因此不能保证元素的数据类型一致。
序列
序列是一种可迭代的（指它的成员能返回一次的对象）、元素有序、可以重复出现的数据结构。序列可以通过索引访问元素，其包括的结构有列表、字符串（str）、元组（tuple）、范围（range）和字节序列（bytes） ，序列可进行的操作有索引、切片、加和乘。
索引操作
序列中第一个元素的索引是0，其他元素的索引是第一个元素的偏移量，有正偏移量（正值索引）和负偏移量（负值索引）。正值索引的最后一个元素索引是“序列长度-1”，负值索引的最后一个元素索引是“-1”。如 World 字符串的正值和负值索引。
| 索引 | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 字符串 | W | o | r | l | d |
World字符串的正值索引
| 索引 | -5 | -4 | -3 | -2 | -1 |
|---|---|---|---|---|---|
| 字符串 | W | o | r | l | d |
World字符串的负值索引
序列中的元素是通过索引下标访问的
输入下面代码：
a = 'Python'
print(a[0])
print(a[1])
print(a[2])
print(a[3])
print(a[4])
print(a[5])
print(a[-1])
print(a[-6])代码运行结果：
P
y
t
h
o
n
n
P序列常用函数
| 函数名 | 描述 |
|---|---|
| len() | 返回序列的长度 |
| max() | 返回ASCII码最大字符 |
| min() | 返回ASCII码最小字符 |
| ord() | 返回字符的ASCII码 |
序列对象的方法
| 函数名 | 描述 |
|---|---|
| s.index(a) | 其中s为序列，o为参数；该函数的作用为返回a在s中第一次出现的位置，若不存在则返回ValueError错误 |
| s.count(a) | 其中s为序列，o为参数；该函数的作用为返回a在s出现的总次数 |
示例代码如下
s = 'HelloWorld'
print(s.index('H'))
print(s.index('W'))
print(s.count('l'))
print(s.count('o'))代码运行结果
0
5
3
2
Process finished with exit code 0序列的加和乘
+ 可以将两个序列连接起来，* 可以将序列重复多次。
序列切片
序列的切片就是从序列中切分出小的子序列。切片使用切片运算符 [start:end:step] ，其中start表示开始索引，end表示结束索引，step表示步长；步长可为正整数或者负整数。
（下次元素索引 = 当次元素索引 + 步长）
注意：切下的切片包括start位置元素，但不包括end位置元素。
输入下面代码：
a = 'Python'
print(a[0:5:2])
print(a[1:4]) #省略了步长
print(a[:3]) #省略了开始索引，默认开始索引为0
print(a[1:]) #省略了结束索引，默认结束索引是序列长度
print(a[:]) #省略了开始和结束索引
print(a[1:-1]) #使用了负值索引
print(a[::-1]) #结果为原始字符串的倒置代码运行结果：
Pto
yth
Pyt
ython
Python
ytho
nohtyP元组
元组是一种不可变序列，一旦创建就不可修改。
创建元组
方法一：使用 “,” 分隔元素
方法二：使用tuple（）函数
输入下面代码：
a = 11,22,33,44,55,66
print(a)
c = (11,22,33,44,55,66)
print(c)
b = tuple([66,55,44,'hello','python'])
print(b)
d = () #创建一个空元组
e = (21,) #创建只有一个元素的元组，其中逗号不能省略，若省略，则是int类型代码运行结果：
(11, 22, 33, 44, 55, 66)
(11, 22, 33, 44, 55, 66)
(66, 55, 44, 'hello', 'python')若输入的参数是一个字符串时，会将字符串中的每个字符作为元组中的一个元素；若参数为列表时，则会将列表中的每个元素作为元组的一个元素。
示例代码如下
tuple1 = tuple('CSDN@邂逅自己')
print(tuple1)
tuple2 = tuple([1,2,3,4])
print(tuple2)代码运行结果
('C', 'S', 'D', 'N', '@', '邂', '逅', '自', '己')
(1, 2, 3, 4)
Process finished with exit code 0注意：创建元组时，若只有一个参数，需要在该参数后面加逗号，否则创建的数据类型为int。
删除元组
语法格式如下
del 元组名访问元组
元组作为序列可以通过下标索引访问其元素，也可以对其进行切片，此外还可以进行拆包操作，就是将元组的元素取出来赋值给不同的变量。
输入下面代码：
a = (11,22,33,44,55,66)
str1,str2,str3,str4,str5,str6=a
print(str1)
print(str2)
print(str3)
print(str4)
print(str5)
print(str6)
str1,str2,*n = a #接收变量个数可以小于等于元组个数，*n表示将剩下元素作为一个列表赋值给变量n
print(n)
print(type(n))代码运行结果：
11
22
33
44
55
66
[33, 44, 55, 66]
遍历元组
一般使用for循环，enumerate（）函数可以获得元组对象，该元组对象有两个元素，第一个元素是索引，第二个元素是数值
输入下面代码：
a = (11,22,33,44,55,66)
for i,item in enumerate(a):
print("{0} - {1}".format(i,item))代码执行结果：
0 - 11
1 - 22
2 - 33
3 - 44
4 - 55
5 - 66注意：元组也有生成式，只是生成式的结果为生成器。此时要想看到元素的内容，可以将其转为元组即可查看或者使用__next__方法也可以查看，只是__next__方法要注意只能遍历一次（因为每使用一次__next__方法就会把生成器对象里的元素取出来一个；若先使用__next__方法把元素全都取出来，此时在使用tuple方法则会得到空元组）。
示例代码如下
tuple1 = (i for i in range(1,11))
print(tuple1)
# 方法一
# 遍历生成器对象，查看元素
for i in range(10):
print(tuple1.__next__())
# 方法二
tuple1 = (i for i in range(1,11))
print(tuple1)
tuple2 = tuple(tuple1)
print(tuple2)代码运行结果
at 0x0000026F586F4880>
1
2
3
4
5
6
7
8
9
10
at 0x0000026F586F4AC0>
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
Process finished with exit code 0 列表
列表是一种可变序列。列表可变，是因为对列表中的元素可以继续增、删、改操作，进行该操作并不会改变列表的地址。由于列表也是序列中的一种，凡是序列的方法，列表都可以使用。
列表创建
方法一：使用中括号 " [] "将元素括起来，元素之间用逗号分隔。
方法二：使用 list() 函数
输入下面代码：
a = [11,22,33,44,55,66] #中括号不能省略，如果省略就变成了元组
print(a)
b = list([66,55,44,'hello','python'])
print(b)
c = [] #创建一个空列表
print(type(c))
d = [11,] #创建一个元素的列表，无论元组还是列表，最后一个元素的逗号可以省略，也可以不省略
print(d)
e = list('CSDN邂逅自己') # 若参数为一个字符串时，此时列表会自动将其中每个字母进行分割
print(e)
f = list(range(1,10,2)) # 也可以结合range函数创建列表
print(f)代码执行结果：
[11, 22, 33, 44, 55, 66]
[66, 55, 44, 'hello', 'python']
[11]
['C', 'S', 'D', 'N', '邂', '逅', '自', '己']
[1, 3, 5, 7, 9]
Process finished with exit code 0 列表删除
语法格式如下
del 列表名列表的遍历
示例代码如下
s = list('CSDN@邂逅自己') # 创建一个列表
# 方法一：使用for循环遍历列表元素
for item in s:
print(item,end='\t')
print(end='\n')
# 方法二：使用for循环和range函数遍历列表
for i in range(0,len(s)):
print(i,'-->',s[i],end='\t')
print(end='\n')
# 方法三：使用enumerate()函数
for index,item in enumerate(s):
print(index,item,end='\t')
print(end='\n')
# 方法三之二：可以手动修改enumerate()函数的起始值，即在参数增加start=n，其中start可以省略
for index,item in enumerate(s,start=3): # 假设从3开始
print(index,item,end='\t')代码运行结果
C S D N @ 邂 逅 自 己
0 --> C 1 --> S 2 --> D 3 --> N 4 --> @ 5 --> 邂 6 --> 逅 7 --> 自 8 --> 己
0 C 1 S 2 D 3 N 4 @ 5 邂 6 逅 7 自 8 己
3 C 4 S 5 D 6 N 7 @ 8 邂 9 逅 10 自 11 己
Process finished with exit code 0追加元素
列表中追加单个元素可以使用append（）方法，如果想追加另一列表，可以使用 + 运算符或者extend（）方法
输入下面代码：
a = [11,22,33,44,55,66]
b = list([66,55,44,'hello','python'])
a.append(1) #追加单个元素
print(a)
b.extend(a) #追加列表
print(b)
c = [2,3]
b +=c #追加列表
print(b)代码执行结果：
[11, 22, 33, 44, 55, 66, 1]
[66, 55, 44, 'hello', 'python', 11, 22, 33, 44, 55, 66, 1]
[66, 55, 44, 'hello', 'python', 11, 22, 33, 44, 55, 66, 1, 2, 3]插入元素
使用insert(参数1，参数2)方法，其中输入两个参数，参数1为插入元素的索引，参数2为插入的元素。
输入下面代码：
a = [11,22,33,44,55,66]
a.insert(2,'我是插入在原来的索引位置2的新元素')
print(a)代码执行结果：
[11, 22, '我是插入在原来的索引位置2的新元素', 33, 44, 55, 66]替换元素
通过列表下标将索引元素放在 = 的左边
a = [11,22,33,44,55,66]
a.insert(2,'我是插入在原来的索引位置2的新元素')
print(a)
print("执行替换元素操作")
a[2] = 30
print(a)代码执行结果：
[11, 22, '我是插入在原来的索引位置2的新元素', 33, 44, 55, 66]
执行替换元素操作
[11, 22, 30, 33, 44, 55, 66]删除元素
方法一：使用remove（）方法，其中参数为要删除的元素，从左到右查找列表中的元素，如果匹配则删除，若有多个匹配，则删除第一个；若没有找到则会抛出错误。
方法二：使用pop（）方法，其中参数为要删除元素的索引，该方法在删除元素后会返回成功删除的元素。
输入下面代码：
a = [11,22,33,44,55,66]
a.insert(2,'我是插入在原来的索引位置2的新元素')
print(a)
a.remove('我是插入在原来的索引位置2的新元素')
print(a)
b = a.pop(0)
print(b)
print(a)代码执行结果：
[11, 22, '我是插入在原来的索引位置2的新元素', 33, 44, 55, 66]
[11, 22, 33, 44, 55, 66]
11
[22, 33, 44, 55, 66]列表的排序
方法一：使用列表对象的sort方法，其中sort（key=None,reverse=False）中参数一key表示排序的规则，参数二reverse表示排序的方式，默认为升序（排序会根据ASCII码来排序）。此时排序是在原列表的基础上进行的，不会产生新的列表对象。
方法二：内置函数sorted(iterable,key=None,reverse=False)方法，其中参数iterable表示的是排序的对象。此时会产生新的列表对象。
示例代码如下
list1 = [55,77,88,66,99,33,11]
list1.sort() # 此时为升序
print(list1)
print('-'*30)
list1.sort(reverse=True) # 此时为降序
print(list1)
list2 = ['banana','apple','Cat','Propose']
list2.sort()
print(list2) # 此时是按照ASCII码进行排序，默认大写在前，小写在后
print('-'*40)
list2.sort(reverse=True) # 此时是按照ASCII码进行排序，默认大写在后，小写在前
print(list2)
list2.sort(key=str.lower) # 此时为忽略大小写进行排序
print(list2)
print('以下为方法二')
new_list1 = sorted(list1)
print(new_list1)
new_list11 = sorted(list1,reverse=True) # 逆序排列
print(new_list11)
new_list2 = sorted(list2)
print(new_list2)代码运行结果
[11, 33, 55, 66, 77, 88, 99]
------------------------------
[99, 88, 77, 66, 55, 33, 11]
['Cat', 'Propose', 'apple', 'banana']
----------------------------------------
['banana', 'apple', 'Propose', 'Cat']
['apple', 'banana', 'Cat', 'Propose']
以下为方法二
[11, 33, 55, 66, 77, 88, 99]
[99, 88, 77, 66, 55, 33, 11]
['Cat', 'Propose', 'apple', 'banana']
Process finished with exit code 0其他列表常用方法
| 方法名 | 描述 |
|---|---|
| reverse（） | 倒置列表 |
| copy（） | 复制列表 |
| clear（） | 清除列表中所有元素 |
| index（x,[i],[j]） | 返回查找x第一次出现的索引，i是开始查找索引，j是结束查找索引 |
| count（x） | 返回x出现的次数，元组和字符串也可以用该方法 |
列表推导式
它可以将一种数据结构作为输入，经过过滤、计算等处理，最后输出另一种数据结构。根据结构的不同可以分为列表推导式、集合推导式和字典推导式；下面为列表推导式的例子
输入下面代码：
a_list = [x**3 for x in range(1,10) if x%2 == 0]
#x**2 为输出表达式，for x in range(1,10) 中 x 为元素变量，range（10） 为输入序列，if x%2 == 0 为条件表达式
print(a_list)代码输出结果：
[8, 64, 216, 512]其中输入的条件表达式也可以有多个条件，如：找出0~66中可以被5整数的偶数数列可以通过下面代码实现：
a_list = [x for x in range(66) if x%2 == 0 if x%5 == 0]
print(a_list)代码输出结果：
[0, 10, 20, 30, 40, 50, 60]此外，还可以使用随机数生成列表
示例代码如下
import random
list = [random.randint(1,100) for _ in range(10)]
print(list)代码运行结果
[46, 92, 34, 89, 98, 64, 80, 5, 69, 95]
Process finished with exit code 0二维列表
一个列表当中又嵌套了另一个列表，此时我们称该列表为二维列表。
二维列表的创建
示例代码如下
list1 =[
['学号','姓名','成绩'],
['11110000','小明',100],
['11110001','小红',90],
['11110002','小蓝',80]
]
print(list1)代码运行结果
[['学号', '姓名', '成绩'], ['11110000', '小明', 100], ['11110001', '小红', 90], ['11110002', '小蓝', 80]]
Process finished with exit code 0二维列表的遍历
外层控制行数，内层控制列数。
示例代码如下
list1 =[
['学号','姓名','成绩'],
['11110000','小明',100],
['11110001','小红',90],
['11110002','小蓝',80]
]
for row in list1:
for column in row:
print(column,end='\t')
print()代码运行结果
学号 姓名 成绩
11110000 小明 100
11110001 小红 90
11110002 小蓝 80
Process finished with exit code 0此外，我们还可以用列表生成式来生成指定行和列的二维列表
示例代码如下（以生成六行七列的二维列表为例）
list1 = [[j for j in range(7)]for i in range(6)]
# 遍历输出列表
for row in list1:
for column in row:
print(column,end='\t')
print()代码运行结果
0 1 2 3 4 5 6
0 1 2 3 4 5 6
0 1 2 3 4 5 6
0 1 2 3 4 5 6
0 1 2 3 4 5 6
0 1 2 3 4 5 6
Process finished with exit code 0元组和列表的区别
| 元组 | 列表 |
|---|---|
| 不可变序列 | 可变序列 |
| 无法实现添加、删除和修改元素等操作 | append()、extend()、insert()、remove()、pop()等方法实现添加和删除列表元素 |
| 支持切片操作访问元素，不支持修改操作 | 支持切片访问和修改列表中的元素 |
| 访问和处理速度快 | 访问和处理速度慢 |
| 可以作为字典的键 | 不能作为字典的键 |
字典是另一种数据结构，具体的可以看我之前发的文章，文章链接如下
Python数据结构——字典-CSDN博客@邂逅自己
https://blog.csdn.net/2302_76708905/article/details/139664120如果想要系统的学习Python知识，可以点开我的主页，点击专栏“Python零基础从入门到实战”进行学习。
最后，文章创作不易（本文前后经过多次修改，只为了给大家最好的学习教程），如果觉得文章对大家有帮助的话，还请点赞+关注；如果有能力的话，也可以打赏一下喔，谢谢大家！！！