Python组合数据类型(集合、序列、元组、列表、字典类型）

集合类型

集合定义

集合是多个元素的无序组合

• 集合类型与数学中的集合概念一致
• 集合用大括号{}表示，元素间用逗号分隔
• 集合元素之间无序，每个元素唯一，不存在相同元素
• 集合元素不可更改，不能是可变数据类型

---

举例：

A = {"python",123,("python",123)} #使用{}建立集合 ==> {123,'python',('python',123)}

B = set("pypy123") # 使用set()建立集合  ==> {'1','p','2','3','y'}  相同元素会被去掉

集合操作符

操作符及应用	描述
S | T	返回一个新集合，包括在集合S和T中的所有元素
S - T	返回一个新集合，包括在集合S但不在T中的元素
S & T	返回一个新集合，包括同时在集合S和T中的元素
S ^ T	返回一个新集合，包括集合S和T中的非相同元素
S <= T或 S < T	返回True/False，判断S和T的子集关系
S >=T或 S > T	返回True/False，判断S和T的包含关系
S |=T	更新集合S，包括在集合S和T中的所有元素
S -=T	更新集合S，包括在集合S但不在T中的元素
S &= T	更新集合S，包括同时在集合S和T中的元素
S ^= T	更新集合S，包括集合S和T中的非相同元素

---

举例：

A={"p","y",123}
B=set("pypy123")
print(A-B) #123 在A中出现，没有在B中出现的元素
print(B-A) # {'2', '1', '3'}  在B中出现，没有在A中出现的元素
print(A&B) # {'p', 'y'}
print(A^B) # {'2', 123, '1', '3'}
print(A|B) # {'2', '3', 'y', 123, 'p', '1'}

集合函数

函数	描述
S.add(x)	如果x不在集合S中，将x添加到S中
S.discard(x)	移除S中元素x,如果x不在集合S中，不报错
S.remove(x)	移除S中元素x,如果x不在集合S中，产生KeyError异常
S.clear()	移除S中所有元素
S.pop()	随机返回S的一个元素，更新S，若S为空产生KeyError异常
S.copy()	返回集合S的一个副本
len(S)	返回集合S的元素个数
x in S	判断S中元素x，x在集合S中，返回True,否则返回False
x not in S	判断S中元素x，x不在集合S中，返回True,否则返回False
set(x)	将其他类型变量x转变为集合类型

---

举例：

A={"p","y",123}
for item in A:
    print(item,end="") # 123py



A={"p","y",123}
try :
    while True:
        print(A.pop(),end="") # 123yp
except:
    pass
print(A) # set() 不断取A中的元素，最后A为空退出

集合类型应用场景

1. 包含关系比较

print("p" in {"p","y",123}) # True
print({"p","y"} >={"p","y",123}) # False

2. 数据去重

利用集合中所有元素不能重复的特点，对一组数据中的重复元素进行删除。

ls=['p','p','y','y',123]
s=set(ls) #利用集合无重复元素的特点
lt=list(s)#将集合转换为列表
print(lt) # [123, 'y', 'p']

序列类型

序列类型定义

序列是具有先后关系的一组元素

• 序列是一维元素向量，元素类型可以不同
• 类似数学元素序列：$s_0,s_1$,…,$s_{(n-1)}$
• 元素间由序号引导，通过下标访问序列的特定元素
• 序列是一个基类类型，可以衍生出字符串类型、元组类型、列表类型

序列操作符

操作符及应用	描述
x in s	如果x是序列s的元素，返回True,否则返回False
x not in s	如果x是序列s的元素，返回False,否则返回True
s+t	连接两个序列s和t
s*n 或n*s	将序列s复制n次
s[i]	索引，返回s中的第i个元素，i是序列的序号
s[i:j]或s[i:j:k]	切片，返回序列s中第i到j以k为步长的元素子序列

ls=["pyt5hon",123,".io"]
print(ls[::-1]) #['.io', 123, 'pyt5hon']

序列函数

函数和方法	描述
len(s)	返回序列s的长度
min(s)	返回序列s的最小元素，s中元素需要可比较
max(s)	返回序列s的最大元素，s中元素需要可比较
s.index(x)或s.index(x,i,j)	返回序列s从i开始到j位置中第一次出现元素x的位置
s.count(x)	返回序列s中出现x的总次数

序列类型应用场景

1. 数据表示

• 元组用于元素不改变的应用场景，更多用于固定搭配场景
• 列表更加灵活，它是最常用的序列类型
• 最主要作用：表示一组有序数据，进而操作它们

2. 元素遍历

for item in ls:
   <语句块>
 for item in tp:
    <语句块> 

3. 数据保护

如果不希望被程序所改变，转换成元组类型

元组类型

元组是序列类型的一种扩展，它就是将元素进行有序的排列，用"()"形式来组织

• 元组是一种序列类型，一旦创建就不能被更改
• 元组类型继承了序列类型的全部通用操作
• 使用小括号()或tuple()创建，元素间用逗号,分割
• 可以使用或不使用小括号

---

举例：

creature="cat","dog","tiger","human"
print(creature) # ('cat', 'dog', 'tiger', 'human')
color=(0x001100,"blue",creature)
print(color) # (4352, 'blue', ('cat', 'dog', 'tiger', 'human'))其中的的第三个元素也是一个元组类型

列表类型

列表定义

列表是一种序列类型，创建后可以随意被修改

• 列表是一种序列类型，创建后可以随意被修改
• 使用方括号[]或list()创建，元素间用逗号,分隔
• 列表中各元素类型可以不同，无长度限制

---

举例：

ls=["cat","dog","tiger",1024] # 方括号[]真正创建一个列表
print(ls) # ['cat', 'dog', 'tiger', 1024]
lt=ls #赋值仅传递引用
print(lt) # ['cat', 'dog', 'tiger', 1024]

列表操作符

函数或方法	描述
ls[i]=x	替换列表ls第i元素为x
ls[i:j:k]=lt	用列表lt替换ls切片后所对应元素子列表
del ls[i]	删除列表ls中第i元素
del ls[i:j:k]	删除列表ls中第i到第j以k为步长的元素
ls+=lt	更新列表ls,将列表lt元素增加到列表ls中
ls*=n	更新列表ls,其元素重复n次

---

举例：

ls=["cat","dog","tiger",1024] # 方括号[]真正创建一个列表
ls[1:2]=[1,2,3,4]
print(ls) # ['cat', 1, 2, 3, 4, 'tiger', 1024]
del ls[::3]
print(ls) # [1, 2, 4, 'tiger']
ls*=2
print(ls) # [1, 2, 4, 'tiger', 1, 2, 4, 'tiger']

列表函数

函数或方法	描述
ls.append(x)	在列表ls最后增加一个元素x
ls.clear()	删除列表ls中所有元素、
ls.copy()	生成一个新列表，赋值ls中所有元素
ls.insert(i,x)	在列表ls的第i位置增加元素x
ls.pop(i)	将列表ls中第i位置元素取出并删除该元素
ls.remove(x)	将列表ls中出现的第一个元素x删除
ls.reverse()	将列表ls中的元素反转

---

举例：

ls=["cat","dog","tiger",1024] 
ls.append(1234)
print(ls) # ['cat', 'dog', 'tiger', 1024, 1234]
ls.insert(3,"human")
print(ls) # ['cat', 'dog', 'tiger', 'human', 1024, 1234]
ls.reverse()
print(ls) # [1234, 1024, 'human', 'tiger', 'dog', 'cat']

字典类型

字典定义

映射：映射是一种键(索引)和值(数据)的对应

字典类型是"映射"的体现

• 键值对：键是数据索引的扩展
• 字典是键值对的集合，键值对之间无序
• 采用大括号{}和dict()创建，键值对用冒号：表示

---

举例：

d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print(d) # {'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
print(d["中国"]) # 北京

de={}
print(type(de)) # <class 'dict'>   de的类型为字典类型

字典操作符

函数或方法	描述
del d[k]	删除字典d中键k对应的数据值
k in d	判断键k是否在字典d中，如果在返回True,否则返回False
d.keys()	返回字典d中所有的键信息
d.values()	返回字典d中所有的值的信息
d.items()	返回字典d中所有键值对信息

---

举例：

d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print("中国"in d) # True
print(d.keys())  # dict_keys(['中国', '美国', '法国'])
print(d.values()) # dict_values(['北京', '华盛顿', '巴黎'])
print(d.items())  # dict_items([('中国', '北京'), ('美国', '华盛顿'), ('法国', '巴黎')])

字典函数

函数或方法	描述
d.get(k,<default>)	键k存在，则返回相应值，不在则返回<default>值
d.pop(k,<default>)	键k存在，则取出相应值，不在则返回<default>值
d.popitem()	随机从字典d中取出一个键值对，以元组形式返回
d.clear()	删除所有的键值对
len(d)	返回字典d中元素的个数

---

举例：

d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print(d.get("中国","伊斯兰堡")) # 北京
print(d.get("巴基斯坦","伊斯兰堡")) # 伊斯兰堡
print(d.popitem()) # ('法国', '巴黎')

字典应用场景

映射的表达

• 映射无处不在，键值对无处不在
• 例如：统计数据出现的次数，数据为键，次数是值
• 最主要作用：表达键值对数据，进而操作它们

组合数据类型总结

• 序列是基类类型，扩展类型包括：字符串、元组和列表
• 元组用()和tuple()创建，列表用[]和list()创建
• 元组操作与序列操作基本相同
• 列表操作在序列操作基础上，增加了更多的灵活性