字典 dict¶

字典概述¶

字典是 Python 中唯一实现映射关系的内置类型。创建语法： x = {1:"1"} ，字典的键和值一一对应，序列中元素可以重复，但是字典键没有重复，如果出现重复旧的键会被新的键覆盖键值。

创建字典¶

Python
# 字典的创建
# 例一
a = {"hello": "word"}
# 例二 不可以在键添加引号
b = dict(hello="word")
# 例三 通过包含元组的列表创建
c = dict([("hello", "word")])
# 例四
d = dict({"hello": "word"})
# 例五 混合使用，此时不可以在使用例三方法混合使用
e = dict({"hello": "word"}, test="test")
# 例六 使用zip()函数进行创建
f = dict(zip([1, 2, 3], "hello"))  # f --> {1: 'h', 2: 'e', 3: 'l'}

字典的增删改查¶

增加键值¶

函数 fromkeys 语法： fromkeys(iterable[,values]) ，可以指定一个可迭代对象 interable，然后赋值 values，初始化一个多个键值对应一个值的字典，如果不指定 values 值生成的字典每个键对应的值都是 None。

Python
a = dict.fromkeys("fq", 33)  # a --> {"f": 33, "q": 33}

b = {1: "a", 2: "b"}
b["3"] = "c"  # 如果传入的键值在字典中没有，那么就会新增该键值

删除键值¶

pop() 语法： pop(key[,default])

Python
a = {1: "a", 2: "b", 3: "c"}
a.pop(1)  # a --> {2: "b", 3: "c"} 如果删除一个不存在的键就会抛出异常
# 如果不想抛出异常可以指定default参数默认值，当没有该键就会打印default内容
a = {1: "1", 2: "2"}
print(a.pop(4, "没有该键！"))

popitem() ： 在 Python3.7 之前该函数随机删除字典中的一个键值对，在 Python3.7 之后，该函数删除最后一个创建的键值对。

Python
a = {1: "1", 2: "2"}
a.popitem()  # a --> {1: "1"}

del() ： 指定字典键，删除对应的字典键值对，或者直接指定字典将字典直接删掉。

Python
a = {1: "1", 2: "2"}
del a[1]  # a --> {2: "2"}
del a  # 直接删除字典

clear() ： 清空字典内容。

Python
a = {1: "1", 2: "2"}
a.clear()  # a --> {}

修改键值¶

Python
a = {1: "a", 2: "b"}
a[1] = "c"  # a --> {1: "c", 2: "b"} 前提修改的键值在对应字典中，如果不在这会新建改键值

update() ： 批量修改字典内容，可以传入一个字典参数直接对其键值进行覆盖，也可以传入多个键值对，进行修改，

Python
a = dict.fromkeys("123")  # a --> {"1": None, "2": None, "3": None}
# 传入字典参数，如果被修改的字典有该键对应值会被修改，如果不存在传入的键这会新增
a.update({1: "1"})  # a --> {'1': None, '2': None, '3': None, 1: '1'}
# 传入键值对，传入键值对，该种方法不适用于键为整形，或字符串整形，传入会引起异常
b = dict.fromkeys("abc")  # b --> {"a": None, "b": None, "c": None}
b.update(a=1, b=2, c=3)

查找键值¶

通过给定一个键返回对应的值，但是如果给定的键不在字典中程序执行会引发异常。

Python
# 通过键直接过去值
a = {1: "a", 2: "b"}
a[1]  # --> "a"

get() 方法： get(key[,default]) 获取键值，可以传入 default 参数，当找不到键的时候，输出 default 内容。

Python
a = {"a": "a", "b": "b", "c": "c"}
a.get("a")  # --> "a"
a.get("c", "不存在")  # --> 不存在

setdefault() 函数语法： setdefault(key[,default]),如果字典存在需要查询的键，会返回对应的值，如果不存在会创建对应的值，default参数就是对应默认不存在创建键对应的值。

Python
a = {"a": "a", "b": "b", "c": "c"}
a.setdefault("c", "d")  # --> "c"
a.setdefault("d", "d")  # --> "d"  a --> {"a": "a", "b": "b", "c": "c", "d": "d"}

items()、keys()、values() 分别用于获取字典的键值对、键、值的视图对象，视图对象是字典的动态视图，当字典的内容发生改变时，视图对象也会相应发生改变。

Python
dic = {"abc": "hello", "xyz": "789", "test": "tui"}
keys = dic.keys()  # dict_keys(['abc', 'xyz', 'test'])
values = dic.values()  # dict_values(['hello', '789', 'tui'])
item = dic.items()  # dict_items([('abc', 'hello'), ('xyz', '789'), ('test', 'tui')])
# 当字典的键值发生改变，对应的视图也会发生改变
dic["word"] = {"hah"}
# dict_keys(['abc', 'xyz', 'test', 'word'])
# dict_values(['hello', '789', 'tui', 'hah'])
# dict_items([('abc', 'hello'), ('xyz', '789'), ('test', 'tui'), ('word', 'hah')])
# 可以发现对应的视图对象也会相应改变

字典的其他操作¶

Python
# 字典的浅拷贝
dic = {"abc": "hello", "xyz": "789", "test": "tui"}
test = dic.copy()  # test --> {"abc": "hello", "xyz": "789", "test": "tui"}此时字典拷贝，两个字典的的id值是不相同

# len()函数获取字典的长度
num = len(dic)

# 使用in 和 not in 判断某个键是否存在
"abc" in dic  # --> True

# 字典转换成列表
list(dic)  # 此时得到的是所有键构成的列表 --> ["abc", "xyz", "test"]
list(dic.values())  # 此时可以获取所有键值的列表 --> ["hello", "xyz", "test"]

# 将字典的键构成迭代器
a = iter(dic)  # 此时a就是所有键的迭代器

# 在python3.8版本后字典的键有了排序，可以使用函数reversed()，对字典进行逆序
b = list(reversed(dic))  # ['test', 'xyz', 'abc']

字典的嵌套¶

某个键的值是另外一个字典，就是字典的嵌套。

Python
a = {
  "小明": {"语文": 10, "数学": 20, "英语": 30},
  "小红": {"语文": 100, "数学": 80, "英语": 100}
}
# 此时获取成绩则需要进行两次索引
# 小明语文成绩
a["小明"]["语文"]

字典推导式¶

Python
test = {"a": 1, "b": 2, "c": 3}
aa = {x, y for y, x in test.iters()}  # 此时aa就会将test键值进行调换创建新的字典赋值给aa
bb = {x, y for y, x in test.iters() if y > 1}  # 此时b对应的值 --> {2: "b", 3: "c"}
# 使用字典推导式求出字符的编码值
d = {x: ord(x) for x in "hello"}  # d --> {'h': 104, 'e': 101, 'l': 108, 'o': 111}
# 使用两个循环，由于字典键不会重复，最后的键会覆盖前面的值
d = {x: y for x in range(1, 3) for y in range(4, 5)}  # d --> {1: 4, 2: 4}