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_0,s_1 s0,s1,…, s ( n − 1 ) s_{(n-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)) # 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, |
键k存在，则返回相应值，不在则返回 |
| d.pop(k, |
键k存在，则取出相应值，不在则返回 |
| d.popitem() | 随机从字典d中取出一个键值对，以元组形式返回 |
| d.clear() | 删除所有的键值对 |
| len(d) | 返回字典d中元素的个数 |
举例：
d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print(d.get("中国","伊斯兰堡")) # 北京
print(d.get("巴基斯坦","伊斯兰堡")) # 伊斯兰堡
print(d.popitem()) # ('法国', '巴黎')
字典应用场景
映射的表达
- 映射无处不在，键值对无处不在
- 例如：统计数据出现的次数，数据为键，次数是值
- 最主要作用：表达键值对数据，进而操作它们
组合数据类型总结
- 序列是基类类型，扩展类型包括：字符串、元组和列表
- 元组用()和tuple()创建，列表用[]和list()创建
- 元组操作与序列操作基本相同
- 列表操作在序列操作基础上，增加了更多的灵活性