十一.字典

1.什么是字典

·python内置的数据结构之一，与列表一样是一个可变的序列

·以键值对的方式存储数据，字典是一个无序的序列

2.字典的原理及特点

·Python中的字典是根据key查找value所在的位置

·字典中的所有元素都是一个 key-value 对，key不允许重复，value可以重复

·字典中的元素是无序的

·字典中的key必须是不可变对象

·字典也可以根据需要动态的伸缩

·字典会浪费较大的内存，是一种使用空间换时间的数据结构

3.字典的创建

·常用方式：使用花括号

字典名={key:value,key:value}

score={'张三':80,'李四':90,'王五':70}
print(score)

打印：
{'张三': 80, '李四': 90, '王五': 70}

·使用内置函数dict()

dict(key=value,key=value) #key值必须为字符串，且不加引号

score = dict(张三=80,李四=90,王五=60)
print(score)

打印：
{'张三': 80, '李四': 90, '王五': 60}

---

4.字典元素的获取

1. [ ]：score['张三']
2. get()方法：score.get('张三')

1.
score = dict(张三=80,李四=90,王五=60)
value=score['张三']
print(value)

打印：
80


----------------------------------------


2.
score = dict(张三=80,李四=90,王五=60)
value = score.get('李四')
print(value)

打印：
90

·[]取值与使用get()取值的区别

1. []如果字典中不存在指定的key，抛出keyError异常
2. get()方法取值，如果字典中不存在指定的key，并不会抛出keyError而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回

5.key的判断

·in：指定的key在字典中存在返回True：'张三' in 字典名

·not in ：指定的key在字典中不存在返回True：'张三' not in 字典名

score = dict(张三=80,李四=90,王五=60)
print('张三' in score)
print('张三' not in score)


打印：
True
False

6.字典元素的删除

·del

1. del 字典名：删除整个字典
2. del 字典名[key]：删除字典中指定的key值

score = dict(张三=80,李四=90,王五=60)
del score
print(score)

打印：
NameError: name 'score' is not defined


-----------------------------------------------

score = dict(张三=80,李四=90,王五=60)
del score['张三']
print(score)

打印：
{'李四': 90, '王五': 60}

2.clear()：清空字典

score = dict(张三=80,李四=90,王五=60)
score.clear()
print(score)


打印：
{}

7.字典元素的增加

score = dict(张三=80,李四=90,王五=60)
score['陈柳']=100
print(score)

打印:
{'张三': 80, '李四': 90, '王五': 60, '陈柳': 100}

8.字典元素的修改

score = dict(张三=80,李四=90,王五=60)
score['张三']=100
print(score)

打印：
{'张三': 100, '李四': 90, '王五': 60}

9.获取字典视图的三个方法

·keys()：获取字典中所有的key        #可以直接转换成列表存储起来

score = dict(张三=80,李四=90,王五=60)
key=score.keys()
print(key)
print(type(key))
print(list(key))

打印：
dict_keys(['张三', '李四', '王五'])
<class 'dict_keys'>
['张三', '李四', '王五']

·values()：获取字典中所以的value  #可以直接转换成列表存储起来

score = dict(张三=80,李四=90,王五=60)
value=score.values()
print(value)
print(type(value))
print(list(value))


打印：
dict_values([80, 90, 60])
<class 'dict_values'>
[80, 90, 60]

·items()：获取字典中所有key，value对

score = dict(张三=80,李四=90,王五=60)
items = score.items()
print(items)
print(type(items))
print(list(items)) #转换之后的列表是由元组组成的

打印：
dict_items([('张三', 80), ('李四', 90), ('王五', 60)]) 
<class 'dict_items'>
[('张三', 80), ('李四', 90), ('王五', 60)]

10.字典元素的遍历

·遍历出的是key值

for 自定义函数 in 字典:

        print(自定义函数)

score = dict(张三=80,李四=90,王五=60)
for key in score:
    print(key,score[key],score.get(key))

打印：
张三 80 80
李四 90 90
王五 60 60

11.字典生成式

·内置函数zip()

• 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表 
• 也可以打印成字典

1.列表
key=['张三','李四','王五','小明']
value=[100,120,150,180]
lst=zip(key,value)
print(lst)
print(list(lst))

打印：
<zip object at 0x0000015520BCCFC0>
[('张三', 100), ('李四', 120), ('王五', 150), ('小明', 180)]

---------------------

2.字典
key=['张三','李四','王五','小明']
value=[100,120,150,180]
lst=zip(key,value)
print(lst)
print(dict(lst))

打印：
<zip object at 0x0000029A9961D000>
{'张三': 100, '李四': 120, '王五': 150, '小明': 180}

1.列表
key=['张三','李四','王五','小明']
value=[100,120,150,180]
zidian = {a for a in zip(key,value)}
print(zidian)

打印：
{('王五', 150), ('张三', 100), ('小明', 180), ('李四', 120)}

------------------------------------

2.字典
key=['张三','李四','王五','小明']
value=[100,120,150,180]
zidian = {a:b for a,b in zip(key,value)}
print(zidian)

打印：
{'张三': 100, '李四': 120, '王五': 150, '小明': 180}

练习：

1.将2个列表以key和value的方式录入到字典中 #可以用zip()录入

lst=['张三','李四','王五','小明']
lst2=[100,120,150,180,12,18]
score_new={}
for key in lst:
    key_id=lst.index(key)
    for value in lst2:
        value_id=lst2.index(value)
        if key_id==value_id:
            score_new[key] = value

print(score_new)


打印：
{'张三': 100, '李四': 120, '王五': 150, '小明': 180}