Python 修仙修炼录 08：字典秘境，参悟键值玄机

目录

• • 一、字典概述
  • 二、创建字典
  • • [1. 创建空字典](#1. 创建空字典)
    • [2. 创建字典的同时设置初始值](#2. 创建字典的同时设置初始值)
  • [三、查找 key](#三、查找 key)
  • • [1. 使用 in / not in判断 key 是否存在](#1. 使用 in / not in判断 key 是否存在)
    • [2. 使用 [] 根据 key 获取 value](#2. 使用 [] 根据 key 获取 value)
  • [四、新增 / 修改 键值对](#四、新增 / 修改 键值对)
  • [五、使用 pop 方法删除键值对](#五、使用 pop 方法删除键值对)
  • 六、遍历字典
  • • [1. 直接 for 循环遍历](#1. 直接 for 循环遍历)
    • [2. keys()、values()、items()](#2. keys()、values()、items())
  • [七、合法的 key 类型](#七、合法的 key 类型)

一、字典概述

字典是Python中存储键值对 的数据结构，根据key能够快速找到value。

字典中可以包含很多键值对，键（key）不能重复。

---

二、创建字典

1. 创建空字典

1. 直接使用花括号{}（最常用）

a = {}
print(type(a))  # 输出：<class 'dict'>

2. 使用 dict() 函数

b = dict()
print(type(b)) # 输出：<class 'dict'>

2. 创建字典的同时设置初始值

字典中的key类型可以不同，value类型也可以不同。

字典对key的类型有约束，对value的类型没有约束。

a = {
    'id': 1,
    'name': 'zhangsan',
     100:'lisi',
}

---

三、查找 key

1. 使用 in / not in判断 key 是否存在

in / not in 只判定 key 是否存在，和 value 无关

a = {
    'id': 1,
    'name': 'zhangsan',
}
print('id' in a)        # 判断 key 'id' 是否在 字典a中，在返回True 不在返回False
print('classId' in a)   # 输出：False

print('classId' not in a)  # 输出：True
print('id' not in a)       # 输出：False

2. 使用 [] 根据 key 获取 value

字典的in和[]都是高效操作 （因为字典背后使用了特殊的数据结构:哈希表）

列表的 in 效率低 （需要把整个列表遍历一遍），列表 [] 效率高(类似于数组/顺序表取下标)

key 不存在 会直接报错 KeyError

a = {
    'id': 1,
    'name': 'zhangsan',
    100: 'lisi'
}
print(a['id'])      # 输出：1
print(a['name'])    # 输出：zhangsan
print(a[100])       # 输出：lisi
# print(a['classId'])  # KeyError: 'classId'

---

四、新增 / 修改 键值对

规则：

• key 不存在 → 新增键值对
• key 已存在 → 修改对应 value
  字典所有操作都是针对 key 进行

语法：字典[key] = 新值

a = {
    'id': 1,
    'name': 'zhangsan',
}

# 新增键值对
a[100] = 'lisi'
print(a)  # {'id': 1, 'name': 'zhangsan', 100: 'lisi'}

# 修改键值对
a[100] = 'wangwu'
print(a)  # {'id': 1, 'name': 'zhangsan', 100: 'wangwu'}

---

五、使用 pop 方法删除键值对

字典的删除只针对 key ，最常用的方法是 pop()，传入要删除的 key 即可。

student = {
    'id': 1,
    'name': 'zhansan',
    100: 'wangwu'
}

# 删除 key='name' 对应的键值对
student.pop('name')
print(student)  # 输出：{'id': 1, 100: 'wangwu'}

---

六、遍历字典

字典设计初衷是高效增删改查，遍历效率稍差

Python 字典遍历顺序 = 插入顺序（不是纯哈希表，做了特殊处理）

1. 直接 for 循环遍历

for 循环直接遍历字典，默认遍历的是所有 key，再通过 key 取 value。

a = {
    'id': 1,
    'name': 'zhangsan',
    100: 'lisi'
}
for key in a:
    print(key, a[key])
# 输出：
# id 1
# name zhangsan
# 100 lisi

在C++或者Java中，哈希表里面的键值对存储的顺序，是无序的!

但是在Python中还不一样 Python中做了特殊处理 能够保证遍历出来的顺序，就是和插入的顺序一致的!!

Python中的字典，又不是一个单纯的哈希表

2. keys()、values()、items()

1. 遍历所有 key：keys()

a = {
    'id':1,
    'name':'zhangsan',
    100:'lisi'
}
print(a.keys())    # dict_keys(['id', 'name', 100])

返回的结果，看起来像列表，又不完全是 自定义的类型

使用的时候也可以把它当做一个列表来使用

2. 遍历所有 value：values()

a = {
    'id':1,
    'name':'zhangsan',
    100:'lisi'
}
print(a.values())  # dict_values([1, 'zhangsan', 'lisi'])

3. 遍历所有键值对：items()（最常用）
   首先是一个列表一样的结构，里面每个元素又是一个元组，元组里面包含了键和值

a = {
    'id':1,
    'name':'zhangsan',
    100:'lisi'
}
print(a.items())   # dict_items([('id', 1), ('name', 'zhangsan'), (100, 'lisi')])

---

七、合法的 key 类型

可使用 hash() 函数判断是否可作为 key

• 不可变对象 → 可哈希 → 可以做 key
• 可变对象 → 不可哈希 → 不能做 key

# 可哈希（可以做 key）
print(hash(0))        # 0
print(hash(3.14))     # 3228180523291329
print(hash('hello'))  # 哈希值（每次运行不同）
print(hash(True))     # 1
print(hash((1, 2, 3)))# 哈希值

# 不可哈希（不能做 key）
# print(hash([1, 2, 3]))  # TypeError: unhashable type: 'list'
# print(hash({}))         # TypeError: unhashable type: 'dict'