Python字典（定义、访问、增、删、改、查）

1.定义

键值对，key-value，键必须唯一且为不可变类型

（1）类型

# d={[0,1]:2}  #报错：TypeError: unhashable type: 'list'
d1={(0,1):2}
# d={(0,1,[2]):2}  #报错：TypeError: unhashable type: 'list'
d2={"s":0,1:1}
# d={d1:2,{1,2,3}:3}   TypeError: unhashable type: 'dict'
#字符串、数字、不含可变类型的元组可以，可变类型：列表、字典、集合不行

字符串、数字、不含可变类型的元组可以，可变类型：列表、字典、集合不行

（2）唯一性

d={1:10,1:20,"s":30,"s":40}
print(d[1],d["s"])    #定义时可以重复，不报错，但相当于覆盖更新
print(d)

20 40
{1: 20, 's': 40}

定义时可以重复，不报错，但相当于覆盖更新

（3）由其它数据类型转化

a=[0,1,2,3,4,5]
b=[00,11,22,33,44,55]
c=[[0,00],[1,11],[2,22],[3,33],[4,44],[5,55]]
print(dict(zip(a,b)),dict(c))

{0: 0, 1: 11, 2: 22, 3: 33, 4: 44, 5: 55} {0: 0, 1: 11, 2: 22, 3: 33, 4: 44, 5: 55}

2.访问

（1）字典名[键名] 直接访问，但是访问了不存在的键会直接报错

（2）get方法

①访问了不存在的键至少不报错

②默认返回值为None，也可以手动设置

d={1:20,"s":30}
#1
print(d["s"])
# print(d["h"])  #KeyError: 'h'

#2
print(d.get("s", "404"))
print(d.get("h"))
print(d.get("h", "404"))

30
30
None
404

3.增

d={1:20,"s":30}
d["h"]=40
print(d)

{1: 20, 's': 30, 'h': 40}

4.删

（1）del 字典名[键名]  #删除键值对

        del 字典名  #删除整个字典

（2）clear方法  #清空

d={1:20,"s":30}
# del d["h"]  #KeyError: 'h'没找到会报错
d.clear()
print(d)

{}

5.改

6.查

（1）方法遍历

操作	方法	结果形式
获取所有键	keys（）	dict_keys，可转为列表
获取所有值	values（）	dict_values，可转为列表
获取所有项	items（）	dict_items，可转为列表（元素为元组）

（2）多变量填充赋值

for   keys，values    in     列表名.items（）：

就像用枚举函数获得循环时的下标一样

这应该是Python的一个特性，多变量赋值，MATLAB里也有

所以Python函数中可以有多返回值

d = {1: 20, "s": 30}
print(d.keys(), type(d.keys()), list(d.keys()), sep="\t")
print(d.values(), type(d.values()), list(d.values()), sep="\t")
print(d.items(), type(d.items()), list(d.items()), sep="\t")
a, b = d.items()
print(a, b)
for k, v in d.items():
    print(k,v)

dict_keys([1, 's'])    <class 'dict_keys'>    [1, 's']
dict_values([20, 30])    <class 'dict_values'>    [20, 30]
dict_items([(1, 20), ('s', 30)])    <class 'dict_items'>    [(1, 20), ('s', 30)]
(1, 20) ('s', 30)
1 20
s 30

7.其它

d = {1: 20, "s": 30}
print(list(d))

[1, 's']

直接转换，只保留了键