python序列结构（列表、字典、元组、集合）大总结(万字长文，建议收藏)

目录

Python序列概述

列表及其相关操作

字典及其相关操作

元组及其相关操作

集合及其相关操作

序列解包

---

---

Python序列概述

Python序列属于容器类结构，用于包含大量数据，类似于其他语言中的数组，但是功能远远不止于数组；常用的序列有列表、元组、字典、字符串、集合等；从是否有序这个角度可以分为有序序列和无序序列，从是否可变来看则可以分为可变序列和不可变序列。

有序序列：列表、元组、字符串

无序序列:字典、集合

可变序列：列表、字典、集合

不可变序列：字符串、元组

列表及其相关操作

概述：变量可以存储一个元素，而列表可以看作是以一个大容器，可以存储多个元素的有序连续内存空间，程序可以更加方便的对这些数据进行操作；类似于一个有索引的集合，可以存放任何类型的数据。(列表里面也可以放列表、元组、字典、集合、函数以及其他任意对象)

列表特点：

# @Author:韩慧腾
# @Time ：2022/6/18 21:49
# @File :list_Demo.py
# 努力已经来不及了，你得拼命
a=10 #一个变量存储的是一个对象的引用
l=['python','java',12,23.43]
l1=[]#里面没有元素，表示的是一个空列表
print(id(l))#输出列表对象的地址
print(type(l))#类型就是list
print(l)#输出列表

列表的基本操作

• 列表的创建

1.需要使用中括号[ ]，元素之间使用英文的逗号进行分隔。eg:l=['python','java',12]。

2.使用内置函数list（）把元组、range对象、字符串、字典、集合或其他可迭代对象转换为列表

# @Author:韩慧腾
# @Time ：2022/9/22 17:52
# @File :ist_Demo.py
# 努力已经来不及了，你得拼命
l=[1,2,3]#直接创建列表
print(l)#[1, 2, 3]
l1=list((1,2,3,4,4.5))#将元组转换为列表
print(l1)#[1, 2, 3, 4, 4.5]
l2=list(range(1,10,1))#将range对象转换为列表
print(l2)#[1, 2, 3, 4, 5, 6, 7, 8, 9]
l3=list('hello')#将字符串转换为列表
print(l3)#['h', 'e', 'l', 'l', 'o']
l4=list({1,2,5,4})#将集合转换为列表，集合中的元素是无序的
print(l4)#[1, 2, 4, 5]
l5=list({'a':1,'b':3,'c':5})#将字典的键转化为列表
print(l5)#['a', 'b', 'c']
l6=list({'a':1,'b':3,'c':5}.items())#将字典的元素转化为列表
print(l6)#[('a', 1), ('b', 3), ('c', 5)]

• 列表中查询操作

•  列表的切片操作

列表的切片操作不仅可以使用切片来截取列表中的任何部分并返回得到一个新的列表，也可以通过切片来修改和删除、添加列表中的部分元素。

注意：

1. 当步长为负数时，会将截取的片段逆序输出。
2. 切片结束位置大于列表长度时，从列表尾部截断；start为0时可以省略，end为列表长度时可以省略，step为1时可以省略，省略step时还可以同时省略最后一个冒号，step为负数时反向切片。

# @Author:韩慧腾
# @Time ：2022/6/19 7:52
# @File :list_Demo0.py
# 努力已经来不及了，你得拼命
l=['python','list',12,'list']
print(l)
l1=list(['python','java',12])
print(l1)
#获取列表元素的索引值,如果查找的元素不存在，则会报错
print(l.index('python'))
#在指定的区间中查找元素
print(l.index('list',2,4))
#正向索引
print(l[2])#12
#用于截取某一片段
print(l[1:4])
#可以用来逆序输出列表
print(l[3:1:-1])

• 判断某元素是否在列表中存在

•  列表元素的遍历

# @Author:韩慧腾
# @Time ：2022/6/27 12:51
# @File :list_Demo2.py
# 努力已经来不及了，你得拼命
#判断列表中是否有某元素
print( 'p' in 'python')#True
print('m' in 'python')#False
print( 'p' not in 'python')#False
print('m' not in 'python')#True
#遍历列表
a=[12,23,'python','abb']
for i in a:
    print(i)

