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'}
练习：
#数据库中原有
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'}
collection系列
计数器（counter）
需要进行模块功能导入: import collection
Counter是对字典类型的补充，用于追踪值的出现次数。
ps：具备字典的所有功能 + 自己的功能
c = Counter('abcdeabcdabcaba') print c 输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
import collections #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 in num.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 in num.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})
有序字典(orderedDict )
orderdDict是对字典类型的补充，他记住了字典元素添加的顺序
import collections d = collections.OrderedDict({'name':'liu','age':18,'address':'beijing'}) # print(d) print(type(d)) # result: # OrderedDict([('age', 18), ('name', 'liu')]) # <class 'collections.OrderedDict'> #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，v print(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)])
默认字典(defaultdict)
defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。
练习：有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66 , 'k2': 小于66}
from collections import defaultdict values = [11, 22, 33,44,55,66,77,88,99,90] my_dict = defaultdict(list) for value in values: if value>66: my_dict['k1'].append(value) else: my_dict['k2'].append(value)
可命名元组(namedtuple)
根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型。
import collections MytupleClass = collections.namedtuple("MytupleClass",['x','y','z']) xyz = MytupleClass(11,22,33) print(xyz.x,xyz.y,xyz.z)
#result：11 22 33
队列
queue.Queue，先进先出队列
queue.LifoQueue，后进先出队列
queue.PriorityQueue，优先级队列
queue.deque，双向对队
queue.Queue(2) 先进先出队列
put放数据,是否阻塞,阻塞时的超时时间
get取数据(默认阻塞),是否阻塞,阻塞时的超时时间
队列的最大长度
qsize()真实个数
maxsize 最大支持的个数
jion,task_done,阻塞进程,当队列中任务执行完毕后,不再阻塞
先进先出（Queue）
#先进先出 # import queue # q = queue.Queue(2) #先进先出 # print(q.empty()) #True # q.put(11) # q.put(22) # print(q.empty()) #False # print(q.qsize()) #2 # q.put(22) # q.put(33,block=False) # q.put(33,block=False,timeout=2) # print(q.get()) # print(q.get()) # print(q.get(timeout=2)) # import queue # q = queue.Queue(5) # q.put(123) # q.put(456) # q.get() # q.task_done() # q.join()
后进先出队列（LifoQueue）
#后进先出 import queue q = queue.LifoQueue() #后进先出 q.put(123) q.put(456) print(q.get()) #456
优先级处理队列（PriorityQueue）
#根据优先级处理 import queue q = queue.PriorityQueue() #根据优先级处理 q.put((1,"lhq1")) q.put((1,"lhq2")) q.put((1,"lhq3")) q.put((3,"lhq3")) print(q.get()) #(1, 'lhq1')
双向队列(deque)
一个线程安全的双向队列
创建双向队列引入collections
import collections d = collections.deque() 返回结果：<class 'collections.deque'>
创建单向队列 引入queue
#创建单向队列 import queue q = queue.Queue() print(type(q)) #<class 'queue.Queue'>
文件操作
打开文件
注：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()
