python保存队列数据到文件_Python运维之路（set、collection系列、队列及文件操作）...

SET集合

set是一个无序且不重复的元素集合

创建集合：

name = set("aqwqewqa")

print(name)

result：

{'a', 'e', 'w', 'q'}

#移除

s1.discard(1) #元素存在直接移除 不存在不会报错

s1.remove(1) #元素存在直接移除,不存在会报错

s1.pop() #随机删除最后一个元素

s1 = set(["l","i","u"])#add 添加集合元素

s1.add("huanqin")print(s1)#result : {'l', 'i', 'huanqin', 'u'}

##clear 清空集合元素

s1.clear()print(s1)#result : set()

#copy 浅拷贝,只拷贝第一层数据

print(s1.copy())#result : {'i', 'u', 'l'}

#difference 返回一个新的set s1中有，s2中没有的

s2 = set("iu")

s3=s1.difference(s2)print(s3)#result：{'l'}

#difference_update 更改原有set，不返回一个新的, s1中有，s2中没有的

s2 = set("iu")

s1.difference_update(s2)print(s1)#result:{'l'}

#discard 移除集合元素

s1.discard("l")print(s1)#result:{'i', 'u'}

#intersection 取交集 重新生成一个set

s2 = set(["l","i"])

s3=s1.intersection(s2)print(s3)#result:{'l', 'i'}

#intersection_update 修改原set

s2 = set(["l","i"])

s1.intersection_update(s2)print(s1)#result:{'l', 'i'}

#isdisjoint 是否有交集 无则返回True

s2 = set(["l","i"])print(s1.isdisjoint(s2))#result：False

#issubset 是否是子集

s2 = set(["l","i"])print(s2.issubset(s1)) #判断s2是否是s1的子集#result:True

print(s1.issubset(s2)) #判断s1是否是s2的子集#result:False

#issuperset 是否是父集

s2 = set(["l","i"])print(s2.issuperset(s1)) #判断s2是否是s1的父集#result：False

print(s1.issuperset(s2)) #判断s1是否是s2的父集#result：True

#pop 移除集合元素,默认移除最后一个

s1.pop()print(s1)#result：{'u', 'l'}

#remove 移除指定元素

s1.remove("l")print(s1)#result:{'u', 'i'}

#symmetric_difference 差集 会创建一个新的集合

s2 = set(["l","i"])

s3=s1.symmetric_difference(s2)print(s3)#result:{'u'}

#symmetric_difference_update 差集 会修改原有集合

s2 = set(["l","i"])

s1.symmetric_difference_update(s2)print(s1)#result:{'u'}

#union 并集 创建一个新的对象

s2 = set(["h","u"])

s3=s1.union(s2)print(s3)#result:{'u', 'h', 'i', 'l'}

#update 更新当前集合

s2 = set("hu")

s1.update(s2)print(s1)#result:{'h', 'u', 'l', 'i'}

set 集合

练习：

#数据库中原有

old_dict = {

"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },

"#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },

"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }

}

# cmdb 新汇报的数据

new_dict = {

"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },

"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },

"#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 }

}

需求：获取最新报表

注意：无需考虑内部元素是否改变，只要原来存在，新汇报也存在，就是需要更新

思路：

1. 需要更新的列表 update_list

2. 需要删除的列表 del_list

3. 需要增加的列表 add_list

程序：

old_set=set(old_dict.keys())

new_set=set(new_dict.keys())

update_set=new_set.intersection(old_dict)

delete_set=old_set.difference(update_set)

add_set=new_set.difference(update_set)print(update_set,delete_set,add_set)#result:{'#3', '#1'} {'#2'} {'#4'}

练习程序demo

collection系列

计数器(counter)

需要进行模块功能导入: import collection

Counter是对字典类型的补充，用于追踪值的出现次数。

ps：具备字典的所有功能 + 自己的功能

c = Counter('abcdeabcdabcaba')printc

输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

importcollections#Counter 统计字符出现个数，结果是字典类型

num = collections.Counter("qwererqewafda")print(num)#result：Counter({'e': 3, 'a': 2, 'q': 2, 'w': 2, 'r': 2, 'f': 1, 'd': 1})

for k,v innum.items():print(k,v)#result:#q 2#d 1#e 3#f 1#r 2#w 2#a 2

#most_common

print(num.most_common(4)) #出现次数最高的前四个，数量大于等n的所有元素和计数器#result:[('e', 3), ('q', 2), ('r', 2), ('w', 2)]

for k in num.most_common(4):print(k)#result:#('e', 3)#('w', 2)#('r', 2)#('q', 2)

#elements 输出计数器中的所有元素，注：此处非所有元素集合，而是包含所有元素集合的迭代器