• 列表元素的增删操作

# @Author:韩慧腾
# @Time ：2022/6/27 20:50
# @File :list_Demo3.py
# 努力已经来不及了，你得拼命
#在一个列表中添加元素后新列表地址值不会改变，即不会创建新列表
a=[12,2,'python','java']
print(id(a)) #2327495879680
print(a) #[12, 2, 'python', 'java']
a.append('c++')
print(id(a))#2327495879680
print(a)#[12, 2, 'python', 'java', 'c++']
#append方法只能添加一个元素，需要添加多个元素可以用extend
b=['c#','C']
a.extend(b)
print(a) #print(a) #[12, 2, 'python', 'java']
c=['PHP','html','CSS']
#切片操作
a[1:]=c
print(id(a)) #1676459748288，说明此操作不会创建新列表
print(a)#[12, 'PHP', 'html', 'CSS']

 

# @Author:韩慧腾
# @Time ：2022/6/27 21:22
# @File :list_Demo4.py
# 努力已经来不及了，你得拼命
a=[12,23,'python','PHP','Java']
#a.remove(1) #注意删除元素时候remove参数是具体的值，不是索引值，此处就会报错
a.remove('python')
print(a) #[12, 23, 'PHP', 'Java']
a.pop(1) #此处的参数就是索引值，会删除索引值为1的元素
print(a)
a.pop() #无参数时候会默认删除列表最后一个元素
print(a) #[12, 'PHP']
#切片操作(至少删除一个元素)，会产生一个新的列表对象
b=[12,1,2,3,'python','java']
c=b[2:4] #产生一个新的列表对象
print(b) #[12, 1, 2, 3, 'python', 'java']
print(c) #[2, 3]
#用切片操作删除元素，思路就是用一个空列表代替切去的元素
lst=[12,22,33,44,'python','java']
lst[2:5]=[]
print(lst) #[12, 22, 'java']
#清空列表中所有元素
lst.clear()
print(lst) #[]
#del语句删除列表对象
del lst
print(lst)#此时就会报错，因为列表对象已被删除

• 列表元素的修改操作

为指定索引的元素赋予一个新值，为指定的切片赋予一个新值。

​
# @Author:韩慧腾
# @Time ：2022/6/28 11:31
# @File :list_Demo5.py
# 努力已经来不及了，你得拼命
lst=[12,22,33,44,'python','java']
lst[3]=333 #根据索引修改值
print(lst)
#用切片操作修改元素
lst[1:3]=['PHP','JAVA','C++']
print(lst) #[12, 'PHP', 'JAVA', 'C++', 333, 'python', 'java']

​

• 列表元素的排序操作 

1.调用sort()方法，列中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True（作为参数）,进行降序排序。不会产生新的列表对象

2.调用内置函数sorted()函数，可指定reverse=True，进行降序排序，原列表不会发生改变；排序后的列表会产生一个新列表对象。

3.reverse()方法用于将列表所有元素原地翻转，就是第一个元素和倒数第一个元素交换位置

# @Author:韩慧腾
# @Time ：2022/6/28 21:38
# @File :list_Demo6.py
# 努力已经来不及了，你得拼命
l=[12,2,33,444,545,1]
#调用sort方法排序,该方法并不会创建新的列表对象
l.sort() #升序
print(l)
l.sort(reverse=True) #降序
print(l)
#调用内置函数sorted，会产生一个新的列表对象
new_l=sorted(l)#升序
print(new_l)
new_ll=sorted(l,reverse=True)#降序
print(new_ll)

• 列表生成式(就是生成列表的公式)

其中i平方就是列表生成元素。 

# @Author:韩慧腾
# @Time ：2022/6/30 10:32
# @File :list_Demo7.py
# 努力已经来不及了，你得拼命
#列表生成式
l=[i*2 for i in range(1,6)]
print(l) #[2, 4, 6, 8, 10]
l1=[i for i in range(1,11)]
print(l1) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

注意：生成式后面可以继续跟If语句，if语句过滤不符合条件的元素。

• count()

该方法用于返回列表中指定元素出现的次数。

