Python 字典详解

更新于 2026-01-11

Pozo Ramos

Python 字典是一种功能强大的内置数据类型，允许你以键值对（key-value pairs）的形式存储数据，从而实现高效的数据检索和操作。掌握字典对于希望高效处理数据的开发者至关重要。在本教程中，你将学习如何使用字面量和 dict() 构造函数创建字典，以及如何使用 Python 的运算符和内置函数来操作它们。

通过学习 Python 字典，你将能够通过键查找访问值，并使用各种方法修改字典内容。这些知识将帮助你在数据处理、配置管理以及处理 JSON 和 CSV 数据时更加得心应手。

学完本教程后，你将理解以下要点：

  • Python 中的字典是一个可变的键值对集合，允许通过唯一键高效检索数据。
  • 可以使用 {} 或 dict() 创建字典：{} 语法更简洁，而 dict() 更适合从可迭代对象动态创建字典。
  • dict() 是一个用于创建字典的类，但在 Python 中通常被称为内置函数。
  • .__dict__ 是 Python 中的一个特殊属性，它以字典形式保存对象的可写属性。
  • Python 的 dict 内部是基于哈希表（hashmap） 实现的，因此键查找速度非常快。

要充分利用本教程，你应该熟悉基本的 Python 语法和概念，如变量、循环和内置函数。具备基本 Python 数据类型的使用经验也会有所帮助。

初识 Python 字典

字典是 Python 最重要且最有用的内置数据类型之一。它提供了一个可变的键值对集合，让你可以通过对应的键高效地访问和修改值：

>>> config = {
...     "color": "green",
...     "width": 42,
...     "height": 100,
...     "font": "Courier",
... }

>>> # 通过键访问值
>>> config["color"]
'green'

>>> # 更新值
>>> config["font"] = "Helvetica"
>>> config
{
    'color': 'green',
    'width': 42,
    'height': 100,
    'font': 'Helvetica'
}

Python 字典由一系列键值对组成，每个键都对应一个关联的值。例如，"color" 是键，"green" 是其对应的值。

字典是 Python 的核心组成部分。你会发现它们广泛应用于作用域和命名空间等底层机制中，比如内置函数 globals() 和 locals()：

>>> globals()
{
    '__name__': '__main__',
    '__doc__': None,
    '__package__': None,
    ...
}

globals() 函数返回一个字典，其中包含当前全局作用域中名称到对象的映射。

Python 还使用字典来支持类的内部实现。考虑下面这个示例类：

>>> class Number:
...     def __init__(self, value):
...         self.value = value
...

>>> Number(42).__dict__
{'value': 42}

.__dict__ 是一个特殊属性，它以字典形式将属性名映射到对应的值。这种实现使得面向对象代码中的属性和方法查找既快速又高效。

你可以用字典解决许多编程任务，比如处理 CSV 和 JSON 文件、操作数据库、加载配置文件等。

Python 字典具有以下特性：

  • 可变（Mutable）：字典的值可以原地更新。
  • 动态（Dynamic）：字典可以根据需要增长或缩小。
  • 高效（Efficient）：基于哈希表实现，支持快速键查找。
  • 有序（Ordered）：从 Python 3.7 起，字典会保持插入顺序。

字典的键有一些限制：

  • 必须可哈希（Hashable）：不能使用列表等不可哈希对象作为键。
  • 必须唯一（Unique）：字典中不能有重复的键。

相比之下，字典的值没有任何限制。值可以是任意 Python 类型，包括其他字典，从而支持嵌套字典。

注意：有时你可能想先添加键，但暂时不确定对应的值。这时可以使用 .setdefault() 方法为键设置默认值或占位符。

在实践中，当你需要一个高效且可变的键值映射结构时，就可以使用字典。接下来，你将学习如何在 Python 代码中创建和使用字典。

创建 Python 字典

你可以通过多种方式创建 Python 字典，具体取决于你的需求。最常见的方式是使用字典字面量（用花括号 {} 包裹），另一种方式是使用 dict() 构造函数，它可以从可迭代对象、其他映射或关键字参数创建字典。不带参数调用时，dict() 会创建一个空字典。

