一.引子
我们学了列表 , 现在有个需求, 把你们公司每个员⼯的姓名、年龄、职务、⼯资存到列表⾥,你怎么存?
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 -> value
key: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)
![](https://i-blog.csdnimg.cn/blog_migrate/bf757068e69687962d08e096f8f2ff77.png)
忘记它吧,为师先⽤最简单的例⼦让你理解
:
看以下列表
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
的某个 位置
![](https://i-blog.csdnimg.cn/blog_migrate/a5b1888be132ca84f0af3b87bb6e0ab3.png)
你再去通过
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']]