Python之路（组合数据类型及操作）
集合类型
集合类型的定义
- 集合是多个元素的无序组合
- 集合类型与数学中的集合概念一致
- 集合类型之间无序，每个元素唯一，不存在相同元素
- 集合元素之间不可或更改，不是可变数据类型
- 集合用大括号 {} 表示，元素间用逗号分隔
- 建立集合类型用 {} 或 set()
- 建立空集合类型，必须使用set()
集合操作符
- 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中的非相同
1 python_l=['lcg','szw','zjw','lcg']
2 linux_l=['lcg','szw','sb']
3 p_s=set(python_l)
4 l_s=set(linux_l)
5 print(p_s,l_s)
6 求交集
7 print('交集',p_s&l_s)
8 p_s&=l_s
9 print('更新交集',p_s)
10 print(p_s.intersection(l_s))#求集
11 p_s.intersection_update(l_s)#求集并更新到左边部分
12 print(p_s,l_s)
13 求并集
14 print('并集',p_s|l_s)
15 p_s|=l_s
16 print('更新并集',p_s)
17 print(p_s.union(l_s))#求集
18 p_s.update(l_s)#求集并更新到左边部分
19 print(p_s,l_s)
20 求差集
21 print('差集',p_s-l_s)
22 p_s-=l_s
23 print('更新差集',p_s)
24 print(p_s.difference(l_s))#求集
25 p_s.difference_update(l_s)#求集并更新到左边部分
26 print(p_s,l_s)
27 求补集
28 print('补集',p_s^l_s)
29 p_s^=l_s
30 print('更新补集',p_s)
31 print(p_s.symmetric_difference(l_s))#求集
32 p_s.symmetric_difference_update(l_s)#求集并更新到左边部分
33 print(p_s,l_s)
34 判断s1是否不是s2的子集，不是就返回True，否则False
35 s1={1}
36 s2={2,3,5}
37 print(s1.isdisjoint(s2))
38 s1={1,2}
39 s2={1,2,3,4}
40 print(s1<=s2)#判断S和T的子集关系,判断S和T的包含关系
41 print(s1.issubset(s2))#判断s1是s2的子集，是就True，否则False
42 print(s2.issubset(s1))
43 print(s2.issuperset(s1))#判断s2是s1的父集，是就True，否则False
44 print(s1.issuperset(s2))
集合处理方法
操作函数或方法 描述
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中，返回False，否则返回True
set(x) 将其他类型变量x转变为集合类型
1 数据类型的相互转化
2 s=frozenset('hello')
3 print(s)
4 names=['alex','alex','wupeiqi']
5 names=list(set(names))
6 print(names)
7 #set建立集合
8 s=set(['hello','hello','lz','age'])
9 s={'hello','hello','lz','age'}
10 print(s) #{'hello', 'lz', 'age'}
11
12 #s.add添加
13 s={1,2,3,4,5,6}
14 s.add('s')
15 s.add('s')
16 s.add(3)
17 s.add(3)
18 print(s)#{1, 2, 3, 4, 5, 6, 's'}
19 #移除所有元素
20 s1=s.copy()#4,返回集合s的一个副本
21 s.clear()
22 print(s)
23 print(s1)
24
25 s={'sb',1,2,3,4,5,6}
26 #随机删除
27 s.pop()
28 print(s)
29 #指定删除
30 s.remove('sb')#元素不存在会报错
31 print(s)
32 s.discard(2)#元素不存在并不会报错
33 print(s)
34 s={1,2,3,4,5}
35 s1=[1,2,3,4,5]
36 s2=set(s1)#将其他类型变量x转变为集合类型
37 print(s2)#{1, 2, 3, 4, 5}
38 print(len(s))#返回集合S的元素个数
39 print(1 in s)#判断S中元素x，x在集合S中，返回True，否则返回False
40 print(1 not in s)#判断S中元素x，x不在集合S中，返回False，否则返回True
集合应用场景
1 # 数据去重：集合类型所有元素无重复 2 ls=['df','df','er',1,2,'er'] 3 s=set(ls) 4 ls=list(s) 5 print(ls)
元组类型
元组类型定义
- 元组是序列类型的一种扩展
- 元组是一种序列类型，一旦创建就不能被修改
- 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔
- 可以使用或不使用小括号 def func():return 1,2
- 元组继承序列类型的全部通用操作
- 元组因为创建后不能修改，因此没有特殊操作
元组类型操作
- 创建
- 索引
- 切片
- 循环
- 长度
- 数据类型转换
1 #---------元组类型----------
2 #创建元组
3 tu = (111,"me",(11,22),[(33,44)],True,33,44,)
4 tu = [111,"me",(11,22),[(33,44)],True,33,44,]
5 s=tuple(tu)
6 print(s)
7 #索引
8 v=s[0]
9 print(v)
10 #切片
11 v=s[0:2]
12 print(v)
13 #循环
14 for item in s:
15 print(item,end=' ')
16 长度
17 l=len(s)
18 print(l)
19 #转换
20 a='dfgtyuhj'
21 li=['dfgfgh','dghxe']
22 tup=('xvbt','hjdc')
23
24 v=tuple(a)
25 print(v)
26
27 v=tuple(li)
28 print(v)
29
30 v=list(tup)
31 print(v)
32
33 v='_'.join(tup)
34 print(v)
35
36 li=['dfgfgh','dghxe']
37 li.extend((11,22,33,))
38 print(li)
39 其他操作
40 a=('dfg','fgh','vgfsd','fgh','vgfsd','fgh')
41 b=('uj7d','weg')
42 print(a+b)#连接两个序列s和t
43 print(2*a)#将序列s复制n次
44 print(a.index('fgh',2,-1))#返回序列s从i开始到j位置中第一次出现元素x的位置
45 print(a.count('fgh'))#返回序列s中出现x的总次数
46 print('dfg' in a)
47 print('dfg' not in a)
列表类型
列表类型定义
- 列表是序列类型的一种扩展，十分常用
- 列表是一种序列类型，创建后可以随意被修改
- 使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
- 列表中各元素类型可以不同，无长度限制
列表类型操作
- 按索引取值（正+反）：可存可取
- 切片
- 长度
- 追加
- 删除
- 循环
1 import copy
2 li=[11, 22, 33, 22, 44]
3 追加
4 li.append('cd')
5 li.append(['xcg','ersx'])
6 print(li)
7
8 清空
9 li.clear()
10 print(li)
11
12 拷贝：深、浅拷贝
13 v=li.copy()
14 s=copy.deepcopy(li)
15 li[6][0]='lz'
16 print(v)#改变
17 print(s)#不变
18
19 计算元素出现的次数
20 print(li.count(22))
21
22 扩展原列表，参数：可迭代对象
23 li = [11, 22, 33, 22, 44]
24 li.extend(['dfg','hjc'])
25 print(li)
26
27 根据值获取当前值索引位置（左边优先）
28 li = [11, 22, 33, 22, 44]
29 print(li.index(22,2,-1))
30
31 在指定索引位置插入元素
32 li.insert(1,55)
33 print(li)
34
35 删除某个值(1.指定索引；2. 默认最后一个)，并获取删除的值
36 li.pop(0)
37 print(li)
38
39 删除列表中的指定值，左边优先
40 li.remove(22,)
41 print(li)
42
43 将当前列表进行翻转
44 li = [11, 22, 33, 22, 44]
45 li.reverse()
46 print(li)
47
48 列表的排序
49 li = [11, 22, 33, 22, 44]
50 li.sort()#正序
51 print(li)
52 li.sort(reverse=True)#反序
53 print(li)
54
55 索引取值
56 li = [11, 22, 33, 22, 44]
57 print(li[1])
58
59 切片
60 li = [11, 22, 33, 22, 44]
61 print(li[1:-1])
62
63 循环
64 li = [11, 22, 33, 22, 44]
65 for item in li:
66 print(item,end=' ')
67
68 修改
69 li = [11, 22, 33, 22, 44]
70 li[1]=200
71 print(li)
72
73 li[1:3]=[20,30]
74 print(li)
75
76 li[0]=['df','cvb','rty']
77 print(li)
78
79 删除
80 li = [11, 22, 33, 22, 44]
81 del li[0]
82 print(li)
83
84 del li[1:3]
85 print(li)
86
87 enumerate操作:可以指定索引从哪个数开始
88 tu=['me','father','mother','brother']
89 for index,element in enumerate(tu,10):
90 print(index,element)
91
92 直接使用字符串join方法：列表中的元素只有字符串
93 li = ["123","lzme"]
94 v = "".join(li)
95 print(v)
96
97 补充：字符串创建后，不可修改
98 v = "memofabo"
99 v = v.replace('m','M')
100 print(v)
字典类型
字典的定义
- 映射是一种键(索引)和值(数据)的对应，字典类型是“映射”的体现
- 键值对：键是数据索引的扩展
- 字典是键值对的集合，键值对之间无序
- 采用大括号{}和dict()创建，键值对用冒号: 表示
字典类型操作
- 索引
- 长度
- 新增
- 删除
- 循环
- 取键值对
1 创建字典
2 dic=dict()
3 dic={"k1": 'v1',
4 "k2": 'v2'}
5 print(dic)
6
7 根据序列，创建字典，并指定统一的值
8 v = dict.fromkeys(["k1",123,"999"],123)
9 print(v)
10
11 dict.get(Key,b)根据Key获取值，键k存在，则返回相应值，不在则返回<default>值
12 dic={
13 'k1':'v1',
14 'k2':'v2'
15 }
16 v = dic['k1']
17 print(v)
18 v = dic.get('k3',111111)
19 print(v)
20
21 dict.pop(k,<default>)删除并获取值,键k存在，则取出相应值，不在则返回<default>值
22 dic = {
23 "k1": 'v1',
24 "k2": 'v2',
25 "k3": 'v3',
26 }
27 v = dic.pop('k1', 90)
28 print(dic, v)
29
30 dict.popitem()随机从字典d中取出一个键值对，以元组形式返回
31 s = dic.popitem()
32 print(dic, s)
33 k,v=dic.popitem()
34 print(dic,k,v)
35
36 设置值，
37 已存在，不设置，获取当前key对应的值
38 不存在，设置，获取当前key对应的值
39 dic = {
40 "k1": 'v1',
41 "k2": 'v2',
42 "k3": 'v3',
43 }
44 v = dic.setdefault('k1111', '123')
45 print(dic, v)
46
47 更新，更改或新增值
48 dic = {
49 "k1": 'v1',
50 "k2": 'v2',
51 "k3": 'v3'
52 }
53 dic.update({'k1': '111111', 'k3': 123})
54 print(dic)
55 dic.update(k1=123, k3=345, k5="asdf")
56 print(dic)
57
58 返回字典dic中元素的个数
59 dic = {
60 "k1": 'v1',
61 "k2": 'v2',
62 "k3": 'v3'
63 }
64 print(len(dic))
65
66 删除所有的键值对
67 dic.clear()
68 print(dic)
69
70 删除字典d中键k对应的数据值
71 dic = {
72 "k1": 'v1',
73 "k2": 'v2',
74 "k3": 'v3'
75 }
76 del dic['k2']
77 print(dic)
78 判断键k是否在字典dic中，如果在返回True，否则False
79 print('k1' in dic)
80 返回字典d中所有的键信息
81 print(dic.keys())
82 返回字典d中所有的值信息
83 print(dic.values())
84 返回字典d中所有的键值对信息
85 print(dic.items())
86
87 循环遍历字典
88 dic = {
89 "k1": 'v1',
90 "k2": 'v2',
91 "k3": 'v3'
92 }
93 for k in dic.keys():
94 print(k)
95 for v in dic.values():
96 print(v)
97 for k,v in dic.items():
98 print(k,v)
99 for k,v in enumerate(dic.items(),20):
100 print(k,v[0],v[1])
101 for k,v in enumerate(dic,20):
102 print(k,v,dic[v])
补充
布尔值
1 None "" () [] {} 0 ==> False 2 print(bool(None))
扫一扫
13万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
