概要：set集合、 collections系列 （计数器、有序字典、默认字典、可命名元组、队列）
一 set集合
set集合：无序且不重复的元素集合
优势：1.访问速度快
2.天生解决了重复问题
set功能演示
1 #!/usr/bin/env python3
2 #author:Alnk
3 s1 = set([11,22,33,])
4 s2 = set([33,44])
5 ‘‘‘
6 #add --增加一个元素到集合
7 s1.add(55)
8 print(s1)
9
10 #clear --清除集合中所有的元素
11 s1.clear()
12 print(s1)
13
14 #copy --拷贝,会在内存中创建新的集合？
15 s3 = s1.copy()
16 print("s3:%s" %s3)
17 s3.pop()
18 print("s1:%s" %s1)
19 print("s3:%s" %s3)
20
21 #difference --取差集，并且新建一个集合
22 s3 = s1.difference(s2) #取 s1 与 (s1 与 s2 交集) 的差集
23 s4 = s2.difference(s1) #取 s2 与 (s1 与 s2 交集) 的差集
24 print("s3:",s3)
25 print("s4:",s4)
26
27 #difference_update --取差集，并且修改原来的集合
28 #s1.difference_update(s2) #取 s1 与 (s1 与 s2 交集) 的差集
29 #s3 = s1
30 #print(s3)
31 s2.difference_update(s1) #取 s2 与 (s1 与 s2 交集) 的差集
32 print(s2)
33
34 #discard --删除元素
35 s1.discard(11)
36 print(s1)
37
38 #intersection --取交集，并且新建一个集合
39 s3 = s1.intersection(s2)
40 print(s3)
41
42 #intersection_update --取交集，并且修改原来的集合
43 s1.intersection_update(s2)
44 s3 = s1
45 print(s3,s1)
46
47 #isdisjoint --如果没有交集返回True
48 t = s1.isdisjoint(s2)
49 print(t)
50
51 #issubeset --是否是子集
52 print(s2.issubset(s1)) #s2 是否是 s1 的子集
53
54 #issuperset --是否是父集
55 print(s1.issuperset(s2)) #s1 是否是 s2 的父集
56
57 #pop --随机弹出一个元素
58 s3 = s1.pop()
59 print(s1)
60 print(s3)
61
62 #remove --指定删除元素
63 s1.remove(11)
64 print(s1)
65
66 #symmetric_difference --并集减去交集，并且创建一个新对象
67 s3 = s2.symmetric_difference(s1) #(s2与s1的并集) 减去 (s2 与 s1 的交集)
68 print(s3)
69 #union --并集，创建一个新的集合
70 s3 = s1.union(s2)
71 print(s3)
72 #intersection --交集，创建一个新的集合
73 s4 = s1.intersection(s2)
74 print(s4)
75 #difference --差集，创建一个新的集合
76 s5 = s3.difference(s4)
77 print(s5)
78
79 #symmetric_difference_update --并集减去交集，并且修改原来的集合
80 s1.symmetric_difference_update(s2) #(s2与s1的并集) 减去 (s2 与 s1 的交集)
81 print(s1)
82
83 #update --更新，相当于并集，修改原来的集合
84 s1.update(s2) #取s1和s2并集，并修改s1
85 print(s1)
86 print(s2)
87 ‘‘‘
set练习
1 #!/usr/bin/env python3
2 #author:Alnk
3 """
4 练习：寻找差异
5 # 数据库中原有
6 old_dict = {
7 "#1":{ ‘hostname‘:c1, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 },
8 "#2":{ ‘hostname‘:c1, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 },
9 "#3":{ ‘hostname‘:c1, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 }
10 }
11
12 # cmdb 新汇报的数据
13 new_dict = {
14 "#1":{ ‘hostname‘:c1, ‘cpu_count‘: 2, ‘mem_capicity‘: 800 },
15 "#3":{ ‘hostname‘:c1, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 },
16 "#4":{ ‘hostname‘:c2, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 }
17 }
18 需要删除:？
19 需要新建：？
20 需要更新：？ 注意：无需考虑内部元素是否改变，只要原来存在，新汇报也存在，就是需要更新
21 """
22 old_dict = {
23 "#1":{ ‘hostname‘:‘c1‘, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 },
24 "#2":{ ‘hostname‘:‘c1‘, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 },
25 "#3":{ ‘hostname‘:‘c1‘, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 }
26 }
27
28 new_dict = {
29 "#1":{ ‘hostname‘:‘c1‘, ‘cpu_count‘: 2, ‘mem_capicity‘: 800 },
30 "#3":{ ‘hostname‘:‘c1‘, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 },
31 "#4":{ ‘hostname‘:‘c2‘, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 }
32 }
33
34 #获取两个字典的key值，并且创建成set集合
35 old = set(old_dict.keys())
36 print(old)
37 new = set(new_dict.keys())
38 print(new)
39
40 #需要更新的数据
41 update_set = old.intersection(new)
42 print(update_set)
43
44 #需要增加的数据
45 add_set = new.difference(old)
46 print(add_set)
47
48 #需要删除的数据
49 del_set = old.difference(new)
50 print(del_set)
二 collections系列
1.计数器（counter）
counter：是对字典类型的补充，用于追踪值出现的次数（序列里面元素出现的次数）
counter继承了dict类，所有它能够使用dict类的方法
counter功能演示
1 #!/usr/bin/env python3 2 #author:Alnk 3 import collections 4 5 c = collections.Counter(‘abcdeabcdabcaba‘) 6 #c = collections.Counter([‘11‘,‘22‘,‘33‘,‘22‘]) 7 print(c) 8 ‘‘‘ 9 #注意是类似字典而并不是真正的字典 10 print(type(c)) 11 #elements 与 items 差别 12 #elements --循环所有值与 dict 一样，拿到所有原生的值，没有经过处理。 13 for i in c.elements(): 14 print(i) 15 #items --处理完以后的数据，循环键值对。 16 for k,v in c.items(): 17 print(k,v) 18 #循环键 19 for k in c.keys(): 20 print(k) 21 22 #update --更新计数器，其实就是增加；如果原来没有，则新建，如果有则加一 23 obj = collections.Counter([‘11‘,‘22‘,‘22‘,‘33‘]) 24 print(obj) 25 obj.update([‘Alnk‘,‘11‘,‘11‘]) 26 print(obj) 27 28 #subtract --相减，原来的计数器中的每一个元素的数量减去后添加的元素的数量,可以产生负数 29 obj = collections.Counter([‘11‘,‘22‘,‘22‘,‘33‘]) 30 obj.subtract([‘11‘,‘Alnk‘,‘11‘]) 31 print(obj) 32 ‘‘‘
2.有序字典（OrderDict）
OrderDict原理：
L1 = [k1,k2,k3, ...]
D1 = {‘k1‘:‘v1‘,‘k2‘:‘v2‘,...}
通过迭代L1中有序的元素(key)，去排序D1中无序的字典。
OrderDict继承了dict类，所有它能够使用dict类的方法
OrderDict部分功能演示
1 #!/usr/bin/env python3
2 #author:Alnk
3 import collections
4
5 dic = collections.OrderedDict()
6 #dic = {}
7 dic[‘k1‘] = ‘v1‘
8 dic[‘k2‘] = ‘v2‘
9 dic[‘k3‘] = ‘v3‘
10 dic[‘k4‘] = ‘v4‘
11 print(dic)
12 ‘‘‘‘
13 #move_to_end --把指定的键值对拿到最后
14 dic.move_to_end(‘k1‘)
15 print(dic)
16
17 #popitem() --后进先出，与弹夹类似
18 dic.popitem()
19 print(dic)
20
21 #pop() --指定拿出的键值对。还可以有返回值
22 #dic.pop(‘k2‘)
23 #print(dic)
24 ret = dic.pop(‘k2‘)
25 print(ret)
26
27 #update() --加数据，需要传字典
28 dic.update({‘k1‘:‘v11111‘,‘k10‘:‘v10‘})
29 print(dic)
30 ‘‘‘
3.默认字典（defaultdict）
可以设定字典的值是默认的某个数据类型
defaultdict继承了dict类，所有它能够使用dict类的方法
defaultdict练习
1 #!/usr/bin/env python3
2 #author:Alnk
3 import collections
4 ‘‘‘
5 #示例1
6 all_list = [11,22,33,44,55,66,77,88,99,90]
7 dic = {}
8 for i in all_list:
9 if i > 66:
10 if ‘k1‘ in dic.keys():
11 dic[‘k1‘].append(i)
12 else:
13 dic[‘k1‘] = [i,]
14 else:
15 if ‘k2‘ in dic.keys():
16 dic[‘k2‘].append(i)
17 else:
18 dic[‘k2‘] = [i,]
19 print(dic)
20 #上面列子解解释
21 dic = {‘k1‘:[1,]}
22 print(type(dic[‘k1‘])) #dic[‘k1‘]相当于一个列表，当然可以append啦
23 dic[‘k1‘].append(2)
24 print(dic)
25
26 #默认字典：可以定义一个值，让字典的默认值是一个列表
27 dic = collections.defaultdict(list)
28 dic[‘k1‘].append(‘Alnk‘)
29 print(dic)
30 ‘‘‘
31 #上面的示例1可以按照如下方法实现
32 all_list = [11,22,33,44,55,66,77,88,99,90]
33 dic = collections.defaultdict(list)
34 for value in all_list:
35 if value > 66:
36 dic[‘k1‘].append(value)
37 else:
38 dic[‘k2‘].append(value)
39 print(dic)
4.可命名元组（namedtuple）
可命名元组没有继承python的类，所以需要自定义一个类。
t = (11, 22, 33)
name addr ip
可以通过给元素重命名，以后通过命名访问，而不用索引，如：
t.name
t.addr
t.ip
可命名元组可以应用于坐标，示例
1 #!/usr/bin/env python3 2 #author:Alnk 3 import collections 4 5 #创建类，和defaultdict有点类似 6 #坐标会使用到这个 7 mytuple_class = collections.namedtuple(‘mytuple_class‘,[‘x‘,‘y‘,‘z‘]) 8 #print(help(mytuple_class)) 9 obj = mytuple_class(11,22,33) 10 print(obj.x,obj.y,obj.z)
5.双向队列、单向队列
双向队列（deque）
双向队列可以两端都插入和取出，也可以随意插入和取出，很灵活。
功能演示
1 #!/usr/bin/env python3 2 #author:Alnk 3 import collections 4 5 d = collections.deque() 6 d.append(‘1‘) 7 d.appendleft(‘10‘) 8 d.appendleft(‘1‘) 9 d.extend([‘yy‘,‘zz‘]) 10 d.extendleft([‘aa‘,‘bb‘]) 11 print(d) 12 ‘‘‘ 13 #count --计数 14 r = d.count(‘1‘) 15 print(r) 16 17 #extend --多个元素添加，扩展 18 d.extend([‘yy‘,‘zz‘]) 19 d.extendleft([‘aa‘,‘bb‘]) 20 print(d) 21 22 #index --取这个值在队列里面的索引,默认从左往右，取第一个找到的值的索引 23 s = d.index(‘1‘) 24 print(s) 25 26 #insert --插入，随便插入 27 #pop --默认从右边取数据 28 #popleft --从左边取数据 29 #remove --删除 30 #reverse --反转 31 #rotate --队列可以理解为首尾是相连的，这个就相当于转动这个圆盘一样。从右边拿数据插到左边，执行1次操作 32 d.rotate(1) 33 print(d) 34 ‘‘‘
单向队列（queue），单向队列的位于queue模块里面，和上面其他介绍的位于collections系列不一样
先进先出，后进后出
部分功能演示
1 #!/usr/bin/env python3
2 #author:Alnk
3 import queue
4
5 #队列长度可为无限或者有限。可通过Queue的构造函数的可选参数maxsize来设定队列长度
6 d = queue.Queue(maxsize=10)
7
8 #put --将一个值放入到队列当中
9 d.put("aa")
10 d.put("bb")
11
12 #qsize --统计队列中的元素
13 print(d.qsize())
14
15 #empty --如果队列为空，返回True，否则False
16 print(d.empty())
17
18 #full --如果队列已满返回Ture，否则False
19 print(d.full())
20
21 #get --取出队列中的一个元素
22 print(d.get())
原文地址：https://www.cnblogs.com/lichengguo/p/9174469.html
时间： 2024-10-22 22:11:21