字典，集合

一、字典
1、删除
（1）del

d = {'a':1,'b':2,'c':3}
# 使用del来删除字典中的key-value
del d['a']
del d['b']
del d['z']     # z不存在，报错
print (d)

(2)popitem

# 随机删除字典中的一个键值对，一般都会删除最后一个键值对
#   删除之后，它会将删除的key-value作为返回值返回
#   返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value
# 当使用popitem（）删除一个空字典时，会抛出异常KeyError: 'popitem(): dictionary is empty'

d = {'a':1,'b':2,'c':3}
d.popitem()
result = d.popitem
print ('result =',result)
print (d)

（3）pop

# pop(key[,default])
# 根据key删除字典中的key-value
# 会将被删除的value返回
d = {'a':1,'b':2,'c':3}
result = d.pop('d')
# 如果删除不存在的key，会抛出异常
#  如果指定了默认值，在删除不存在的key时，不会报错，而是直接返回默认值
result = d.pop('z')    #z不存在，报错
print ('result =',result)
print (d)

（4）clear()

# clear()用来清空字典
d = {'a':1,'b':2,'c':3}
result = d.clear()
print ('result =',result)
print (d)

2、copy（）—用来对字典进行浅复制

# 该方法对字典进行浅复制
# 复制以后的对象，和原对象是独立的，修改一个不会影响另一个
# 注意！浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
d = {'a':1,'b':2,'c':3}
d1 = d    # id相同，指向同一个对象
d2 = d.copy（）  # id不同，有两个对象
# d['a']=100   只改变d中的a,不改变d2中的a，但是d1中的a改变

d3 = {'a':{'name':'肖战','age':29},'b':2,'c':3}
d4 = d3.copy()
d4['a']['name'] = '小战'

print('d = ',d,id(d))
print('d1 = ',d1,id(d1))
print('d2 = ',d2,id(d2))
print('d3 = ',d3,id(d3))
print('d4 = ',d4,id(d4))

3、字典的遍历
（1）keys() —遍历键

# keys() 该方法会返回字典的所有key
#  该方法会返回一个序列，序列中保存有字典的所有的键
d = {'name':'肖战','age':29,'gender':'男'}

# 通过遍历keys()来获取所有的键
for k in d.keys() :
    print (k)
    print (d[k])

（2）values()

# values()
# 该方法会返回一个序列，序列中保存有字典的所有的值
d = {'name':'肖战','age':29,'gender':'男'}
for v in d.values() :
    print (v)

（3）items()

# items()
# 该方法会返回字典中所有的项
# 它会返回一个序列，序列中包含有双值子序列
# 双值分别是字典中的key和value
d = {'name':'肖战','age':29,'gender':'男'}
for k,v in d.items() :
print(k,'=',v)

二、集合 (set)
1、集合和列表非常相似
（1）不同点
①集合中只能存储不可变对象
②集合中存储的对象是无序（不是按照元素的插入顺序保存）
③集合中不能出现重复的元素
2、创建集合以及小知识点

# (1)使用{}创建集合
s = {10,2,4,1,3,9,6}
# s = {[1,2,3],[4,5,6]}   TypeError: unhashable type: 'list'   (可变对象)

# (2)使用set()函数创建集合
s = set()
# 可以通过set（）来将序列和字典转换为集合
s = set([1,2,3,4,5,1,1,2,3])
s = set('hello')
s = set({'a':1,'b':2,'c':3})   # 使用set()将字典转换为集合时，只会包含字典中的键

# 创建集合
s = {'a' ,'b' , 1 , 2 , 3}

# 使用in和not in来检查集合中的元素
print ('c' in s)

# 使用len()来获取集合中元素的数量
print (len(s))

# add()向集合中添加元素
s.add(10)

# update()将一个集合中的元素添加到当前集合中
#   update()可以传递序列或字典作为参数，字典只会使用键

s2 = set ('hello')
s.update(s2)
s.update((10,20,30,40))   # 可以传序列
s.update({100:'ab',200:'bc',300:'ef'})   # 可以传字典

# pop()随机删除并返回一个集合中的元素
s.pop()

# remove()删除集合中的指定元素
s.remove (100)

# clear()清空集合
s.clear()

# copy()对集合进行浅复制

print (s,type(s))

2、集合的运算

# 在对集合进行运算时，不会影响原来的集合，而是返回一个运算结果
# 创建两个集合
s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# (1) & 交集
result = s1 & s2    # {3,4,5}

# (2) | 并集
result = s1 | s2    # {1,2,3,4,5,6,7}

# (3) - 差集  指只存在s1集合中，s2集合中没有的
result = s1 - s2    # {1，2}  

# (4) ^ 异或集  只在一个集合中出现的元素
result = s1 ^ s2    #{1，2，6，7} 

# (5) <= 检查一个集合是否是另一个集合的子集
# 如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集,b集合是a集合超集
a = {1,2,3}
b = {1,2,3,4,5}
result = a <= b     #True
result = {1,2,3} <= {1,2,3}       # True
result = {1,2,3,4,5} <= {1,2,3}   # False

# (6) < 检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中的所有元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集
result = {1,2,3} < {1,2,3}        # False
result = {1,2,3} < {1,2,3，4，5}  # True

# (7) >= 检查一个集合是否是另一个的超集
# (8) > 检查一盒集合是否是另一个的真超集
print ('result = ',result)