l=[1,2,2,2,3,4,56]
print(l.count(2))#3

•  列表对象支持的运算符

加法运算符可以连接两个列表，得到一个新列表；乘法运算符可以用于列表和整数相乘，表示序列重复，返回新列表;关系运算符可以用来比较两个列表的大小（比较原理：逐个比较对应位置的元素，直到某个元素能够比较出大小为止）

l=[1,2,3,4]
l1=[12,23,34,45]
print(l+l1)#[1, 2, 3, 4, 12, 23, 34, 45]
print(l*3)#[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
print(l>l1)#False

• 内置函数对列表的操作 

import random
l=[12,2,2,33,45,1]
l1=[0,1,2,3]
print(l)#[12, 2, 2, 33, 45, 1]
random.shuffle(l)#用于打乱列表中元素顺序
print(l)#[33, 12, 1, 45, 2, 2]
print(all(l))#True 测试是否所有的元素都等价于True
print(all(l1))#False
print(any(l)) #True 测试是否存在等价于True的元素
print(max(l),min(l),sum(l),len(l))#45 1 95 6 最大值 最小值 列表元素之和 列表元素个数

字典及其相关操作

概述：字典是Python内置的数据结构之一，包含若干“键：值”元素的无序可变序列，表示的是一种映射或对应关系，也称关联数组。

字典中元素的“键”可以是python中任意不可变数据，eg：整数、实数、复数、字符串、元组等类型可散列数据，但不能使用列表、集合、字典或其他可变类型作为字典的“键”。另外：字典的“键”不允许重复，而“值”是可以重复的。

特点：

1. 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
2. 字典中的元素是无序的
3. 字典中的key必须是不可变对象
4. 字典也可以根据需要动态地伸缩
5. 字典会浪费较大的内存，是一种使用空间换时间的数据结构

字典的创建方式：

# @Author:韩慧腾
# @Time ：2022/7/1 9:01
# @File :dict_Demo0.py
# 努力已经来不及了，你得拼命
#创建字典
a={'北京':32.1,'上海':29.9,'三亚':33.4}
print(a) #{'北京': 32.1, '上海': 29.9, '三亚': 33.4}
print(type(a)) #
#使用内置函数dict创建字典
aa=dict(北京=32.1,上海=29.9,三亚=33.4)
print(aa) #{'北京': 32.1, '上海': 29.9, '三亚': 33.4}
print(type(aa)) #
#创建空字典
d={}
d1=dict()
print(d,d1)#{} {} 两个空列表
#根据已有数据创建字典
keys=['a','b','c']
values=[1,2,3]
d2=dict(zip(keys,values))
print(d2) #{'a': 1, 'b': 2, 'c': 3}
d3=dict.fromkeys(keys)#以给定内容为键，创建“值”为空的字典
print(d3) #{'a': None, 'b': None, 'c': None}
d4=dict(name='李华',age=90) #以关键参数的形式创建字典
print(d4) #{'name': '李华', 'age': 90}
del d #删除字典d

字典中元素的获取

# @Author:韩慧腾
# @Time ：2022/7/1 9:24
# @File :dict_Dmo1.py
# 努力已经来不及了，你得拼命
d=dict(北京=32.1,上海=29.9,三亚=33.4)
print(d['北京']) #32.1
print(d.get('北京')) #32.1
print(d.get('北京',30)) #32.1 列表中有北京这个键，所以该默认值并没有什么用
print(d.get('天津',30)) #30 列表中没有天津这个键，所以会输出默认值30
'''获取元素的时候，第二个参数是当字典中没有该键时候，会输出该默认值'''

 字典的常用操作

• Key的判断

# @Author:韩慧腾
# @Time ：2022/7/1 9:38
# @File :DICT_Demo2.py
# 努力已经来不及了，你得拼命
d=dict(北京=32.1,上海=29.9,三亚=33.4)
print('北京' in d) #True
print('北京' not in d) #False
print('南京' in d) #False
print('南京' not in d) #True

• 字典元素的删除

可以使用字典对象的pop()和popitem()方法弹出并删除指定元素

•  字典元素的新增

