当前位置：首页 > news >正文

Python中的defaultdict方法

news 来源：原创 2025/5/19 0:58:34

文章目录

- - 核心特点
  - 基本语法
  - 常见使用场景
  - - 1. 分组数据（默认值为列表）
    - 2. 计数（默认值为整数）
    - 3. 集合操作（默认值为集合）
    - 4. 嵌套字典
  - 注意事项
  - 与普通字典对比
  - 总结
  - 1. 键（Key）的类型
  - 2. 值（Value）的类型
  - 3. `default_factory` 的返回值
  - 4. 嵌套 `defaultdict` 的键值
  - 5. 键和值的可变性总结
  - 常见问题解答
  - - Q1：可以用 `list` 作为键吗？
    - Q2：可以用 `defaultdict` 作为键吗？
    - Q3：值可以是函数或类吗？
  - 总结

在 Python 中， defaultdict 是 collections 模块提供的一个非常有用的类，它是内置字典类型 dict 的子类。 defaultdict 的主要特点是 自动处理字典中不存在的键，避免在使用普通字典时因访问不存在的键而抛出 KeyError 异常。

核心特点

自动初始化默认值：当访问一个不存在的键时，defaultdict 会调用指定的默认工厂函数（default_factory）生成一个初始值，确定了字典中值的类型。
简化代码：无需手动检查键是否存在，适合需要分组、统计或聚合数据的场景。

基本语法

from collections import defaultdictd = defaultdict(default_factory)

default_factory：一个可调用对象（如 list, int, set, str 或自定义函数），用于生成默认值。

常见使用场景

1. 分组数据（默认值为列表）

将数据按键分组，类似 SQL 的 GROUP BY：

from collections import defaultdictdata = [("apple", "fruit"), ("carrot", "vegetable"), ("apple", "fruit")]
grouped = defaultdict(list)for name, category in data:grouped[category].append(name)print(grouped)
# 输出：defaultdict(<class 'list'>, {'fruit': ['apple', 'apple'], 'vegetable': ['carrot']})

2. 计数（默认值为整数）

统计元素出现次数：

from collections import defaultdicttext = "apple banana apple orange banana"
words = text.split()
count = defaultdict(int)for word in words:count[word] += 1print(count)
# 输出：defaultdict(<class 'int'>, {'apple': 2, 'banana': 2, 'orange': 1})

3. 集合操作（默认值为集合）

避免重复值：

from collections import defaultdictpairs = [("a", 1), ("b", 2), ("a", 3)]
unique = defaultdict(set)for key, value in pairs:unique[key].add(value)print(unique)
# 输出：defaultdict(<class 'set'>, {'a': {1, 3}, 'b': {2}})

4. 嵌套字典

构建多层嵌套结构：

from collections import defaultdictnested = defaultdict(lambda: defaultdict(int))
nested["fruit"]["apple"] += 1
nested["vegetable"]["carrot"] += 2print(nested["fruit"])        # 输出：defaultdict(<class 'int'>, {'apple': 1})
print(nested["unknown_key"])  # 输出：defaultdict(<class 'int'>, {})

注意事项

default_factory 必须可调用：例如 list、int 是类（构造函数），而 list() 或 int() 的返回值不可作为工厂。
仅对 d[key] 有效：使用 d.get(key) 或 key in d 不会触发默认值生成。
性能：与普通字典性能接近，适合高频插入操作。

与普通字典对比

# 普通字典需要手动处理缺失键
d = {}
key = "unknown"
if key not in d:d[key] = []
d[key].append(1)# defaultdict 自动处理
d = defaultdict(list)
d["unknown"].append(1)

总结

defaultdict 简化了需要初始化默认值的字典操作，特别适合数据聚合、分组和统计场景。通过合理选择 default_factory（如 list、int、set 或自定义函数），可以大幅提升代码简洁性和可读性。

在 Python 中，defaultdict 继承自 dict，因此它的 键（Key）和值（Value）的类型规则与普通字典一致，但也有一些细节需要注意。以下是详细说明：

1. 键（Key）的类型

规则：键必须是 不可变类型（Immutable） 且 可哈希（Hashable）。
允许的类型：
- 基本类型：int, float, str, bool, None
- 不可变容器：tuple（但元组内的元素也必须不可变）
- frozenset（不可变集合）
- 用户自定义的不可变对象（需正确实现 __hash__ 和 __eq__ 方法）。
禁止的类型：
- 可变类型：list, dict, set
- 包含可变元素的 tuple（例如 (1, [2, 3])）。

示例：

from collections import defaultdict# 合法键
d = defaultdict(int)
d["apple"] = 10       # 字符串作为键 ✅
d[123] = 20          # 整数作为键 ✅
d[(1, 2)] = 30       # 不可变元组作为键 ✅# 非法键（会抛出 TypeError）
d[[1, 2]] = 40       # 列表不可哈希 ❌
d[{"a": 1}] = 50     # 字典不可哈希 ❌

2. 值（Value）的类型

规则：值可以是 任意类型，包括可变对象。
允许的类型：
- 基本类型（int, float, str 等）
- 可变容器（list, dict, set）
- 自定义对象、函数、类实例等。

示例：

from collections import defaultdict# 值可以是列表（可变）
d_list = defaultdict(list)
d_list["fruits"].append("apple")# 值可以是字典（可变）
d_dict = defaultdict(dict)
d_dict["data"]["count"] = 10# 值可以是自定义对象
class MyClass:passd_obj = defaultdict(MyClass)
obj = d_obj["instance"]  # 自动生成一个 MyClass 实例

3. `default_factory` 的返回值

default_factory 是一个可调用对象（如 list, int 或自定义函数），它决定了 当键不存在时，默认值的类型。例如：

defaultdict(list)：默认值是一个空列表（[]）。
defaultdict(int)：默认值是 0。
defaultdict(lambda: "unknown")：默认值是字符串 "unknown"。

值的类型完全由 default_factory 决定，与键的类型无关。

4. 嵌套 `defaultdict` 的键值

可以创建多层嵌套的 defaultdict，键的规则依然适用：

from collections import defaultdict# 嵌套 defaultdict（值类型是另一个 defaultdict）
nested = defaultdict(lambda: defaultdict(int))# 合法操作
nested["fruit"]["apple"] += 1      # 键为 "fruit"（字符串）和 "apple"（字符串）
nested[123][(4, 5)] = 2           # 键为 123（整数）和 (4, 5)（不可变元组）# 非法操作（内层键非法）
nested["data"][[1, 2]] = 3        # 内层键为列表，不可哈希 ❌

5. 键和值的可变性总结

特性	键（Key）	值（Value）
类型限制	必须不可变且可哈希	可以是任意类型
可变性	不可变	可以可变
示例	`int`, `str`, `tuple`	`list`, `dict`, 自定义对象

常见问题解答

Q1：可以用 `list` 作为键吗？

否。列表是可变类型，不可哈希。若需用类似列表的结构作为键，可以转换为不可变的 tuple。

Q2：可以用 `defaultdict` 作为键吗？

否。defaultdict 是可变对象，不可哈希。只有不可变类型（如 frozenset）可以作为键。

Q3：值可以是函数或类吗？

是。例如：

d = defaultdict(type)  # 默认值是类对象
d["my_class"] = MyClass

总结

键：必须为不可变且可哈希的类型（如 str, int, tuple）。
值：可以是任意类型（包括可变对象），具体由 default_factory 决定。
嵌套结构：可以自由嵌套 defaultdict，但需确保每一层的键合法。