03_set集合

set，无序，不重复序列

列表特点：有序，数据可重复

li = [11,222,11,222,]
print(li)
# 输出结果
# [11, 222, 11, 222]

a.创建　

集合：se = {"123", "456"} #每个值都是一个元素
字典：dic = {"k1":123} #键值对，字典的元素
列表：li = []  #python内部调用list()方法

初识构造方法
list((11,22,33,44))
原理：构造方法，类后加()，会自动执行这个类的__init__方法
自动执行list __init__ （构造方法）
内部执行for循环，循环元组里的所有元素（11，2，33，4），转换成列表[11,22,33,4]

创建集合

s1 = {11,22}
s2 = set() #创建空集合
s3 = set([11,22,33,4])

列表转换集合

li = [11,22,11,22]
s1 = set(li)
print(s1,type(s1))
# 输出结果：
{11, 22} <class ‘set‘>

操作集合

set()  #创建空集合
add()  #添加元素
clear()  #清除内容
copy()  #浅拷贝
difference()  #A中存在，B中不存在
difference_update()  #从当前集合中删除和B中相同的元素
discard()  #移除指定元素，不存在不报错
intersection()  #A,B的交集
intersection_update()  #取A,B的交集并更新到A中
isdisjoint()  #如果没有交集，返回True，否则返回False
issubset()  #是否是子集关系
pop()  #移除元素
remove()  #移除指定元素，不存在报错
symmetric_difference()  #对称差集
symmetric_difference_update()  #对称差集，并更新到A中
union()  #并集
update()  #更新

示例1：创建set()、添加add()、清除clear()

s0 = set()  #创建集合
print(s0,type(s0))
s0.add(11)  #添加元素
s0.add(22)
s0.add(33)
s0.add(11)  #重复数据
print(s0,type(s0))
s0.clear()
print(s0,type(s0))

# 输出结果：3个print
# set() <class ‘set‘>
# {33, 11, 22} <class ‘set‘>
# set() <class ‘set‘>

示例2：移除元素pop(),discard(),remove()

s0 = set([11,22,33,44,55,])
print(s0, type(s0))
# {33, 11, 44, 22, 55} <class ‘set‘>
s0.pop()  #删除元素
print(s0)
# {11, 44, 22, 55}
s0.discard(11)  #指定删除11(存在)
print(s0)
# {44, 22, 55}
s0.discard(66)  #指定删除66(不存在，不报错)
print(s0)
# {44, 22, 55}
s0.remove(55)  #指定删除55(存在)
print(s0)
# {44, 22}
s0.remove(77)  #指定删除77(不存在，报错)
# KeyError: 77
print(s0)

示例3：交集、差集、并集、对称差集、子集

s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.difference(s2)  #s1中有，s2中没有的
print(s3)
# {11}
s4 = s2.difference(s1)  #s2中有，s1中没有的
print(s4)
# {44}
s5 = s1.symmetric_difference(s2) #对称差集，s1中有，s2中没有的和s2中有，s1中没有的集合
print(s5)
# {11, 44}
s6 = s1.intersection(s2)  #s1与s2的交集
print(s6)
# {33, 22}
s7 = s1.isdisjoint(s2)  #判断s1与s2是否有交集，没有返回True，否则False
print(s7)
# False
s8 = s2.issubset(s1)  #判断s2是否是s1的子集
print(s8)
# False
s9 = s1.union(s2)  #s1与s2的并集
print(s9)
# {33, 22, 11, 44}

示例4：更新

s1 = {11, 22, 33, }
print(s1)
# {33, 11, 22}
s1.update({55, 66, 77, })
print(s1)
# {33, 66, 22, 55, 11, 77}
s1.update("tom")
print(s1)
# {‘m‘, 33, 66, 22, 55, ‘o‘, ‘t‘, 11, 77} #更新数据为字符串时，每个字符为一个元素

示例5：集合更新

# s1、s2为两个set集合
s1 = {11, 22, 33, }
s2 = {22, 33, 44, }

s1.difference_update(s2)  #集合s1中删除和集合s2中相同的元素
print(s1)
# {11}

s1.intersection_update(s2)  #取s1和s2的集合，结果更新到s1
print(s1)
# {33, 22}

s1.symmetric_difference_update(s2)  #取s1与s2的对称差集，并将结果更新到s1中
print(s1)
# {11, 44}

练习：寻找差异

# 数据库中原有
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 }
}

思考：

需要删除的：old_dict有，new_dict中没有的key

需要增加的：new_dict有，old_dict中没有的key

需要更新的：old_dict中有，new_dict中也有key，而且在new_dict中值是有变化的

# 数据库中原有
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‘:  "c1", ‘cpu_count‘: 2, ‘mem_capicity‘: 80 },
}

# 设置old_dict里的key为集合
old_keys_set = set(old_dict.keys())
# old_keys_set = set(old_keys)
print("old_keys_set:", old_keys_set, type(old_keys_set))

# 设置new_dict里的key为集合
new_keys_set = set(new_dict.keys())
print("new_keys_set:", new_keys_set, type(new_keys_set))

# 筛选需要删除的key
remove_keys_set = old_keys_set.difference(new_keys_set)
print("remove_keys_set:", remove_keys_set, type(remove_keys_set))

# 筛选需要增加的key
add_keys_set = new_keys_set.difference(old_keys_set)
print("add_keys_set:", add_keys_set,type(add_keys_set))

# old_keys_set删除要删除的key
old_keys_set.difference_update(remove_keys_set)
# print(old_keys_set)
# old_keys_set增加要更新的key
old_keys_set = old_keys_set.union(new_keys_set)
print("old_keys_set", old_keys_set)

# 输出结果
old_keys_set: {‘#2‘, ‘#1‘, ‘#3‘} <class ‘set‘>  #数据库中原有的key
new_keys_set: {‘#4‘, ‘#1‘, ‘#3‘} <class ‘set‘>  #新数据中的key
remove_keys_set: {‘#2‘} <class ‘set‘>  #数据库中需要删除的key
add_keys_set: {‘#4‘} <class ‘set‘>  #数据库中需要增加的key
old_keys_set {‘#4‘, ‘#3‘, ‘#1‘}  #最终的结果