# @Author:韩慧腾
# @Time ：2022/7/1 18:47
# @File :dict_Demo3.py
# 努力已经来不及了，你得拼命
d=dict(北京=32.1,上海=29.9,三亚=33.4)
#删除字典元素
del d['北京']
print(d) #{'上海': 29.9, '三亚': 33.4}
#字典元素的新增
d['南京']=30.1 
print(d) #{'上海': 29.9, '三亚': 33.4, '南京': 30.1}
#清空列表
d.clear()
print(d) #{}

• 获取字典视图的三个方法 

# @Author:韩慧腾
# @Time ：2022/7/1 18:55
# @File :dict_Demo4.py
# 努力已经来不及了，你得拼命
d=dict(北京=32.1,上海=29.9,三亚=33.4)
d1=d.keys()
print(d1) #dict_keys(['北京', '上海', '三亚'])
d2=d.values()
print(d2) #dict_values([32.1, 29.9, 33.4])
d3=d.items()
print(d3) #dict_items([('北京', 32.1), ('上海', 29.9), ('三亚', 33.4)])
#以列表的形式输出
print(list(d1)) #['北京', '上海', '三亚']
print(list(d2)) #[32.1, 29.9, 33.4]
print(list(d3)) #[('北京', 32.1), ('上海', 29.9), ('三亚', 33.4)] 该集合是由元组组成的

• 字典元素的遍历

  注意：item是键（key），如果需要遍历字典的元素必须使用字典对象的items()方法明确说明。

# @Author:韩慧腾
# @Time ：2022/7/1 20:52
# @File :dict_Demo5.py
# 努力已经来不及了，你得拼命
d=dict(北京=32.1,上海=29.9,三亚=33.4)
#遍历字典
for i in d:
    print(i,d[i],d.get(i)) #注意i是键(key)

• 字典生成式

内置函数zip()，用于将可迭代的对象(eg:列表、字符串)作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表。 

# @Author:韩慧腾
# @Time ：2022/7/1 21:29
# @File :dict_Demo6.py
# 努力已经来不及了，你得拼命
city=['北京','上海','三亚']
tem=[32.1,32,35]
d={c.upper():t for c,t in zip(city,tem)} #upper可以将其变为大写字母
print(d) #{'北京': 32.1, '上海': 32, '三亚': 35}

• 添加字典的方法

字典对象的update()方法可以将另一个字典的"键：值"一次性全部添加到当前字典对象，如果两个字典中存在相同的“键”，则以另一个字典中的“值”为准对当前字典进行更新。

元组及其相关操作

概述：Python内置的数据结构之一，可以看作是一个简化版列表，支持与列表类似的操作，但功能不如列表强大元组的所有元素放在一对圆括号中，元素之间使用逗号隔开；如果元组中只有一个元素则必须在最后增加一个逗号。

元组是不可变序列，不可以直接修改元素的值，无法为元组添加或删除元素，因此，没有添加append()、extend()、insert()、remove()、pop()方法，也不能进行del操作；元组的访问速度比列表要快。

作为不可变序列，与整数、字符串一样，元组可用作字典的键，也可以作为集合的元素，而列表则永远都不能当作字典键使用，也不能作为集合中的元素，因为列表不是不可变的。

元组设计成不可变序列的好处：

在多任务环境下，同时操作对象时不需要加锁（也就是说多个任务同时操作元组时候互不影响，互不干扰）。

 注意：

1.和列表的括号是不一样的（列表是方括号，而元组是圆括号）

2.元组中存储的是对象的引用，如果元组中对象本身是不可变对象，则不能再引用其他对象；如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变。

# @Author:韩慧腾
# @Time ：2022/7/2 8:34
# @File :tuple_Demo2.py
# 努力已经来不及了，你得拼命
t=(12,23,[12,333],4)
#t[1]=100 此处会报错，不可修改
t[2].append(122) #由于列表是可变序列，所以可以向列表中添加元素，而列表的内存地址是不变的
print(t) #(12, 23, [12, 333, 122], 4)

元组的创建方式