使用字典字面量

你可以通过将逗号分隔的键值对放在花括号 {} 中来定义字典。键和值之间用冒号 : 分隔：

{
    <key_1>: <value_1>,
    <key_2>: <value_2>,
      ...,
    <key_N>: <value_N>,
}

键和值都是可选的，因此你可以用一对空花括号 {} 创建空字典。

键必须是可哈希对象，如数字、字符串或元组。可哈希意味着该对象可以传递给哈希函数。在 Python 中，所有内置的不可变类型都是可哈希的，而可变类型（如列表、集合、字典）则不可哈希。

注意：Python 集合（set）也使用花括号定义，但它们只包含元素而非键值对。要创建空集合，必须使用 set()，因为 {} 被保留用于空字典。

以下代码定义了一个将城市或州映射到美国职业棒球大联盟（MLB）球队的字典：

>>> MLB_teams = {
...     "Colorado": "Rockies",
...     "Chicago": "White Sox",
...     "Boston": "Red Sox",
...     "Minnesota": "Twins",
...     "Milwaukee": "Brewers",
...     "Seattle": "Mariners",
... }

你也可以使用整数、浮点数甚至布尔值作为键：

>>> {42: "aaa", 2.78: "bbb", True: "ccc"}
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

甚至可以使用类型或函数作为键：

>>> types = {int: 1, float: 2, bool: 3}
>>> types[float]
2
>>> types[bool]
3

但如果你尝试使用不可哈希对象（如列表）作为键，会报错：

>>> {[1, 2]: "A list as a key? Hmm..."}
Traceback (most recent call last):
    ...
TypeError: unhashable type: 'list'

这是因为列表是可变的，其哈希值会随内容变化，违反了哈希值必须恒定的要求。

如果需要用序列作为键，可以使用元组（tuple），因为元组是不可变的：

>>> a_dict = {(1, 1): "a", (1, 2): "b", (2, 1): "c", (2, 2): "d"}
>>> a_dict[(1, 1)]
'a'

但注意：即使元组本身不可变，如果它包含可变对象（如列表），也不能作为键：

>>> {(1, [1, 1]): "a"}
# 报错：TypeError: unhashable type: 'list'

字典不允许重复键。如果你为已有键赋新值，不会新增键，而是覆盖旧值：

>>> MLB_teams["Chicago"] = "Cubs"  # 覆盖 "White Sox"

同样，在字典字面量中重复定义同一键，后面的会覆盖前面的：

>>> MLB_teams = {"Chicago": "White Sox", "Chicago": "Cubs"}
>>> MLB_teams
{'Chicago': 'Cubs'}  # "White Sox" 被覆盖

与键不同，值没有限制，可以是任何类型，包括列表、集合、自定义对象等：

>>> {
...     "colors": ["red", "green", "blue"],
...     "plugins": {"py_code", "dev_sugar"},
...     "position": Point(42, 21),
... }

值也可以重复：

>>> {0: "a", 1: "a", 2: "a"}
{0: 'a', 1: 'a', 2: 'a'}  # 完全合法

使用 dict() 构造函数

dict() 构造函数支持多种调用方式：

dict()
dict(**kwargs)
dict(mapping, **kwargs)
dict(iterable, **kwargs)
  • 无参调用：dict() → {}（空字典）
  • 关键字参数（仅限字符串键）：
    >>> dict(Colorado="Rockies", Chicago="White Sox")
  • 从可迭代的键值对创建：
    >>> dict([("Colorado", "Rockies"), ("Chicago", "White Sox")])
  • 结合 zip() 函数：
    >>> places = ["Colorado", "Chicago"]
>>> teams = ["Rockies", "White Sox"]
>>> dict(zip(places, teams))

注意：使用关键字参数时，键必须是合法的 Python 标识符（即字符串且符合变量命名规则）。

使用 .fromkeys() 类方法

