python3自动化学习02

Posted 2020-11-17 lichengguo

概要：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 ‘‘‘

View Code

 

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)

View Code

 

 二 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 ‘‘‘

View Code

 

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 ‘‘‘

View Code

 

 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)

View Code

 

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)

View Code

 

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 ‘‘‘

View Code

 

单向队列（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())

View Code