# @Author:韩慧腾
# @Time ：2022/7/2 7:55
# @File :tuple_Demo1.py
# 努力已经来不及了，你得拼命
#元组的创建
t=('python','java','C++') #这种创建方式的小括号是可以省略的
print(t,type(t)) #('python', 'java', 'C++') 
t1=tuple(('北京','上海','三亚'))
print(t1,type(t1)) #('北京', '上海', '三亚') 
t3=('python',) #注意元组只有一个元素的时候，必须加上逗号
print(type(t3)) #
t4=('python')
print(type(t4)) #

元组的遍历

由于元组是可迭代对象，所以可以使用for……in进行遍历

# @Author:韩慧腾
# @Time ：2022/7/2 8:53
# @File :tuple_Demo3.py
# 努力已经来不及了，你得拼命
#元组的遍历
t=(12,23,3,'python')
for i in t:
    print(i)

# @Author:韩慧腾
# @Time ：2022/7/1 22:03
# @File :Demo_0.py
# 努力已经来不及了，你得拼命
#关于可变序列和不可变序列
#不可变序列，对其操作是会生成一个新的对象，而不是在原来对象的地址修改
a='python'
print(id(a)) #2052419985584
a+=' yyds'
print(id(a)) #2052419983856
#可变序列 对其修改是在原对象地址修改，不会生成一个新的对象
l=[12,2,34,'python']
print(id(l)) #2643504240384
l.append(' yyds')
print(id(l)) #2643504240384

• 生成器表达式

生成器表达式的语法与列表推导式非常相似，在形式上生成器使用圆括号作为定界符，而列表推导式使用的是方括号，结果是一个生成器对象；比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据的处理。

生成器对象可以根据需要将其转换为列表或者元组，可以使用生成器对象的__next__()方法或内置函数next()进行遍历，或者使用for循环来遍历其中的元素；无论哪种方法访问其元素，只能从前往后正向访问每个元素，没有方法可以访问已访问过的元素，也不支持使用下标访问其中的元素。如果一个生成器对象的所有元素访问结束以后，需要重新访问其中的元素，必须重新创建该生成器对象。zip、map、filter、enumerate等其他迭代器对象也具有同样的特点。

a=(i for i in range(4))#创建生成器对象
print(a.__next__()) #0 访问其元素

集合及其相关操作

概述：集合是Python无序可变序列，使用一对大括号作为定界符，同一个集合内的每个元素都是唯一的，不允许重复。集合中只能包含数字、字符串、元组等不可变类型的数据，而不能包含列表、字典、集合等可变类型的数据。

集合的两种创建方式

# @Author:韩慧腾
# @Time ：2022/7/2 10:51
# @File :set_Demo1.py
# 努力已经来不及了，你得拼命
#集合的创建方式
s={2,3,4,456,2}
print(s)#{456, 2, 3, 4}
s1=set(range(4))
print(s1)#{0, 1, 2, 3}
#将列表中的元素转为集合，并去掉重复元素
s2=set([12,23,3,3,44])
print(s2) #{3, 12, 44, 23}
#将元组中的元素转为集合，并去掉重复元素
s3=set((1,2,33,333,2))
print(s3)#{1, 2, 333, 33}
#将字符串中的元素转为集合，并去掉重复元素
s4=set(('popularity'))
print(s4) #{'r', 'y', 't', 'i', 'l', 'o', 'p', 'u', 'a'}
#创建空集合
s5=set()
print(type(s5)) #
#注意这种方式创建出来的不是空集合，而是字典
s6={}
print(type(s6)) #
del s6#del命令可以删除整个集合

集合的常用操作

• 集合元素的判断操作

in 或not in用于检验集合中是否存在某元素

# @Author:韩慧腾
# @Time ：2022/7/2 16:17
# @File :set_Demo2.py
# 努力已经来不及了，你得拼命
s={12,23,'python','java'}
print(12 in s) #True
print(12 not in s) #False
print(1 in s) #False
print(1 not in s) #True

• 集合元素的新增操作

add方法增加一个元素，如果该元素已存在则忽略该操作，不会抛出异常；update方法用于合并另外一个集合中的元素到当前集合中，并自动去除重复元素。

