一.引子
我们学了列表 ， 现在有个需求， 把你们公司每个员⼯的姓名、年龄、职务、⼯资存到列表⾥，你怎么存？
staff_list = [
["Alex",23,"CEO",66000],
["⿊姑娘",24,"⾏政",4000],
["佩奇",26,"讲师",40000],
# [xxx,xx,xx,xxx]
# [xxx,xx,xx,xxx]
# [xxx,xx,xx,xxx]
]如图为两层列表 这样存没问题，不过你要查⼀个⼈的⼯资的话， 是不是得把列表遍历⼀遍
for i in staff_list:
if i[0] == '⿊姑娘':
print(i)
break
但假如你公司有 2 万⼈，如果你要找的⿊姑娘正好在列表末尾，那意味着你要遍历 2 万次，才能找到这个信息。列 表越⼤，查找速度越慢。好了，现在福⾳来了， 接下来学要的字典可以 查询数据⼜快、操作⼜⽅便，是⽇后开发中必备神器
staff_list = {
"alex": [23, "CEO", 66000],
"⿊姑娘": [24, "⾏政", 4000],
# ....
}
print(staff_list["⿊姑娘"]) # 即可取出来二.字典的定义
｛ key1:value1, key2:value2 ｝
info = {
"name":"Alex Li",
"age" : 26,
"name":"Jacke"
}
key -> valuekey：value
dict 特性
1. key-value 结构
2. key 必须为不可变数据类型（字符串、数字、元组）， (hashtable)
3. key 必须唯⼀ ,(hashtable)
4. ⼀个 key 对应的 value 可存放任意数据类型，可修改、可以不唯⼀
5. 可嵌套，即 value 也可是 dict
py3.7 之前是⽆序的 , 3.7 开始变成有序的了， ordered_dict
7. 查询速度快，且不受 dict 的⼤⼩影响，⾄于为何快？我们学完 hash 再解释。 =O(1)
三.dict⽤法
创立
# ⽅法1
>>> info2 = {
"name":"BlackGirl",
"age":23
}
# ⽅法2
>>> info = dict(name="alex",age=22)
>>> info
{'name': 'alex', 'age': 22}
增
>>> staff_list
{'alex': [23, 'CEO', 66000], '⿊姑娘': [24, '⾏政', 4000]}
>>>
>>> staff_list["XiaoYun"] = [26,"前端开发",19000] # 新增
>>> staff_list
{'alex': [23, 'CEO', 66000], '⿊姑娘': [24, '⾏政', 4000], 'XiaoYun': [26, '前端开发',
19000]}
检查式新增
向 dict ⾥新增⼀个 key,val 值 ，如果这个 key 不存中，如果这个 key 已存在，就返回已存在的 key 对应的 value
>>> staff_list.setdefault("Celina",[22,"Accountant",12000]) # 新增⼀个k,v值
[22, 'Accountant', 12000]
>>> staff_list
{'alex': [23, 'CEO', 66000], '⿊姑娘': [24, '⾏政', 4000], 'XiaoYun': [26, '前端开发',
19000], 'Celina': [22, 'Accountant', 12000]}
>>> staff_list.setdefault("XiaoYun",[22,"Accountant",12000]) # 新增⼀个，但是XiaoYun已经
存在了，所以返回原来的值
[26, '前端开发', 19000]
改
普通修改
>>> names["xiao_yun"] = [23,"前台", 6000]
>>> names["xiao_yun"][2] = 4500 # 改values列表⾥的值
>>> names
{'xiao_yun': [23, '前台', 4500], 'Celina': [23, 'UE', 9999]}
>>>
合并修改
把另外⼀个 dict 合并进来
staff_list = {
"alex": [23, "CEO", 66000],
"⿊姑娘": [24, "⾏政", 4000],
"xiao_yun":[22,"Student",2000],
}
names = {
"xiao_yun":[25,"前端开发",12000],
"Celina":[23,"UE", 9999]
}
staff_list.update(names) # 把names的每个k,v赋值给staff_list, 相当于如下操作
# for k in names:
# staff_list[k] = names[k]
print(staff_list)
输出： {'alex': [23, 'CEO', 66000], ' ⿊姑娘 ': [24, ' ⾏政 ', 4000], 'xiao_yun': [22, 'Student', 2000], 'Celina': [23, 'UE', 9999]}
查
>>> names
{'xiao_yun': [23, '前台', 4500], 'Celina': [23, 'UE', 9999]}
# get ⽅法
>>> names.get("Jack") # 如果没有，返回None
>>> names.get("xiao_yun") # 如果有，则返回值
[23, '前台', 4500]
# 直取
>>> names["Jack"] # 如果没有，报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'Jack'
>>> names["Celina"]
[23, 'UE', 9999]
判断是否在 dict ⾥有指定的 key
>>> names
{'xiao_yun': [23, '前台', 4500], 'Celina': [23, 'UE', 9999]}
>>>
>>> "Alex" in names
False
删
循环
输出
dic.keys() #返回⼀个包含字典所有KEY的列表；
dic.values() #返回⼀个包含字典所有value的列表；
dic.items() #返回⼀个包含所有（键，值）元组的列表；删
names.pop("alex") # 删除指定key
del names["black_girl"] # 删除指定key,同pop⽅法
names.popitem() # 以LIFO的⽅式删除⼀对值
names.clear() # 清空dict
循环
1、for k in dic.keys()
2、for k,v in dic.items()
3、for k in dic # 推荐⽤这种，效率速度最快
info = {
"name":"路⻜学城",
"mission": "帮⼀千万b粉⽩嫖学好编程",
"website": "https://luffycity.com"
}
for k in info:
print(k,info[k])输出
name 路⻜学城
mission 帮⼀千万b粉⽩嫖学好编程
website https://luffycity.com
特殊⽅法
fromkeys : 批量⽣成多个 k,v 的 dict
>>> n
['alex', 'jack', 'rain']
>>> dict.fromkeys(n, 0)
{'alex': 0, 'jack': 0, 'rain': 0}
Copy: 浅 copy , 同列表的 copy ⼀样
求⻓度
len(info) # len()⽅法可同时⽤于列表、字符串四.dict 为何查询速度快？
因为 dict 是基于 hashtable 实现的， hashtable 的原理导致你查询速度就是 O(1) ， 意思就是你即使有 1 亿个数据，查
询某个值也只需 1 次搞定 。。。。。
哈哈， 上边这句，对现在的你，肯定完全懵逼。 什么是 hashtable, 什么是 O(1)
忘记它吧，为师先⽤最简单的例⼦让你理解 :
看以下列表 nums, 让你⽤最快最⾼效的⽅式找出 100 这个数，你怎么找？
>>> nums
[125, 247, 53, 260, 33, 6, 132, 198, 151, 110, 95, 163, 116, 295, 289, 200, 142, 153,
126, 41, 294, 290, 31, 34, 241, 132, 191, 82, 246, 123, 19, 171, 37, 130, 139, 250,
53, 241, 84, 172, 14, 120, 138, 92, 294, 116, 269, 104, 278, 146, 12, 293, 135, 240,
289, 121, 295, 50, 60, 198, 10, 57, 248, 79, 169, 298, 292, 64, 298, 3, 9, 152, 268,
178, 0, 136, 165, 53, 146, 78, 270, 104, 116, 283, 177, 145, 142, 71, 176, 33, 235,
134, 188, 29, 39, 15, 136, 137, 16, 189]
1. 先排序
2. 再折半（ 2 分）算法查找
粗识 hashtable
hashtable( 散列表 ) ⽤了个更 nb 的⽅式 ， 直接把你的 key 通过 hash 函数算出来个数字， 然后扔在 hashtable 的某个 位置
你再去通过 dict.get("alex") 获取的时候，它只需要把 alex 再变成⼀个 hash 值，去找在这个表⾥的值 就可以了。
这样， ⽆论你的 dict 多⼤， 你查询速度都不会受影响 .
五.练习题
1. ⽣成⼀个包含 100 个 key 的字典，每个 value 的值不能⼀样
2. {‘k0’: 0, ‘k1’: 1, ‘k2’: 2, ‘k3’: 3, ‘k4’: 4, ‘k5’: 5, ‘k6’: 6, ‘k7’: 7, ‘k8’: 8, ‘k9’: 9} 请把这个 dict 中 key ⼤于 5 的值 value 打
印出来。
3. 把题2中value是偶数的统⼀改成-1
4. 把下⾯列表中的值进⾏分类 ，变成dict
Input : test_list = [4, 6, 6, 4, 2, 2, 4, 8, 5, 8]
Output : {4: [4, 4, 4], 6: [6, 6], 2: [2, 2], 8: [8, 8], 5: [5]}
需求 : 值⼀样的要分类存在⼀个key⾥
5. 把⼀段话⾥᯿复的单词去掉
Input : Python is great and Java is also great
Output : is also Java Python and great
1. 写程序输出 dict 中 values ⾥唯⼀的值
dic = {'gfg': [5, 6, 7, 8], 'best': [6, 12, 10, 8], 'is': [10, 11, 7, 5], 'for': [1,
2, 5]}
结果 : [1, 2, 5, 6, 7, 8, 10, 11, 12]
1. 把所有下表中同字⺟异序词找出来
arr = ['cat', 'dog', 'tac', 'god', 'act']
结果： [ ['cat','tac','act'],['god','dog']]
