Python数据类型字典分析

1. 创建字典

• 字典（dict）是一个无序、可变和有索引的集合，字典中不允许存在重复的成员。

1.1 创建空字典

• 在 Python 中，{} 表示一个空字典
• 可以通过 dict() 的方式来创建一个空字典

a = {}  
print(type(a)) # <class 'dict'>  
b = dict()  
print(type(b)) # <class 'dict'>

1.2 创建非空字典

• 创建字典时可以在 {} 中设置字典的初始值。

a = {  
    'name':'siwen',  
    'time':2023  
}  
print(a) # {'name': 'siwen', 'time': 2023}

• 字典是一种存储键值对的结构，键和值一一对应，根据键就能够快速找到其对应的值
• 键值对之间使用 , 分割，键（key）和值（value）之间使用 : 分隔
• 最后一个键值对的后面可以写 , 也可以不写

2. 新增字典元素

2.1 thisdict[new_key] = new_value

• 通过 thisdict[key] = value 的方式可以将键值对 <key, value> 插入到字典 thisdict 中。

a = {  
    'name':'siwen',  
    'time':2023  
}  
print(a) # {'name': 'siwen', 'time': 2023}  
a['age'] = 22  
print(a) # {'name': 'siwen', 'time': 2023, 'age': 22}

2.2 update 方法

• 使用 update 方法可以将多个键值对插入到字典中

a = {  
    'name':'siwen',  
    'time':2023  
}  
print(a) # {'name': 'siwen', 'time': 2023}  
a.update({'age': 22,'weight':123})  
print(a) # {'name': 'siwen', 'time': 2023, 'age': 22, 'weight': 123}

3. 删除字典元素

• 使用 pop 方法可以删除指定键值（key）的键值对。
• 使用 popitem 方法可以删除最后插入字典的键值对

a = {  
    'name':'siwen',  
    'time':2023  
}  
  
a.pop('time')  
print(a) # {'name': 'siwen'}  
  
a = {  
    'name':'siwen',  
    'time':2023  
}  
a.popitem()  
print(a) # {'name': 'siwen'}  
a.popitem()  
print(a) # {}

4. 查找字典元素

4.1 in 和 in not 操作符

• 使用 in 和 in not 操作符能够判定指定的键值（key）是否在字典中存在

a = {  
    'name':'siwen',  
    'time':2023  
}  
  
print('time' in a)      # True  
print('time' not in a)  # False  
print('name' in a)      # True  
print('name' not in a)  # False

• in 和 in not 操作符只是判定 key 是否存在，与 value 无关

4.2 get 方法

• 使用 get 方法可以获取指定键（key）的值（value）

a = {  
    'name':'siwen',  
    'time':2023  
}  
print(a.get('name')) # siwen  
print(a.get('hello'))# None

• 如果指定的键（key）不存在，则 get 返回 None

4.3 thisdict[key]

• 通过 thisdict[key] 的方式也可以获取指定键（key）的值（value）

a = {  
    'name':'siwen',  
    'time':2023  
}  
print(a['name']) # siwen  
#print(a['hello'])# 抛出异常

5. 修改字典元素

• 通过 thisdict[key] = new_value 的方式可以修改指定键（key）的值（value）

a = {  
    'name':'siwen',  
    'time':2023  
}  
a['time'] = 1997  
print(a) #{'name': 'siwen', 'time': 1997}

• 使用 [] 可以根据 key 来新增或修改 value，如果指定的 key 不存在，则为新增键值对，如果指定的 key 存在，则为修改键值对的值

6. 遍历字典元素

6.1 for 循环遍历

字典也是一个可迭代对象，因此可以直接使用 for 循环对字典进行遍历

• 使用 for 循环对字典遍历时，实际上是在对字典中的 key 进行遍历

a = {  
    'name':'siwen',  
    'time':2023,  
    'age': 22  
}  
  
for key in a:  
    print(key,a[key])  
    
#name siwen  
#time 2023  
#age 22

6.2 keys 方法

• 使用 keys 方法可以获取到字典中所有 key 所组成的列表

a = {  
    'name':'siwen',  
    'time':2023,  
    'age': 22  
}  
  
for key in a.keys():  
    print(key,a[key])  
#name siwen  
#time 2023  
#age 22

6.3 values 方法

使用 values 方法可以获取到字典中所有 value 所组成的列表

a = {  
    'name':'siwen',  
    'time':2023,  
    'age': 22  
}  
  
