第五章 Python数据容器 06-dict容器

dict（字典、映射）

类似于新华字典的结构，里面的数据放的是成对的数据，这个数据叫做键值对

这个键类似于新华字典中要查的词，值就类似于这个词对应的解释

在新华字典中需要先定位到字，才能查到相应的解释

Python中字典的结构是一样的，是根据键定位到值的。所以对键是有要求的：

1. 不允许重复
2. 不允许发生变化 【键对应的类型必须是不可变的 --整数 字符串 元组】

字典的数据结构本质是无序的可变序列 【在Python3.6的时候做了一个优化，字典的从内存角度来说比3.5及其之前的降低25%, 展示的时候跟书写的时候 顺序是一致的】

无序的数据就没有编号【索引】这一说。字典中定位数据就通过键来定位的，字典的键就等同于有序数据的索引

1. 字典的定义

1. 通过{}字面量法来定义，存在键值对的时候，结构是 {key: value, key1: value1}
2. 通过dict()来进行构造的

# 1. 定义一个空字典
d0 = {}
print(type(d0))  # <class 'dict'>

d1 = {'语文': 77, '数学': 87, '英语': 85}
print(d1)  # {'语文': 77, '数学': 87, '英语': 85}

# 比列表的好处在于可以清晰的看出数据所表达的意义 [77， 87, 85]

# 2. dict构造
# 空字典
d2 = dict()
print(d2)  # {}

# 将其他序列转化成字典的时候 对这个序列有要求
'''
字典比较特殊 呈现一个数据的话需要两个值来配合 一个做键 一个做值
因此把其他序列转换成字典的话 这个序列得是二维的， 内层序列得有两个元素
[['语文', 77], ['数学', 78]]
'''
d3 = dict([('语文', 77), ('数学', 78), ('英语', 87)])
print(d3)  # {'语文': 77, '数学': 78}

d4 = dict(enumerate('abcdef'))  # enumerate('abcdef') 对序列重组  组合二维的  内层是二元组 (索引, 元素)
print(d4)  # {0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f'}

# 另外一种构造方式
# dict(变量名=数据值, 变量名1=数据值1)  # 把变量名转化为字符串类型  作为字典的键
d5 = dict(a=97, b=98, c=99, d=100)
print(d5)  # {'a': 97, 'b': 98, 'c': 99, 'd': 100}

2. 字典的运算符

scores = {'语文': 78, '数学': 97, '英语': 82, '政治': 77}

print('语文' in scores)  # True

print(77 in scores)  # False

print('历史' not in scores)  # True


scores1 = {'语文': 78, '数学': 97}
print(id(scores))
print(scores is scores1)
print(not scores is scores1)

# print(scores > scores1)
# TypeError: '>' not supported between instances of 'dict' and 'dict'

3. 字典的操作

scores = {'语文': 78, '数学': 97, '英语': 82, '政治': 77}

# 1. 添加数据
# 添加新的键值对
'''
字典数据[键] = 值
	键不存在  会将其作为新的键值对添加在字典中
	键若存在  将字典中该键对应的值进行修改
'''
scores['历史'] = 65
print(scores)  # {'语文': 78, '数学': 97, '英语': 82, '政治': 77, '历史': 65}

scores['英语'] = 28
print(scores)  # {'语文': 78, '数学': 97, '英语': 28, '政治': 77, '历史': 65}

'''
字典数据.setdefault(键, 值)
	键不存在  添加新的键值对
	键若存在  不做任何反应
'''
scores.setdefault('化学', 78)
print(scores)
# {'语文': 78, '数学': 97, '英语': 28, '政治': 77, '历史': 65, '化学': 78}
scores.setdefault('数学', 79)
print(scores)  # {'语文': 78, '数学': 97, '英语': 28, '政治': 77, '历史': 65, '化学': 78}

# 合并其他序列的元素
scores.update({'生物': 77, '地理': 56})
print(scores)
# {'语文': 78, '数学': 97, '英语': 28, '政治': 77, '历史': 65, '化学': 78, '生物': 77, '地理': 56}

# 序列得是二维的
scores.update([('物理', 87), ('体育', 98)])
print(scores)
# {'语文': 78, '数学': 97, '英语': 28, '政治': 77, '历史': 65, '化学': 78, '生物': 77, '地理': 56, '物理': 87, '体育': 98}


# 2. 删除数据
# 【根据键 把整个键值对就都删除】
'''
del 字典数据[键]
'''
del scores['历史']
print(scores)
# {'语文': 78, '数学': 97, '英语': 28, '政治': 77, '化学': 78, '生物': 77, '地理': 56, '物理': 87, '体育': 98}

