字典与集合

字典的定义

• Python内置的数据结构之一，与列表一样是一个可变序列（可以增删改）
• 以键值对的方式存储数据，字典是一个无序的序列（第一个放进去的不一定在第一个位置，位置根据哈希函数计算得来，因此放在字典中的键必须是一个不可变序列，整数序列、字符串都是不可变序列）

字典的创建

• 最常用的方式：使用花括号

scores = {'张三':100,'李四':98,'王五':45}
print(scores) #{'张三':100,'李四':98,'王五':45}

• 使用内置函数dict()

student = dict(name='jack',age=20) #括号中的键只能是字符串
print(student) #{name:'jack',age:20}

• 空字典

d = {}
print(d) #{}

字典的常用操作

• 字典中值的获取
  

#[key]如果字典中不存在指定的key，抛出keyError异常
scores = {'张三':100,'李四':98,'王五':45}

#get(key)，如果字典中不存在指定的key，并不会抛出KeyError而是返回None
print(scores.get('赵六')) #None
#get(key,自定义的数据)，不存在则返回自定义的数据
print(scores.get('麻七','没有这个key')) #没有这个key

#setdefault(key),如果字典中不存在指定的key，并不会抛出KeyError而是返回None，并添加
print(scores.setdefault('张三')) #100
print(scores.setdefault('赵六')) #None
print(scores) #{'张三':100,'李四':98,'王五':45,赵六:None}
#setdefault(key,自定义的数据)，无则增，有则查
print(scores.setdefault('赵六'，85)) #85

• key的判断
  
• 字典元素的删除

scores = {'张三':100,'李四':98,'王五':45}
#pop
#print(scores.pop('张三')) #100
#print(scores) #{'李四': 98, '王五': 45}

#del
del scores['张三']
print(scores) #{'李四': 98, '王五': 45}

#clear
scores.clear() #清空
print(scores) #{}

#popitem
scores.popitem() #根据添加进去的元素顺序进行删除，后添加的先删

• 字典元素的修改与新增

scores['张三'] = 90
scores['Jack'] = 90

#update，可以更新key的值,如果不存在则添加键值对
scores.update({'王五':85,'赵六':60})
print(scores) #{'张三': 100, '李四': 98, '王五': 85, '赵六': 60}

• 获取字典视图的三个方法

scores = {'张三':100,'李四':98,'王五':45}

keys = scores.keys()
print(keys) #dict_keys(['张三', '李四', '王五'])
print(type(keys)) #<class 'dict_keys'>，也是可迭代对象，下同
print(list(keys)) #['张三', '李四', '王五']

values = scores.values()
print(values) #dict_values([100, 98, 45])
print(type(values)) #<class 'dict_values'>
print(list(values)) #[100, 98, 45]

items = scores.items()
print(items) #dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
print(type(items)) #<class 'dict_items'>
print(list(items)) #[('张三', 100), ('李四', 98), ('王五', 45)]

• 字典元素的遍历

scores = {'张三':100,'李四':98,'王五':45}
for key in scores:
    print(key) #输出键
for key in scores.keys():
    print(key) #输出键
    
for value in scores.values():
    print(value) #输出值
    
for item in scores.items():
	print(item) #输出键和值组成的元组
for key,value in scores.items():
    print(key,value) #输出键和值

字典的特点

• 字典中的所有元素都是一个key-value对，key不允许重复， value可以重复
• 字典中的元素是无序的
• 字典中的key必须是不可变对象
• 字典也可以根据需要动态地伸缩
• 字典会浪费较大的内存，是一种使用空间换时间的数据结构

字典生成式

• 内置函数zip():用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表

d = {item:price for item,price in zip(items,prices)}
print(d) #{'Fruits': 96, 'Books': 78, 'Others': 85}

集合的创建

• 集合每个值是唯一的，与列表、字典一样都属于可变类型的序列，并且也是无序的，是可迭代对象

s = {1,1,1,2,4,6,3,2,2}
print(s) #{1, 2, 3, 4, 6}
print(type(s)) #<class 'set'>

s = set(range(6))
print(s) #{0, 1, 2, 3, 4, 5}

s = set() #set()是空集合

集合的增删

#add，一次添中一个元素
s = {1,4,8,9}
s.add(2)
s.add(10)
s.add(5)
print(s) #{1, 2, 4, 5, 8, 9, 10}

#update，一次至少添中一个元素，括号里可以是列表或元组
s.update({2,3,5})
print(s) #{1, 2, 3, 4, 5, 8, 9, 10}
s.update([111,22])
print(s) #{1, 4, 8, 9, 111, 22}

#pop，一次只删除一个任意元素，无法指定参数
s.pop()
print(s) #{2, 3, 4, 5, 8, 9, 10}

#remove，一次删除一个指定元素，如果指定的元素不存在抛出KeyError
s.remove(8)
print(s) #{2, 3, 4, 5, 9, 10}

#discard，一次删除一个指定元素，如果指定的元素不存在不抛异常
s.discard(100)
print(s) #{2, 3, 4, 5, 9, 10}

#clear，清空集合
s.clear()
print(s) #set()

集合的运算

#原集合不发生变化
s1 = {1,2,3}
s2 = {2,4,5}

print(s1.intersection(s2)) #交集，{2}
print(s1 & s2) #交集，{2}

print(s1.union(s2)) #并集，{1, 2, 3, 4, 5}
print(s1 | s2) #并集，{1, 2, 3, 4, 5}

print(s1.difference(s2)) #{1, 3}，指的是被减集合减去两个集合中相同的元素
print(s1 - s2) #{1, 3}，指的是被减集合减去两个集合中相同的元素
print(s2 - s1) #{4, 5}

print(s1.symmetric_difference(s2)) #{1,3,4,5}，对称差集
print(s1 ^ s2) #{1,3,4,5}

集合的判断

#集合元素的判断操作：in或not in
#两个集合是否相等，可以使用运算符==或!=进行判断
s1 = {1,2,3}
s2 = {1,2,3,5}
print(s1.isdisjoint(s2)) #False，有交集
print(s1.issubset(s2)) #True，s1是s2的子集
print(s1.issuperset(s2)) #False，s1是s2的超集

集合生成式

s = {i for i in range(1,11)}
print(s) #{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}