【Python基础：语法第五课】Python字典高效使用指南：避开KeyError，掌握遍历与增删改查精髓

艾莉丝努力练剑2025-12-13 8:13


🎬 个人主页 ：艾莉丝努力练剑
❄专栏传送门 ：《C语言》《数据结构与算法》《C/C++干货分享&学习过程记录》
《Linux操作系统编程详解》《笔试/面试常见算法：从基础到进阶》《Python干货分享》

⭐️为天地立心，为生民立命，为往圣继绝学，为万世开太平

🎬 艾莉丝的简介：

文章目录

  • [1 ~> 字典的概念](#1 ~> 字典的概念)
    • [1.1 什么是字典？](#1.1 什么是字典？)
    • [1.2 什么是键值对？](#1.2 什么是键值对？)
    • [1.3 最佳实践](#1.3 最佳实践)
  • [2 ~> 创建字典](#2 ~> 创建字典)
    • [2.1 理论](#2.1 理论)
    • [2.2 最佳实践](#2.2 最佳实践)
  • [3 ~> 查找key](#3 ~> 查找key)
    • [3.1 理论](#3.1 理论)
      • [3.1.1 使用`in`可以判定key是否在字典中存在（返回布尔值）](#3.1.1 使用in可以判定key是否在字典中存在（返回布尔值）)
      • [3.1.2 使用`[]`通过类似于取下标的方式，获取到元素的值](#3.1.2 使用[]通过类似于取下标的方式，获取到元素的值)
      • [3.1.3 如果`key`在字典中不存在，则会抛出异常](#3.1.3 如果key在字典中不存在，则会抛出异常)
      • [3.2 最佳实践](#3.2 最佳实践)
  • [4 ~> 新增 / 修改 / 删除元素](#4 ~> 新增 / 修改 / 删除元素)
    • [4.1 概念](#4.1 概念)
      • [4.1.1 新增 / 修改元素的概念](#4.1.1 新增 / 修改元素的概念)
      • [4.1.2 删除元素](#4.1.2 删除元素)
    • [4.2 理论](#4.2 理论)
      • [4.2.1 新增 / 修改元素部分的理论](#4.2.1 新增 / 修改元素部分的理论)
        • [4.2.1.1 如果 key 不存在，对取下标操作赋值，即为新增键值对](#4.2.1.1 如果 key 不存在，对取下标操作赋值，即为新增键值对)
        • [4.2.1.2 如果 key 已经存在，对取下标操作赋值，即为修改键值对的值](#4.2.1.2 如果 key 已经存在，对取下标操作赋值，即为修改键值对的值)
      • [4.2.2 删除元素部分的理论](#4.2.2 删除元素部分的理论)
        • [4.2.2.1 使用 pop 方法根据 key 删除对应的键值对](#4.2.2.1 使用 pop 方法根据 key 删除对应的键值对)
    • [4.3 最佳实践](#4.3 最佳实践)
  • [5 ~> 遍历字典元素](#5 ~> 遍历字典元素)
    • [5.1 理解字典操作的效率](#5.1 理解字典操作的效率)
      • [5.1.1 最佳实践](#5.1.1 最佳实践)
    • [5.2 理论](#5.2 理论)
      • [5.2.1 直接使用 for 循环能够获取到字典中的所有的 key，进一步的就可以取出每个值了](#5.2.1 直接使用 for 循环能够获取到字典中的所有的 key，进一步的就可以取出每个值了)
    • [5.3 遍历相关最佳实践](#5.3 遍历相关最佳实践)
  • [6 ~> 取出所有 key 和 value（三种方法，也能完成字典的变量）](#6 ~> 取出所有 key 和 value（三种方法，也能完成字典的变量）)
    • [6.1 理论](#6.1 理论)
      • [6.1.1 使用`keys`方法可以获取到字典中的所有的 key](#6.1.1 使用keys方法可以获取到字典中的所有的 key)
      • [6.1.2 使用`values`方法可以获取到字典中的所有 value](#6.1.2 使用values方法可以获取到字典中的所有 value)
      • [6.1.3 使用`items`方法可以获取到字典中所有的键值对](#6.1.3 使用items方法可以获取到字典中所有的键值对)
    • [6.2 最佳实践](#6.2 最佳实践)
      • [6.2.1 获取到字典中的所有的 key](#6.2.1 获取到字典中的所有的 key)
      • [6.2.2 获取到字典中的所有 value](#6.2.2 获取到字典中的所有 value)
      • [6.2.3 获取到字典中所有的键值对](#6.2.3 获取到字典中所有的键值对)
      • [6.2.4 借助上面的方法也能完成对字典的遍历](#6.2.4 借助上面的方法也能完成对字典的遍历)
  • [7 ~> 合法的 key 类型 / 可哈希的类型](#7 ~> 合法的 key 类型 / 可哈希的类型)
    • [7.1 理论](#7.1 理论)
      • [7.1.1 不是所有的类型都可以作为字典的key](#7.1.1 不是所有的类型都可以作为字典的key)
      • [7.1.2 列表无法计算哈希值](#7.1.2 列表无法计算哈希值)
      • [7.1.3 字典也无法计算哈希值](#7.1.3 字典也无法计算哈希值)
    • [7.2 最佳实践](#7.2 最佳实践)
  • [8 ~> Python基础语法字典部分小结](#8 ~> Python基础语法字典部分小结)
  • 结尾

1 ~> 字典的概念

1.1 什么是字典？

字典是一种存储 键值对 的结构。

1.2 什么是键值对？

啥是 键值对？这是计算机 / 日常生活中一个非常广泛使用的概念。

把键 (key) 和值 (value) 进行一个一对一的映射，然后就可以根据键，快速找到值。

举个🌰，学校的每个同学，都会有一个唯一的学号。

知道了学号，就能确定这个同学。

此处"学号"就是"键"，这个"同学"就是"值"。

1.3 最佳实践

如下图所示------

2 ~> 创建字典

2.1 理论

创建一个空的字典。使用 { } 表示字典------

python 复制代码 
a = { }
b = dict()

print(type(a))
print(type(b))

也可以在创建的同时指定初始值。

键值对之间使用,分割，键和值之间使用:分割（冒号后面推荐加一个空格）。

使用print来打印字典内容。

python 复制代码 
student = { 'id': 1, 'name': 'zhangsan' }
print(student)

为了代码更规范美观，在创建字典的时候往往会把多个键值对，分成多行来书写。

python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan'
}

最后一个键值对，后面可以写,也可以不写------

python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan',
}

2.2 最佳实践

python 复制代码 
# 字典的创建
# 我们此处所说的Python中的字典表示一种存储键值对的数据结构

# # 1、创建字典
# a = {}
# print(type(a))
# b = dict()
# print(type(b))
#
# # 2、创建字典的同时设置初始值
# a = {'id' : 1,'name' : 'zhangsan'}
# print(a)

# 上面的写法都不够直观
a ={
    'id' : 1,
    'name' : 'zhangsan'
}
print(a)
# 打印出来还是这种比较紧凑的格式：{'id': 1, 'name': 'zhangsan'}
# 但是书写代码的时候可以写成这种多行的形式------好处就是一目了然，可读性很好

b ={
    'id' : 1,
    'name' : 'lisi',    # 最后一个键值对后面的逗号可以写也可以不写！
}
print(b)

3 ~> 查找key

3.1 理论

3.1.1 使用in可以判定key是否在字典中存在（返回布尔值）

python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan',
}
print('id' in student)
print('score' in student)

3.1.2 使用[]通过类似于取下标的方式，获取到元素的值

只不过此处的"下标"是key（可能是整数，也可能是字符串等其他类型）。

python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan',
}

print(student['id'])
print(student['name'])

3.1.3 如果key在字典中不存在，则会抛出异常

python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan',
}

print(student['score'])

3.2 最佳实践

python 复制代码 
# 字典查找key

# 1、使用 in 来判定某个 key 是否在字典中存在
# a = {
#     'id' : 1,
#     'name' : 'zhangsan'
# }
#
# print('id' in a)
# print('classId' in a)
#
# # in 只是判定 key 是否存在，和 value 无关！
# print('zhangsan' in a)
#
# # not in 用来判定 key 在字典中不存在
# print('id' not in a)
# print('classId' not in a)

# 2、使用 [] 来根据 key 获取到 value
# in、not in只能判定在不在，而 [] 可以获取里面的内容
a = {
    'id' : 1,
    'name' : 'zhangsan',
    100 : 'lisi'
}

print(a['id'])  # 光是一个 id 只是代表一个 key，但是 a['id'] 这个是根据 key 找到对应的 value，这里就是1
print(a['name'])    # 这样 zhangsan 也能获取到了
print(a[100])   # 整数也可以
print(a['classId']) # 代码出现异常：KeyError: 'classId'（表示当前这个key在字典中不存在）
# (1)对于字典来说，使用in或者[]来获取value(字典背后使用了特殊的数据结构：哈希表------特点：擅长查找操作)，都是非常高效的操作
# (2)对于列表来说，使用in比较低效的(需要把整个列表遍历一遍)，而使用[](类似于数组 / 顺序表取下标)是比较高效的
# 像哈希表、顺序表这样的数据结构都是日常开发中比较常用的结构，Python把这些数据结构封装好了，作为一个内置类型
# 我们拿过来就可以很方便地使用，只不过我们使用时要注意理解这些结构背后操作的一些相关机制，
# 以及这些操作带来的一些效率高低的问题


KeyError:'classId' 表示当前这个key在字典中不存在------

4 ~> 新增 / 修改 / 删除元素

4.1 概念

4.1.1 新增 / 修改元素的概念

使用[ ]可以根据 key 来新增 / 修改 value。

4.1.2 删除元素

使用pop方法根据 key 删除对应的键值对。

4.2 理论

4.2.1 新增 / 修改元素部分的理论

4.2.1.1 如果 key 不存在，对取下标操作赋值，即为新增键值对
python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan',
}

student['score'] = 90
print(student)
4.2.1.2 如果 key 已经存在，对取下标操作赋值，即为修改键值对的值
python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}

student['score'] = 90
print(student)

4.2.2 删除元素部分的理论

4.2.2.1 使用 pop 方法根据 key 删除对应的键值对
python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}

student.pop('score')
print(student)

4.3 最佳实践

python 复制代码 
# 1、（插入新键值对操作）在字典中新增元素，使用 [] 来进行
a = {
    'id' : 1,
    'name' : 'zhangsan',
} # 这里出现"转成字面量"的黄色波浪线，点击替换就会变成下面的代码
# a ={'id' : 1,'name' : 'zhangsan','score' : 90}    # 此处是为了演示插入新键值对操作，所以还是要写成多行

# 这个操作就是往字典里面插入新的键值对
# 这里没报异常是因为当前我们进行的是写操作，不要求原来存在，换句话说：如果原来存在了也就不叫新增了
a['score'] = 90 # 前面出现 KeyError 异常是因为前面进行的是读取操作
print(a)

# 2、（修改操作）在字典中，根据 key 来修改 value，也是使用 [] 来进行的
a['score'] = 100
print(a)
# （1）如果key不存在，往里写入，相当于新增键值对
# （2）如果key存在，往里写入，则相当于根据key修改value
# 这里就和前面说的变量创建、修改是类似的
# a = 10  #a当前不存在，这就是定义变量（创建新变量
# a = 20  #a当前已经存在了，这里就是修改变量

# 注意区分读操作和写操作：写操作是赋值，读操作是从里面获取到这个值（数据流向的方向不同，要注意区分）

# 3、（删除操作）使用 pop 方法，根据 key 来删除键值对
a.pop('name')
print(a)

# 要注意体会这里的要点------
# 字典的各种操作，都是针对 key 来进行的
# 新增，删除，获取value，修改value...都要凭借 key 去进行（这里的 key 是至关重要的）

# 毕竟我们现实中的很多数据往往是很复杂的，我们要想直接去表示这个很复杂的数据是比较麻烦的，
# 所以日常中也经常用这个很复杂的数据其中的某个能够区分身份的属性作为身份的标识

uu们就记住一句话：字典的各种操作，都是针对 key 来进行的。无论是新增，还是删除、获取value、修改value...都要凭借 key 去进行（这里的 key 是至关重要的）。毕竟我们现实中的很多数据往往是很复杂的，我们要想直接去表示这个很复杂的数据是比较麻烦的，所以日常中也经常用这个很复杂的数据其中的某个能够区分身份的属性作为身份的标识。

5 ~> 遍历字典元素

5.1 理解字典操作的效率

5.1.1 最佳实践

python 复制代码 
# 理解字典操作的效率

# 遍历指的就是能够把一个可迭代对象，里面包含的元素依次的取出来，并进行一些操作，整个过程要求不重不漏
# 字典是哈希表，进行增删改查操作，效率都是非常高的
# 如果学了一场数据结构，还不知道哈希表，说明就是学了一个假的数据结构！
# 我们学了那么多数据结构，其中最最重要的数据结构就是哈希表！
# 1.工作中最常用到的数据结构（没有之一）
# 2.也是面试中非常高频的问题！
# 哈希表效率都是非常高的体现在于：哈希表这个结构被设计的非常巧妙，能够以"常数级"时间复杂度来完成增删改查
# "常数级"的理解：无论字典中有多少元素，新增，修改，查找，删除操作都是固定时间，不会因为元素多了，操作就慢了
# 固定时间 --> 是一个前提：字典中的 key 要求不能重复
# 而字典的遍历则效率就要差一些（虽说不擅长，但是Python还是提供了这样一个方式，以备不时之需）

5.2 理论

5.2.1 直接使用 for 循环能够获取到字典中的所有的 key，进一步的就可以取出每个值了

python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}

for key in student:
    print(key, student[key])

5.3 遍历相关最佳实践

python 复制代码 
# 字典的遍历

# 直接使用 for 循环来遍历字典
a = {
    'id' : 1,
    'name' : 'zhangsan',
    'score': 90
}

for key in a:   # 把每个键取出来，并且获取到每个键值对的键和值
    print(key,a[key])

在C++或者Java中，哈希表里面的键值对存储的顺序，是无序的，即插入顺序不一定是遍历出来的顺序。

换句话说：Python的字典说是一个哈希表，但是又不是一个单纯的哈希表，既是按照哈希表这样的方式来组织键对，（特殊处理）同时又有一个像队列一样的结构来控制先进先出（实现这样一个功能），有了这样一个顺序控制，我们就可以保证它是按照插入顺序来进行的。不过，我们还有其它办法来取出字典里的所有key、所有value以及所有键值对。我们在下一个部分马上介绍！

6 ~> 取出所有 key 和 value（三种方法，也能完成字典的变量）

这就是我们上面提到的还有其它办法来取出字典里的所有key、所有value以及所有键值对，这涉及到三个方法------

6.1 理论

6.1.1 使用keys方法可以获取到字典中的所有的 key

python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}

print(student.keys())

此处dict_keys是一个特殊的类型, 专门用来表示字典的所有 key。大部分元组支持的操作对于dict_keys同样适用。

6.1.2 使用values方法可以获取到字典中的所有 value

python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}

print(student.values())

此处dict_values也是一个特殊的类型, 和dict_keys类似。

6.1.3 使用items方法可以获取到字典中所有的键值对

python 复制代码 
student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}

print(student.items())

此处dict_items也是一个特殊的类型，和dict_keys类似。

6.2 最佳实践

6.2.1 获取到字典中的所有的 key

python 复制代码 
a = {
    'id' : 1,
    'name' : 'zhangsan',
    'score': 90
}
print(a.keys())

运行结果返回------

bash 复制代码 
dict_keys(['id', 'name', 'score'])


6.2.2 获取到字典中的所有 value

python 复制代码 
a = {
    'id' : 1,
    'name' : 'zhangsan',
    'score': 90
}

print(a.values())

运行结果返回------

bash 复制代码 
dict_values([1, 'zhangsan', 90])


6.2.3 获取到字典中所有的键值对

python 复制代码 
a = {
    'id' : 1,
    'name' : 'zhangsan',
    'score': 90
}
# print(a.keys())
# print(a.values())
print(a.items())

运行结果返回------

bash 复制代码 
dict_items([('id', 1), ('name', 'zhangsan'), ('score', 90)])


首先是一个列表一样的结构，里面每个元素又是一个元组，元组里面包含了键和值。

6.2.4 借助上面的方法也能完成对字典的遍历

总之，借助上面这几种方式也是可以完成字典的遍历，毕竟字典的key、value都获取到了，自然也能遍历。

python 复制代码 
# 借助上面的方法也一样能完成对字典的遍历
a = {
    'id' : 1,
    'name' : 'zhangsan',
    'score': 90
}

for key,value in a.items():
    print(key,value)

代码运行，返回结果------

bash 复制代码 
id 1
name zhangsan
score 90

和前面用 for 循环遍历的结果是一样的------

效果演示------


7 ~> 合法的 key 类型 / 可哈希的类型

7.1 理论

7.1.1 不是所有的类型都可以作为字典的key

不是所有的类型都可以作为字典的key。

字典本质上是一个哈希表，哈希表的key要求是"可哈希的"，也就是可以计算出一个哈希值。

可以使用hash函数计算某个对象的哈希值。

但凡能够计算出哈希值的类型，都可以作为字典的key。

python 复制代码 
print(hash(0))
print(hash(3.14))
print(hash('hello'))
print(hash(True))
print(hash(()))           # ( ) 是一个空的元组

7.1.2 列表无法计算哈希值

python 复制代码 
print(hash([1, 2, 3]))

7.1.3 字典也无法计算哈希值

python 复制代码 
print(hash({ 'id': 1 }))

7.2 最佳实践

python 复制代码 
# 可哈希的类型
# 使用 hash 函数能够计算出一个变量的哈希值
# hash 是一个内建函数，可以直接使用
print(hash(0))   # 0 的哈希值就是 0
print(hash(3.14))   # 浮点数
print(hash('hello')) # 字符串
print(hash(True)) # 布尔类型
print(hash((1,2,3))) # 元组

# 上面这些类型都是能够计算出哈希值的（都能作为字典的 key ）
# 有的类型是不能计算出哈希值的 ------> 列表、字典都是不可哈希的（不都能作为字典的 key ）
# print(hash([1,2,3,4]))  # list这样的类型会报错：TypeError: unhashable type: 'list'
# print(hash({})) # 字典类型不能计算哈希值：TypeError: unhashable type: 'dict'

# 什么样的类型是可哈希的？
# （1）不可变的对象，一般就是可哈希的
# （2）可变的对象，一般就是不可哈希的

8 ~> Python基础语法字典部分小结

字典也是一个常用的结构。字典的所有操作都是围绕 key 来展开的。

需要表示"键值对映射"这种场景时就可以考虑使用字典。

python 复制代码 
# 小结
# 字典，列表，元组 ------> Python中非常常用的内置类型，相比于int，str，float...
# 它们内部可以再包含其他元素了
# 容器 / 集合类
# 字典，列表，元组------>Python内部提供的容器

结尾

uu们，本文的内容到这里就全部结束了，艾莉丝再次感谢您的阅读！

结语：希望对学习Python相关内容的uu有所帮助，不要忘记给博主"一键四连"哦！

往期回顾：

【Python基础：语法第四课】列表和元组------Python 里的"爱情"：列表善变，元组长情

🗡博主在这里放了一只小狗，大家看完了摸摸小狗放松一下吧！🗡 ૮₍ ˶ ˊ ᴥ ˋ˶₎ა

相关推荐
向量引擎小橙2 小时前
GPT-5.2：深度解析AI的“能力跃迁”与未来生态变革
人工智能·gpt
xixixi777772 小时前
App反诈骗：一场面向移动生态的深度安全战争（接上文短信反诈）
安全·信息与通信·通信·电话反诈
后端小张2 小时前
【JAVA进阶】Docker 2025完全指南：从容器入门到企业级实践
java·运维·开发语言·spring·docker·容器·springboot
科技快报2 小时前
读屏、代点、跨应用，新形态AI 手机背后的基础设施是AI芯片
人工智能·智能手机
适应规律2 小时前
hook来获取模型每层的激活值输出
pytorch·python·深度学习
DeepFlow 零侵扰全栈可观测2 小时前
金山办公基于 DeepFlow docker 模式的可观测性实践
运维·docker·容器
盛世宏博北京2 小时前
弹药库房 “感知 - 传输 - 平台 - 应用” 四层架构温湿度监控方案
java·大数据·人工智能·弹药库房温湿度监控
驾驭人生2 小时前
SSH 服务部署 + Docker（指定版本）完整安装 的一体化操作流程
运维·docker·ssh
软件开发技术深度爱好者2 小时前
Python + Ursina设计一个有趣的3D小游戏
开发语言·python·3d
热门推荐
01GitHub 镜像站点02【AutoGLM部署】本地私有化部署AI手机Agent03UV安装并设置国内源04【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）05Open-AutoGLM Windows 安装部署教程06Cursor 又偷偷更新，这个功能太实用：Visual Editor for Cursor Browser07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08Linux下V2Ray安装配置指南09BongoCat - 跨平台键盘猫动画工具10Windows 11 官方系统安装与重装完整教程（2025年最新版）