'''
字典数据.pop(键)
	和del的区别是  这个删完之后可以获取到键对应的值
'''
value = scores.pop('生物')
print(scores)  # {'语文': 78, '数学': 97, '英语': 28, '政治': 77, '化学': 78, '地理': 56, '物理': 87, '体育': 98}
print(value)  # 77

'''
清空字典
'''
# scores.clear()
# print(scores)  # {}


# 3. 获取相关数据信息
# 根据键获取值
'''
变量名 = 字典数据[键]
	键若存在 获取键对应的数据值
	键若不存在 就报错
'''
value = scores['语文']
print(value)  # 78

# value = scores['生物']  # KeyError: '生物'

'''
变量名 = 字典数据.get(键)
	键若存在 获取键对应的数据值
	键若不存在 不会报错 返回的是None
'''
value = scores.get('语文')
print(value)  # 78

value = scores.get('生物')
print(value)  # None

# 当键不存在的时候 可以自定义相应的数据   键存在 还是把键对应的值返回
value = scores.get('语文', 0)
print(value)  # 78

value = scores.get('生物', 0)
print(value)  # 0

# 获取所有的键
all_keys = scores.keys()
print(all_keys)  # dict_keys(['语文', '数学', '英语', '政治', '化学', '地理', '物理', '体育'])  一维数据

# 获取所有的值
all_values = scores.values()
print(all_values)  # dict_values([78, 97, 28, 77, 78, 56, 87, 98])  一维数据

# 获取所有的键值组合
all_items = scores.items()
print(all_items)
# dict_items([('语文', 78), ('数学', 97), ('英语', 28), ('政治', 77), ('化学', 78), ('地理', 56), ('物理', 87), ('体育', 98)])
# 二维数据 内层是二元组 (键, 值)


# 4.其他的操作
# 拷贝字典
new_scores = scores.copy()
print(new_scores)

# 构造键序列构造字典[值默认为None]    dict.fromkeys(键)
d0 = dict.fromkeys('abcdefg')
print(d0)  # {'a': None, 'b': None, 'c': None, 'd': None, 'e': None, 'f': None, 'g': None}

# dict.fromkeys(键序列, 值)  # 给键设置值
d1 = dict.fromkeys('abcdefg', 0)
print(d1)
# {'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 0, 'g': 0}

4. 字典的遍历

scores = {'语文': 78, '数学': 97, '英语': 28, '政治': 77, '历史': 65, '化学': 78, '生物': 77, '地理': 56}

# 直接遍历
for key in scores:
	print(key)
'''
语文
数学
英语
政治
历史
化学
生物
地理
'''

print('=' * 20)

# 等同于遍历  字典.keys()
for k in scores.keys():
	print(k, scores[k])
print('=' * 20)

# 直接遍历字典的所有的值
for v in scores.values():
	print(v)
'''
78
97
28
77
65
78
77
56
'''
print('=' * 20)

# *******  对字典进行操作 既要获取键 又要获取值  对字典的所有条目进行操作  字典.items()
for item in scores.items():
	print(item, item[0], item[1])  # 元组类型的数据
'''
('语文', 78)
('数学', 97)
('英语', 28)
('政治', 77)
('历史', 65)
('化学', 78)
('生物', 77)
('地理', 56)
'''
print('=' * 20)
# d0 = dict(scores.items())
# print(d0)

for k, v in scores.items():
	print(k, v)
# 语文 78
# 数学 97
# 英语 28
# 政治 77
# 历史 65
# 化学 78
# 生物 77
# 地理 56

5. 字典推导式

类似于列表推导式

格式 {键的变量: 值的变量 for 键的变量, 值的变量 in 字典.items() if 判断条件}

scores = {'语文': 88, '数学': 97, '英语': 28, '政治': 77, '历史': 65, '化学': 78, '生物': 77, '地理': 56}

# 获取成绩在80及其以上的 科目与成绩信息
'''
思路：
	1. 定以一个空字典 用来存储获取的信息
	2. 遍历获取所有的键值信息
	3. 判断操作 将符合要求的放在存储信息的字典中
'''
scores_80 = {}
# 遍历
for k, v in scores.items():
	if v >= 80:
		scores_80[k] = v
print(scores_80)  # {'语文': 88, '数学': 97}

print({k: v for k, v in scores.items() if v >= 80})

# 成绩在60到80之间的 科目及其成绩信息
scores_6080 = {}
print({k: v for k, v in scores.items() if 60 <= v <= 80})

总结:

字典：可以容纳多个数据、可以容纳不同类型的数据、每一份数据是KeyValue键值对、可以通过Key获取到Value，Key不可重复（重复会覆盖）、不支持下标索引、可以修改（增加或删除更新元素等）、支持for循环，不支持while循环