1字典: dict 无序可变序列

字典是一个可变，无序的容器 ，字典内的元素都是键值对，每一个值（value）都对应一个键（key），标志性符号是花括号{}和冒号

1.1 创建

1.1.1 用{ }创建字典

dict1={'韩梅梅': 80,'李雷': 86 ,'张三': 77 }
dict1
#out：{'韩梅梅': 80, '李雷': 86, '张三': 77}

#传入不同类型的值
dict1={'韩梅梅': 80,'李雷': 86 ,'张三': [77,45,56] }
dict1
#out:{'韩梅梅': 80, '李雷': 86, '张三': [77, 45, 56]}

#创建空字典
dict1 = {}
dict1
out: {}

1.1.2 用dict创建字典

dict2 = dict(韩梅梅= 80, 李雷= 86, 张三= 77)
dict2
#out: {'韩梅梅': 80, '李雷': 86, '张三': 77}

#可以使用元组或者列表，将一对包起来
dict2 = dict([('韩梅梅',80), ('李雷',86),('张三',79)])
dict2
#out: {'韩梅梅': 80, '李雷': 86, '张三': 79}

#创建空字典
dict2 = dict()
dict2 
out: {}

1.1.3 用zip创建字典

name = ['韩梅梅', '李雷', '张三']
score = [80, 86, 79]
dict3 = dict(zip(name,score))
dict3 
#out: {'韩梅梅': 80, '李雷': 86, '张三': 79}

1.1.4 用fromkeys创建字典

#创建值相同的字典
dict4 = dict.fromkeys(['韩梅梅', '李雷', '张三'], 99)
dict4
#out: {'韩梅梅': 99, '李雷': 99, '张三': 99}

#创建值为空的字典
dict4 = dict.fromkeys(['韩梅梅', '李雷', '张三'])
dict4
#out: {'韩梅梅': None, '李雷': None, '张三': None}

注意：

• 必须是不可变的数据类型才可以做字典的键，如果是包含列表的元组也不能做键。

#元组是不可变类型元组可以做key,但是列表不可以
dict1={('王明','韩梅梅'): 80,'李雷': 86 ,'张三': 79 }
dict1

• 字典的键不可以出现重复值（键必须是唯一的），值可以重复，可以使复合类型。
  如果键的名字有重复，不会报错，保留后面的一个键值对
  

1.2 查询

1.2.1 通过键访问字典的值

1.2.1.1 直接取键 dict[ ]

dict2 = dict([['韩梅梅',80], ['李雷',86],['张三',79]])
dict2['韩梅梅']
#out: 80

1.2.1.2 get()

dict2 = dict([['韩梅梅',80], ['李雷',86],['张三',79]])
dict2.get('韩梅梅')
#out: 80

dict2 = dict([['韩梅梅',80], ['李雷',86],['张三',79]])
#若字典中不存在该键，不会报错，输出为空；
#get中可以传入两个参数，若字典中存在该键，则输出该键所对应的值，否则输出设定的输出内容。
dict2.get('韩梅梅','不存在')
#out: 80

dict2 = dict([['韩梅梅',80], ['李雷',86],['张三',79]])
dict2.get('王梅','不存在')
#out: 不存在

1.2.2 查看字典的键和值

1.2.2.1 返回所有的键 dict.keys()

dict2 = dict([['韩梅梅',80], ['李雷',86],['张三',79]])
dict2.keys()
#out: dict_keys(['韩梅梅', '李雷', '张三'])

1.2.2.2 返回所有的值 dict.values()

dict2 = dict([['韩梅梅',80], ['李雷',86],['张三',79]])
dict2.values()
#out: dict_values([80, 86, 79])

1.2.3 返回所有键值对 dict.items()

#dict.items()辅助实现字典和其他数据类型之间的转换
dict2 = dict([['韩梅梅',80], ['李雷',86],['张三',79]])
dict2.items()
#out: dict_items([('韩梅梅', 80), ('李雷', 86), ('张三', 79)])

