python 函数/列表的应用

enumerate 函数用于遍历序列中的元素以及它们的下标：

>>> for i,j in enumerate(('a','b','c')):
 print i,j

0 a
1 b
2 c
>>> for i,j in enumerate([1,2,3]):
 print i,j

0 1
1 2
2 3
>>> for i,j in enumerate({'a':1,'b':2}):
 print i,j

0 a
1 b

>>> for i,j in enumerate('abc'):
 print i,j

0 a
1 b
2 c

集合、有序字典、可命名元祖、计数

 #!/usr/bin/env python3.5
 # -*-coding:utf8-*-
 # s1 = set()  # 集合 是一个无序且不重复的元素集合
 # s1.add("alex")
 # print("s1")
 # s1.add("alex")
 # print("s1")
 # set()  # 访问速度快，天生解决了重复问题  # 用于爬虫等s2 =
 # s2 = set(["alex", "eric", "tony"])
 #print(s2)
 # s3 = s2.difference(["alex", "eric"])  # difference 没有改变原来的元数，生成了一个生的元素（集合）
 # print(s3)
 # # {'tony', 'alex', 'eric'}
 # # {'tony'}
 # s4 = s2.difference_update(["alex", "eric"])  # 不生成新的内容，而是改变原有集合的内容 ，删除当前SET中的所有包含在参数集合里的元素
 # print(s2)
 # print(s4)
 # s5 = s2.intersection(["alex", "eric"])  # 新建一个取相同的部分
 # print(s5)
 # s6 = s2.intersection_update(["alex", "eric"])  # 更新原来的取相同部分
 # print(s2)

 # b = {"1":"2","2":5}
 # c = {"1":"2","2":6}
 # c.update(b)
 # print(b)
 # print(c)

 # import collections
 # obj = collections.Counter(["afad", "adfas"])
 # print(obj)  # 字典
 # obj.update(["afad", "ad2adf"])  # 更新计数
 # print(obj)
 # obj.subtract(["afad", "adfa"])  # 删除计数
 # print(obj)
 # ret = obj.most_common(4)
 # print(ret)
 # for k in obj.elements():
 # elements =>原生值
 #     print(k)  # 循环取出从多到少的各个元素
 # for k, v in obj.items():
 #     print(k, v)  # 取字典键与值
 # import collections
 # # 有序字典
 # dic = collections.OrderedDict()
 # dic['k1'] = 'v1'
 # dic['k2'] = 'v2'
 # dic['k3'] = 'v3'
 # print(dic)
 # dic.popitem()  # 后进先出
 # print(dic)
 # dic.pop('k2')
 # print(dic)
 # help(collections.OrderedDict())
 # 内部用列表来维护有序字典
 # dic = {"k1": []}
 # dic["k1"].append("alex")
 # import collections
 # dic = collections.defaultdict(list)  # 设置字典默认值为空列表
 # dic["k1"].append("alex")
 # print(dic)

 # 可命名元祖 意思是 对元祖的元素命名 以后可以直接调名字
 # import collections
 # mytupleclass = collections.namedtuple('mytupleclass', ['x', 'y', 'z'])  # 创建类等同于 defaultdict
 # print(help(mytupleclass))
 # obj = mytupleclass(11, 22, 33)
 # print(obj.x)
 # print(obj.y)
 # print(obj.z)
 # #  主要用于坐标

 # 队列 分双向队列与单向队列
 # import collections
 # d = collections.deque()  # 创建双向队列
 # d.append("1")
 # d.append("10")
 # d.append("1")
 # d.append("10")
 # r = d.count("1")
 # # print(r)
 # d.extend(["yy", "uu",   "ii"])
 # d.appendleft("ad")
 # d.appendleft("12")
 # d.extendleft(["adf", "1111", "222"])
 # print(d)
 # #print(help(d))

 # 单向队列FIFO
 # 生产者消费者模型
 # import queue
 # q = queue.Queue()  # 创建单向队列
 # # print(help(q))
 # q.put('123')
 # q.put("678")
 # print(q.qsize())  # 获取队列大小
 # print(q.get())  # 获取队列值

课上作业：

 #!/usr/bin/env python3.5
 # -*-coding:utf8-*-
 # 数据库中原有
 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、原来没有 －>〉新加的插入
 #2、原来有 －>〉更新
 #3、新的无，原来有 ＝>把原来的删除掉
 #需求
 #要更新的数据
 #要删除的数据
 #要添加的数据
 #交集、差集
 old = set(old_dict.keys())  # 将旧的字典创建集合
 new = set(new_dict.keys())  # 将新的字典创建集合
 # 交集：要更新的数据，即把原来的更新为最新的数据
 # 差集：原来的数据删除，新的数据进行添加
 # delete_set = old.difference(update_set)  # 差集，创建新对象，获取旧的字典里存在的且不在交集里面的，这种方式是通过循环去比较
 # add_set = new.difference(update_set)  # 差集，创建新对象，获取新的字典里存在的且不在交集里面的
 # 交集
 update_set = old.intersection(new)  # 取交集
 delete_set = old.symmetric_difference(update_set)  # 差集，创建新对象，获取旧的字典里存在的且不在交集里面的,对称差集
 add_set = new.symmetric_difference(update_set)  # 差集，创建新对象，获取新的字典里存在的且不在交集里面的，对称差集
 # print(update_set)  # 需要更新的
 # print(delete_set)  # 需要删除的
 # print(add_set)  # 需要增加的
 # 更新
 for i in update_set:
     b = new_dict.get(i)
     c = old_dict.get(i)
     if b == c:
         continue
     else:
         c.update(b)  # 将对应旧字典的数据进行更新
         # print(new_dict)
         # print(old_dict)
         # print(b)
         # print(c)
 # 删除
 for i in delete_set:
     old_dict.pop(i)  # 删除旧的不存在的字典数据
     # print(old_dict)
 # 添加
 for i in add_set:
     old_dict.update(new_dict)  # 将对应旧字典的数据进行更新

 print("new_dict:\n %s" % new_dict)
 print("old_dict:\n %s" % old_dict)

深浅拷贝：

 #!/usr/bin/env python3.5
 # -*-coding:utf8-*-
 import copy
 # copy.copy()  # 浅拷贝 只拷贝一层
 # copy.deepcopy()  # 深拷贝 有多层就拷贝多少份
 # ＝  # 赋值
 # a1 =12324
 # a3 = copy.copy(a1)
 # print(a1)
 # print(a3)
 # # 其它，元祖，列表，字典……
 # n1 = {"k1": "12", "k2": "2212", 'k3': ["112", ["adfa", "1231234"]]}
 # n2 = n1
 # print(id(n1))
 # print(id(n2))
 # n3 = copy.copy(n1)
 # n3 = copy.deepcopy(n1)
 # print(id(n1))
 # print(id(n3))
 # print(id(n1["k3"]))
 # print(id(n3["k3"]))
 # print(id(n1["k3"][1]))
 # print(id(n3["k3"][1]))
 # print(n1["k3"][1])
 # 监控模板 深浅拷贝
 #
 # dic = {
 #     "cpu": [80],
 #     "mem": [80],
 #     "disk": [80]
 # }
 # print("brefor:",dic)
 # new_dic = copy.deepcopy(dic)
 # new_dic['cpu'][0] = 50
 # print(new_dic)