Python序列类型之字典dict

来源： “码农不会写诗”公众号
链接：Python序列类型之字典dict

字典Dictionary

字典(Dict)是一种（值）可存储任意类型对象的可变容器，通过唯一的键来快速查找和访问对应的值。

01 基本概念

即一种存储键值对的无序可变容器类型。但在Python3.7之后为有序（插入顺序），需要注意，每个键会转为hash值存储，因此必须是唯一且不可变的数据类型（如字符串、整数、元组等），不可以是列表、布尔值、字典，因为这些不可以转为hash值存储起来。值可以是任何数据类型，包括可变和不可变类型。

02 字典创建

字典创建

d = dict([("A", "python"),
          ("B", "hello"),
          ("C", "world")])

{}创建字典

d = {"A": "python", 
     "B": "hello",
     "C": "world"}

推导式创建字典

d = {x: x**2 for x in range(5)}
print(d)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

dict.fromkeys(seq[, value]) 函数创建字典
序列 seq 中元素做字典的键，value（可选，默认None）为字典所有键对应的初始值

seq = ("key1", "key2", "key3")
d1 = dict.fromkeys(seq)
print(d1)   # {'key1': None, 'key2': None, 'key3': None}

d2 = dict.fromkeys(seq, 10)
print(d2)   # {'key1': 10, 'key2': 10, 'key3': 10}

03 字典操作

通过键访问值

d = {"A": "python", "B": "hello", "C": "world"}
print(d["A"])  # python
print(d["B"])  # hello

获取键的列表dict.keys()

d = {"A": "python", "B": "hello", "C": "world"}
d.keys()  # dict_keys(['A', 'B', 'C']

获取值的列表dict.values()

d = {"A": "python", "B": "hello", "C": "world"}
d.values()  # dict_values(['python', 'hello', 'world'])

获取列表形式的键值对dict.items()

d = {"A": "python", "B": "hello", "C": "world"}
d.items()  # dict_items([('A', 'python'), ('B', 'hello'), ('C', 'world')])

字典遍历

d = {"A": "python", "B": "hello", "C": "world"}
for key in d:
    print(key)

A
B
C

d = {"A": "python", "B": "hello", "C": "world"}
for value in d.values():
    print(value)

python
hello
world

d = {"A": "python", "B": "hello", "C": "world"}
for key, value in d.items():
    print(key, value)

A python
B hello
C world

dict.get(key, default=None)返回指定键的值，不存在该键则返回defalut指定的值

d = {"A": "hello", 
     "B": "python", 
     "C": "world"}
print(d.get("D"))        # None
print(d.get("A"))        # hello
print(d.get("D", "Hi"))  # Hi

需要注意的是，通过键访问值时，若该键不存在则会触发 KeyError 异常。

d = {"A": "python", 
     "B": "hello", 
     "C": "world"}
print(d["D"])  # KeyError: 'D'

dict.setdefault(key, default=None)

1. 若键key不存在，则添加并设置值为default指定的值并返回；
2. 如果 key 已经存在，则返回对应的值。

d = {"A": "hello", 
     "B": "python", 
     "C": "world"}
print(d.setdefault("C", None))  # world
print(d.setdefault("D", None))  # None
print(d)  # {'A': 'hello', 'B': 'python', 'C': 'world', 'D': None}

dict.copy()返回一个字典的深拷贝
以下可以发现：修改deepcopy_d的值不会修改原字典的值，而copy_d则会。

d = {"A": "hello", 
     "B": "python", 
     "C": "world"}
copy_d = d
deepcopy_d = d.copy()

copy_d["A"] = "hi"
deepcopy_d["A"] = "Hello"

print(d)
#  {'A': 'hi', 'B': 'python', 'C': 'world'}
print(copy_d)
#  {'A': 'hi', 'B': 'python', 'C': 'world'}
print(deepcopy_d)
# {'A': 'Hello', 'B': 'python', 'C': 'world'}

[]修改字典的值

d = {"A": "python", 
     "B": "hello", 
     "C": "world"}
d["C"] = "Hi"
print(d)  # {'A': 'python', 'B': 'hello', 'C': 'Hi'}

dict1.update(dict2)将dict2的键值对更新到dict1里

dict1 = {"A": "hello", "B": "python"}
dict2 = {"C": "world"}
dict1.update(dict2)
print(dict1)  # {'A': 'hello', 'B': 'python', 'C': 'world'}
print(dict2)  # {'C': 'world'}

删除字典元素
del 命令删除字典元素

d = {"A": "python", 
     "B": "hello", 
     "C": "world"}
del d["A"]
print(d)  # {'B': 'hello', 'C': 'world'}

dict.clear() 清空字典

d = {"A": "python", "B": "hello", "C": "world"}
d.clear()
print(d)  # {}

dict.pop(key[,default]) 删除字典键key所对应的值，并返回被删除的值

1. 若key存在，删除对应的元素并返回值；
2. 若key不存在且指定了默认值default则返回默认值；
3. 若key不存在且未指定默认值default则触发KeyError异常；

d = {"A": "python", 
     "B": "hello", 
     "C": "world"}
v = d.pop("A")
print(v)  # python
print(d)  # {'B': 'hello', 'C': 'world'}

d = {"A": "python", 
     "B": "hello", 
     "C": "world"}
d.pop("D", "not existed key")  # 'not existed key'

d = {"A": "python", 
     "B": "hello", 
     "C": "world"}
d.pop("D")  # KeyError: 'D'

dict.popitem()返回并删除字典中的最后一个键值对
需要注意，在Python3.7之前，该方法删除并返回任意插入字典的键值对。

d = {"A": "python", 
     "B": "hello", 
     "C": "world"}
x = d.popitem()
print(x)  # ('C', 'world')
print(d)  # {'A': 'python', 'B': 'hello'}

04 拓展1列表去重

Python字典dict是一种基于哈希表的复杂数据结构。

1. 实现原理
字典的键被传入哈希函数，生成一个哈希值，此哈希值随后被转换为一个整数索引，用以确定键值对在哈希表中的存储位置。

2. 查找速度
字典的查找速度非常快，平均情况下是O(1)的时间复杂度，即常数时间复杂度。这是因为理想情况下，每个键的哈希值都是唯一的，所以可以直接定位到哈希表中的对应位置。
但在最坏的情况下，所有的键都产生相同的哈希值或哈希值之间有很多冲突，查找速度会退化到O(n)，其中n是字典中元素的数量，但此情况基本不会出现。

今天的内容就到这里啦，先拜了个拜~

上一篇：Python序列类型之集合set