.fromkeys(iterable, value=None) 可以从一个键的可迭代对象和一个默认值创建字典：

>>> inventory = dict.fromkeys(["apple", "orange"], 0)
>>> inventory
{'apple': 0, 'orange': 0}

常用于初始化计数器或库存系统。

访问字典值

使用方括号 [] 通过键访问值：

>>> MLB_teams["Minnesota"]
'Twins'

如果键不存在，会抛出 KeyError：

>>> MLB_teams["Indianapolis"]
# KeyError: 'Indianapolis'

对于嵌套字典或列表，可以链式访问：

>>> person["children"][0]      # 访问嵌套列表
>>> person["pets"]["dog"]      # 访问嵌套字典

逐步填充字典

字典是动态的，可以随时添加键值对：

1. 手动赋值

>>> person = {}
>>> person["name"] = "John"

2. 在 for 循环中添加

>>> squares = {}
>>> for i in range(1, 5):
...     squares[i] = i**2

3. 使用字典推导式

>>> squares = {i: i**2 for i in range(1, 5)}

字典常用方法

获取数据

  • .get(key, default=None)：安全获取值，避免 KeyError
  • .keys()：返回所有键的视图
  • .values()：返回所有值的视图
  • .items()：返回所有键值对的视图（元组形式）

添加/更新

  • .setdefault(key, default)：若键不存在则设为默认值
  • .update(other)：合并另一个字典或键值对序列

删除数据

  • .pop(key[, default])：删除并返回值
  • .popitem()：删除并返回最后一个键值对（LIFO）
  • .clear()：清空字典

字典运算符

  • 成员测试：in / not in
    "Chicago" in MLB_teams          # 检查键
"Rockies" in MLB_teams.values() # 检查值
("Chicago", "Cubs") in MLB_teams.items()  # 检查键值对
  • 相等比较：== / !=（忽略顺序）
  • 合并操作（Python 3.9+）：
    • |：创建新字典（右优先）
    • |=：就地更新（类似 .update()）

内置函数与字典

函数 用途
len(d) 返回键值对数量
min(d), max(d) 返回最小/最大键（或对 .values() 操作）
sum(d.values()) 对数值求和
sorted(d) 返回排序后的键列表
all(d.values()) 检查所有值是否为真
any(d.values()) 检查是否有值为真

示例：按值排序字典

>>> students = {"Alice": 89.5, "Bob": 76.0}
>>> dict(sorted(students.items(), key=lambda x: x[1]))
# 按成绩升序

遍历字典

  • 遍历键：
    for key in d:          # 推荐
for key in d.keys():   # 显式但稍慢
  • 遍历值：
    for value in d.values():
  • 遍历键值对：
    for key, value in d.items():
    print(key, "->", value)

类字典容器（collections 模块）

  • defaultdict：访问不存在的键时自动创建默认值
    from collections import defaultdict
d = defaultdict(list)
d["a"].append(1)  # 自动初始化为 []
  • Counter：高效计数
    Counter("hello")  # {'l': 2, 'h': 1, 'e': 1, 'o': 1}
  • OrderedDict：在 Python 3.7+ 中已基本被普通字典取代（因字典已有序）

自定义类字典类

可通过继承 dict 或 collections.UserDict 创建自定义字典：

class SortableDict(dict):
    def sort_by_keys(self, reverse=False):
        sorted_items = sorted(self.items(), key=lambda x: x[0], reverse=reverse)
        self.clear()
        self.update(sorted_items)

总结

你已经深入学习了 Python 的 dict 类型，掌握了：

  • 使用字面量和 dict() 创建字典
  • 通过键访问和修改值
  • 使用方法（.get(), .update(), .pop() 等）操作字典
  • 利用运算符和内置函数处理字典
  • 遍历字典的不同方式
  • 使用 collections 中的高级字典类

字典是 Python 开发的核心技能，广泛应用于数据处理、配置管理、API 响应解析等场景。熟练掌握字典将极大提升你的编程效率和代码质量。