# @Author:韩慧腾
# @Time ：2022/7/2 16:23
# @File :set_Demo3.py
# 努力已经来不及了，你得拼命
s={12,23,'python','java'}
s.add('C++') #向集合添加一个元素的操作
print(s)
#s.update(12,23,33) #向集合中添加至少一个元素
'''注意在加多个元素的时候不能把多个元素直接放在参数，上面就会报错'''
s.update({1,2,3})#此处参数可以是列表、元组、集合
print(s) #{1, 2, 3, 'C++', 12, 'java', 23, 'python'}

•  集合元素的删除操作

# @Author:韩慧腾
# @Time ：2022/7/2 16:38
# @File :set_Demo4.py
# 努力已经来不及了，你得拼命
s={1, 2, 3, 'C++', 12, 'java', 23, 'python'}
s.remove(1)
print(s)#{2, 3, 'python', 12, 'C++', 23, 'java'}
s.discard(2)
print(s) #{3, 'python', 12, 'C++', 23, 'java'}
#remove方法和discard方法区别在于删除不存在元素是否抛出异常
#s.remove("cc") #会抛出异常
s.discard("cc") #不会抛出异常
s.pop()#pop方法没有参数，随机任意删除一个元素
print(s)#{3, 12, 23, 'java', 'C++'}
s.clear()#清空集合，即删除所有元素
print(s) #set()

• 集合运算

内置函数len()、max()、min()、sum()、sorted()、map()、filter()、enumerate()等也适用于集合。集合还支持数学意义上的交集、并集、差集等运算。

# @Author:韩慧腾
# @Time ：2022/9/23 10:58
# @File :set_Demo8.py
# 努力已经来不及了，你得拼命
s={12,2,3,4,5}
s1={1,2,3,4,5,6,7}
print(s | s1) #{1, 2, 3, 4, 5, 6, 7, 12} 求两个集合的并集
print(s & s1) #{2, 3, 4, 5} 求两个集合的交集
print(s-s1) #{12} 求两个集合的差集
print(s^s1) #{1, 6, 7, 12} 两个集合的对称差集(即把两个集合重复的元素去掉)

关系运算符>、>=、<、<=作用于集合时表示集合之间的包含关系，而不是集合中元素的大小关系

集合之间关系的判断：

# @Author:韩慧腾
# @Time ：2022/7/2 16:54
# @File :set_Demo5.py
# 努力已经来不及了，你得拼命
#判断两个集合是否相等，注意集合是无序的，只会根据元素值判断
s={1,2,22,34}
s1={22,34,1,2}
print(s==s1) #True
print(s1!=s1) #False
#判断一个集合是否为另一个集合的子集
s3={1,2,3,4,5}
s4={1,2,3,4,5,6,7}
s5={1,3,123,3}
print(s3.issubset(s4)) #True s3是s4的子集
print(s5.issubset(s4)) #False
#一个集合是否为另一个集合的超集
print(s4.issuperset(s3)) #True
print(s5.issuperset(s3)) #False
#判断两个集合是否有交集
print(s3.isdisjoint(s4)) #False 意思为有交集
s6={100,200}
print(s3.isdisjoint(s6)) #True 意思为没有交集

集合生成式：

将{ }换成[ ] 就是列表生成式

# @Author:韩慧腾
# @Time ：2022/7/2 21:48
# @File :set_Demo7.py
# 努力已经来不及了，你得拼命
#列表生成式
l=[i*i for i in range(6)]
print(l)
#集合生成式
s=[i*i for i in range(6)]
print(s)

序列解包

概述：序列解包是对多个变量同时进行赋值的简洁形式，也就是把一个序列或可迭代对象中的多个元素的值同时赋值给多个变量，要求等号左侧变量的数量和等号右侧值的数量必须一致。

序列解包可以用于列表、字典、enumerate对象、filter对象、zip对象等，但是对字典使用时，默认是对字典“键”进行操作，如果需要对字典"键：值"对进行操作，需要使用字典的items()方法说明，如果需要对字典的“值”进行操作，则需要使用字典的values()方法明确指定。

a,b,c=12,23,3#多个变量同时赋值
a1,b1,c1=('java','php','html')#将元组的值赋给三个变量
print(a,a1)#12 java
a,b=b,a#交换两个变量的值

大总结：