for i innum.elements():print(i)#result:#w#w#q#q#f#e#e#e#r#r#d#a#a

#sorted 按照ascii码进行元素排序

print(sorted(num.elements()))#result:['a', 'a', 'd', 'e', 'e', 'e', 'f', 'q', 'q', 'r', 'r', 'w', 'w']

#__missing__ 对于不存在的元素，返回计数器0

a = num.__missing__("h")print(a)#result: 0

#b= num["h"] #统计key的个数 若key不存在则返回0

print(b)#result：0

#update 更新计数器，其实就是增加；如果原来没有，则新建，如果有则加一

num.update("asdf")print(num)#result:Counter({'e': 3, 'a': 3, 'w': 2, 'r': 2, 'q': 2, 'f': 2, 'd': 2, 's': 1})

#subtract 相减，原来的计数器中的每一个元素的数量减去后添加的元素的数量

num.subtract("asdf")print(num)#result:Counter({'e': 3, 'r': 2, 'q': 2, 'w': 2, 'a': 1, 'f': 0, 'd': 0, 's': -1})

#copy 浅拷贝

c =num.copy()print(c)#result:Counter({'e': 3, 'w': 2, 'a': 2, 'r': 2, 'q': 2, 'f': 1, 'd': 1})

#del 删除

del num["e"]print(num["e"])#result:0

#__delitem__ 删除元素

d = num.__delitem__("e")print(num)#result:Counter({'w': 2, 'q': 2, 'a': 2, 'r': 2, 'f': 1, 'd': 1})

counter

有序字典(orderedDict )

orderdDict是对字典类型的补充，他记住了字典元素添加的顺序

importcollections

d= collections.OrderedDict({'name':'liu','age':18,'address':'beijing'})#print(d)

print(type(d))#result:#OrderedDict([('age', 18), ('name', 'liu')])#

#move_to_end 将指定的键值移动到末尾

d.move_to_end("age")print(d)#result:OrderedDict([('adderss', 'beijing'), ('name', 'liu'), ('age', 18)])

#pop 删除key 但是会返回value

e = d.pop('address')print(d) 删除k，vprint(e) value值#result :#OrderedDict([('name', 'liu'), ('age', 18)])#beijing

#clear 清空有序字典的值

d.clear()print(d)#result:OrderedDict()

#keys,values,items

l1 =d.keys()print(l1)

l2=d.values()print(l2)

l3=d.items()print(l3)#result:#odict_keys(['name', 'address', 'age'])#odict_values(['liu', 'beijing', 18])#odict_items([('name', 'liu'), ('address', 'beijing'), ('age', 18)])

orderedDict

默认字典(defaultdict)

defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。

练习：有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于66 的值保存至字典的第一个key中，将小于66 的值保存至第二个key的值中。

创建双向队列引入collections

importcollections

d=collections.deque()

返回结果：

创建单向队列 引入queue

#创建单向队列

importqueue

q=queue.Queue()print(type(q))#

文件操作

打开文件

注：python中打开文件有两种方式，即：open(...) 和  file(...) ，本质上前者在内部会调用后者来进行文件操作，推荐使用 open。

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式有：

r，只读模式(默认)。

w，只写模式。【不可读；不存在则创建；存在则删除内容；】

a，追加模式。【可读；   不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

r+，可读写文件。【可读；可写；可追加】

w+，写读

a+，同a

"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n (与 r 或 r+ 模式同使用

rU

r+U

"b"表示处理二进制文件(如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注)

rb

wb

ab

#close(self) 关闭文件#

#fileno(self) 文件描述符#

#flush(self) 刷新文件内部缓冲区#

#isatty(self) 判断文件是否是同意tty设备#

#next(self) 获取下一行数据，不存在，则报错#

#read(self, size=None) 读取指定字节数据#

#readinto(self) 读取到缓冲区，不要用，将被遗弃#

#readline(self, size=None) 仅读取一行数据#

#readlines(self, size=None) 读取所有数据，并根据换行保存值列表#

#seek(self, offset, whence=None) 指定文件中指针位置#

#tell(self) 获取当前指针位置#

#truncate(self, size=None) 截断数据，仅保留指定之前数据#

#write(self, p_str) 写内容#

#writelines(self, sequence_of_strings) 将一个字符串列表写入文件#

#xreadlines(self) 可用于逐行读取文件，非全部#seek&&tell

f =open("test.log","w")

f.write("qwewqreasdf")

f=open("test.log","r+")

set= f.read(2)#指定读取字符

print(set)print(f.tell()) #通过字节来计算#result:#qw#2

f.seek(2) #指定指针位置

f.truncate() #截断数据，仅保留指定之前数据

f.close()

seek，read，tell，truncate