1.2.4 判断键是否存在 in

dict1={'韩梅梅': 80, '李雷': 86, '张三': 77, '王五': 90, '王梅': 88}
'韩梅梅' in dict1  #查找字典里有没有某个值
#out: True 

1.3 增加

1.3.1 dict1[’ ']

dict1={'韩梅梅': 80, '李雷': 86, '张三': 77, '王五': 90}
#键不存在，增加一个元素
dict1['王梅'] = 88
dict1
#out: {'韩梅梅': 80, '李雷': 86, '张三': 77, '王五': 90, '王梅': 88}

1.3.2 dict.setdefault()

dict1={'韩梅梅': 80, '李雷': 96, '张三': 77, '王五': 90}
dict1.setdefault('李红',100)
dict1
#out: {'韩梅梅': 80, '李雷': 96, '张三': 77, '王五': 90, '李红': 100}

1.4 修改

1.4.1 通过键修改字典的值

dict1={'韩梅梅': 80, '李雷': 86, '张三': 77, '王五': 90}
#键存在，修改对应的值
dict1['韩梅梅'] = 88
dict1
#out: {'韩梅梅': 88, '李雷': 86, '张三': 77, '王五': 90}

1.4.2 通过一个字典修改另一个字典中的值

dict1={'韩梅梅': 80, '李雷': 86, '张三': 77}
dict2={'李雷': 96, '张三': 77, '王五': 90}
dict1.update(dict2)
dict1
#out: {'韩梅梅': 80, '李雷': 96, '张三': 77, '王五': 90}

1.5 删除

1.5.1 del dict[‘’]

#del  删除字典某键的键值对 
dict1={'韩梅梅': 80, '李雷': 86, '张三': 77, '王五': 90, '王梅': 88}
del dict1['韩梅梅']
dict1
#out: {'李雷': 86, '张三': 77, '王五': 90, '王梅': 88}

1.5.2 pop和popitem

pop和popitem 会抛出的元素，也就是取出所对应的值，然后在原字典删除该键值对

dict1={'韩梅梅': 80, '李雷': 86, '张三': 77, '王五': 90, '王梅': 88}
dict1.pop('韩梅梅')
#out: 80
dict1
#out: {'李雷': 86, '张三': 77, '王五': 90, '王梅': 88}

popitem删除最后一个键值对

dict1={'韩梅梅': 80, '李雷': 86, '张三': 77, '王五': 90, '王梅': 88}
dict1.popitem()
#out: ('王梅', 88)

1.5.3 clear 清空字典

1.5.4 del 删除字典

1.6 应用 统计字符串出现次数

s = 'absdcdaa'
d = {}
for i in s:
    d[i] = d.get(i,0)+1
d
#out: {'a': 3, 'b': 1, 's': 1, 'd': 2, 'c': 1}

2 集合: set 无序可变序列

集合常用来对其他数据类型进行去重

2.1 创建

集合是一种无序的可变的容器,对应数学中的集合,标志性符号是花括号{}
集合与字典类似,集合中的元素被看做的字典中的键(里面的元素需要是不可变的数据类型),集合里面没有重复值

2.1.1 用{} 创建

set1 = {1,2,'a','b'}
set1
#out: {1, 2, 'a', 'b'}

type(set1)
#out: set

2.1.1 用set( )创建

set2 = set([1,2,'a','b'])  #或者set2 = set((1,2,'a','b'))
set2
#out: {1, 2, 'a', 'b'}

2.2 查询 in

2.3 修改 set1.update(set2)

2.4 增加 add

2.5 删除

2.5.1 pop随机删除

2.5.2 按照元素值删除

2.5.3 清空 clear

2.6 专属操作 求并集,交集,差集,子集判断,等于和不等于

2.7 应用 其他数据类型进行去重