for value in a.values():  
    print(value)  
#siwen  
#2023  
#22

6.4 items 方法

• 使用 items 方法可以获取到字典中所有键值对所组成的元组的列表
• 代码中用 for 循环对 items 的返回值进行遍历，也就是对列表中的一个个元组在进行遍历，每次遍历时将元组中的键和值分别赋值给 key 和 value 变量

a = {  
    'name':'siwen',  
    'time':2023,  
    'age': 22  
}  
  
for key,value in a.items():  
    print(key,value)  
#name siwen  
#time 2023  
#age 22

7. 合并字典

7.1 update 方法

• 使用 update 可以将一个字典合并到另一个字典中

a = {  
    'name':'siwen',  
    'time':2023,  
}  
b = {  
    'age': 22  
}  
a.update(b)  
print(a) # {'name': 'siwen', 'time': 2023, 'age': 22}
print(b) # {'age': 22}

8. 字典的 key

• 一个字典中存储的各个键值对的 key 可以是不同类型的
• 但并不是所有的类型都可以作为字典的 key，因为字典本质上是一个哈希表，而哈希表的 key 要求是“可哈希的”，因此字典的 key 也必须是“可哈希的”，所谓的“可哈希”就是可以计算出一个哈希值。
• 在 Python 中，使用 hash 函数可以计算某个对象的哈希值
• 在 python 中有些类型是不能计算出对应的 hash 值,如 list, tuple,dict

print(hash(0))       # 0  
print(hash('a'))     # -510370993372095746  
print(hash(1.1))     # 230584300921369601  
print(hash((1,2,3))) # 529344067295497451

#以下都会抛异常
print(hash([1,2]))  
print(hash({1,2}))  
print(hash({'1':1,'2':2}))

9. 其他方法

9.1 copy 方法

• copy 属于浅拷贝
• 浅拷贝会复制字典的键和值的引用，但不会递归复制内部嵌套的对象

a = {  
    'name':'siwen',  
    'time':2023,  
}  
b = {  
    'age': 22  
}  
a = b.copy() #浅拷贝    浅拷贝会复制字典的键和值的引用，但不会递归复制内部嵌套的对象。  
print(a)     # {'age': 22}

• 注意

a = {  
    'name':'siwen',  
    'time':2023,  
}  
b = {  
    'age': 22  
}  
  
b = a # b 字典成为了 a 字典的引用  
a['name'] = 'test'  
  
print(a) # {'name': 'test', 'time': 2023}  
print(b) # {'name': 'test', 'time': 2023}

• 实现深拷贝
• 导入 copy 模块,使用 copy.deepcopy 方法

import copy # 导入copy模块  
  
a = {  
    'name':'siwen',  
    'time':2023,  
}  
b = {  
    'age': 22  
}  
b = copy.deepcopy(a) # 深拷贝  
print(a)    # {'name': 'siwen', 'time': 2023}  
  
a['name'] = 'test'  
print(a)    # {'name': 'test', 'time': 2023}  
print(b)    # {'name': 'siwen', 'time': 2023}

9.2 clear 方法

a = {  
    'name':'siwen',  
    'time':2023,  
}  
a.clear()  
print(a) # {}

9.3 fromkeys方法

• fromkeys(keys, value)：这个方法返回一个新的字典，其中包含指定的键 keys 和对应的值 value。其中，keys 是一个可迭代的对象，用于指定新字典中的键，value 是用于指定新字典中所有键对应的初始值。

keys = ['a', 'b', 'c']  
value = 0  
new_dict = dict.fromkeys(keys, value)  
print(new_dict)  # {'a': 0, 'b': 0, 'c': 0}

keys = ['a', 'b', 'c']  
values = {1,2,3}  
new_dict = dict.fromkeys(keys, values)  
print(new_dict)  # {'a': {1, 2, 3}, 'b': {1, 2, 3}, 'c': {1, 2, 3}}

9.4 setdefault方法

• setdefault(key, default=None)
• 这个方法返回指定键 key 对应的值。如果字典中已经存在键 key，则返回该键对应的值；如果字典中不存在键 key，则将键 key 插入字典，并将其值设为 default（默认为 None），然后返回 default。

my_dict = {'a': 1, 'b': 2}
value = my_dict.setdefault('c', 3)
print(my_dict)  # {'a': 1, 'b': 2, 'c': 3}
print(value)  # 3
```![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/6306c5b7f9244d9bac3cd20e7e7c2f09.png)