使用 Python defaultdict 类型处理丢失的键

理解 Pythondefaultdict类型

Python 标准库提供了collections，它是一个实现专用容器类型的模块。其中之一是 Pythondefaultdict类型，它是dict专为帮助您解决丢失键而设计的替代方法。defaultdict是一种继承自的 Python 类型dict：

>>> from collections import defaultdict
>>> issubclass(defaultdict, dict)
True

上面的代码显示，Python的defaultdict类型是子类的dict。这意味着defaultdict继承了 的大部分行为dict。所以，你可以说这defaultdict很像一本普通的字典。

defaultdict和之间的主要区别在于dict，当您尝试访问或修改key字典中不存在的 时，value会自动为该提供默认值key。为了提供这个功能，Pythondefaultdict类型做了两件事：

1. 它覆盖.__missing__().
2. 它添加了.default_factory一个需要在实例化时提供的可写实例变量。

实例变量.default_factory将保存传入的第一个参数defaultdict.__init__()。此参数可以采用有效的 Python 可调用或None. 如果提供了可调用对象，则defaultdict每当您尝试访问或修改与缺失键关联的值时，它都会自动被调用。

看看如何创建和正确初始化 a defaultdict：

>>> # Correct instantiation
>>> def_dict = defaultdict(list)  # Pass list to .default_factory
>>> def_dict['one'] = 1  # Add a key-value pair
>>> def_dict['missing']  # Access a missing key returns an empty list
[]
>>> def_dict['another_missing'].append(4)  # Modify a missing key
>>> def_dict
defaultdict(<class 'list'>, {'one': 1, 'missing': [], 'another_missing': [4]})

在这里，您在创建字典时传递list到.default_factory。然后，您def_dict就像使用普通字典一样使用。请注意，当您尝试访问或修改映射到不存在的键的值时，字典会为其分配调用list().

请记住，您必须将有效的 Python 可调用对象传递给.default_factory，因此请记住不要在初始化时使用括号调用它。当您开始使用 Pythondefaultdict类型时，这可能是一个常见问题。看看下面的代码：

>>> # Wrong instantiation
>>> def_dict = defaultdict(list())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    def_dict = defaultdict(list())
TypeError: first argument must be callable or None

在这里，您尝试defaultdict通过传递list()给.default_factory. 对 的调用list()引发 a TypeError，它告诉您第一个参数必须是可调用的 or None。

通过对 Pythondefaultdict类型的介绍，您可以通过实际示例开始编码。接下来的几节将带您了解一些常见的用例，您可以在这些用例中依靠 adefaultdict提供优雅、高效和 Pythonic 的解决方案。

使用 Pythondefaultdict类型

有时候，你会使用内置集合一个可变的（一个list，dict或set）在你的Python字典值。在这些情况下，您需要在第一次使用前初始化密钥，否则您会得到一个KeyError. 您可以手动执行此过程，也可以使用 Python 自动执行此过程defaultdict。在本节中，您将学习如何使用 Pythondefaultdict类型来解决一些常见的编程问题：

• 将集合中的项目分组
• 计算集合中的项目
• 累积集合中的值

您将介绍一些使用list、set、int和float以用户友好且高效的方式执行分组、计数和累加操作的示例。

>>> from collections import defaultdict
>>> dd = defaultdict(list)
>>> dd['key'].append(1)
>>> dd
defaultdict(<class 'list'>, {'key': [1]})
>>> dd['key'].append(2)
>>> dd
defaultdict(<class 'list'>, {'key': [1, 2]})
>>> dd['key'].append(3)
>>> dd
defaultdict(<class 'list'>, {'key': [1, 2, 3]})

dep = [('Sales', 'John Doe'),
       ('Sales', 'Martin Smith'),
       ('Accounting', 'Jane Doe'),
       ('Marketing', 'Elizabeth Smith'),
       ('Marketing', 'Adam Doe')]

from collections import defaultdict

dep_dd = defaultdict(list)
for department, employee in dep:
    dep_dd[department].append(employee)

defaultdict(<class 'list'>, {'Sales': ['John Doe', 'Martin Smith'],
                             'Accounting' : ['Jane Doe'],
                             'Marketing': ['Elizabeth Smith', 'Adam Doe']})

dep_d = dict()
for department, employee in dep:
    dep_d.setdefault(department, []).append(employee)

对唯一项进行分组

继续使用上一节中的部门和员工数据。经过一些处理，您发现数据库中错误地复制了一些员工。您需要清理数据并从dep_dd字典中删除重复的员工。为此，您可以使用 a setas the.default_factory并按如下方式重写您的代码：

dep = [('Sales', 'John Doe'),
       ('Sales', 'Martin Smith'),
       ('Accounting', 'Jane Doe'),
       ('Marketing', 'Elizabeth Smith'),
       ('Marketing', 'Elizabeth Smith'),
       ('Marketing', 'Adam Doe'),
       ('Marketing', 'Adam Doe'),
       ('Marketing', 'Adam Doe')]

dep_dd = defaultdict(set)
for department, employee in dep:
    dep_dd[department].add(employee)

在本例中，您设置.default_factory为set。集合是唯一对象的集合，这意味着您不能创建set具有重复项的集合。这是集合的一个非常有趣的特性，它保证您在最终字典中不会有重复的项目。

计数项目

如果您设置.default_factory为int，那么您defaultdict将有助于计算序列或集合中的项目。当您int()不带参数调用时，该函数返回0，这是您用来初始化计数器的典型值。

继续以公司数据库为例，假设您要构建一个字典来计算每个部门的员工人数。在这种情况下，您可以编写如下代码：

>>> from collections import defaultdict
>>> dep = [('Sales', 'John Doe'),
...        ('Sales', 'Martin Smith'),
...        ('Accounting', 'Jane Doe'),
...        ('Marketing', 'Elizabeth Smith'),
...        ('Marketing', 'Adam Doe')]
>>> dd = defaultdict(int)
>>> for department, _ in dep:
...     dd[department] += 1
>>> dd
defaultdict(<class 'int'>, {'Sales': 2, 'Accounting': 1, 'Marketing': 2})

在这里，您设置.default_factory为int。int()不带参数调用时，返回值为0。您可以使用此默认值开始计算在每个部门工作的员工数。要使此代码正常工作，您需要一个干净的数据集。不得有重复数据。否则，您需要过滤掉重复的员工。

另一个计算项目的例子是计算mississippi一个单词中每个字母重复的次数。看看下面的代码：

>>> from collections import defaultdict
>>> s = 'mississippi'
>>> dd = defaultdict(int)
>>> for letter in s:
...     dd[letter] += 1
...
>>> dd
defaultdict(<class 'int'>, {'m': 1, 'i': 4, 's': 4, 'p': 2})

在上面的代码中，您创建了一个defaultdictwith .default_factoryset to int。这将任何给定键的默认值设置为0。然后，您使用for循环遍历字符串 s并使用增强赋值操作1在每次迭代中添加到计数器。ddwill的键是 中的字母mississippi。

由于计数是编程中相对常见的任务，Python 类字典类collections.Counter专门用于对序列中的项目进行计数。使用Counter，您可以编写mississippi如下示例：

>>> from collections import Counter
>>> counter = Counter('mississippi')
>>> counter
Counter({'i': 4, 's': 4, 'p': 2, 'm': 1})

在这种情况下，Counter为您完成所有工作！你只需要传入一个序列，字典就会计算它的项目，将它们存储为键，将计数存储为值。请注意，此示例有效，因为 Python 字符串也是序列类型。

累积值

有时您需要计算序列或集合中值的总和。假设您有以下Excel 表格，其中包含有关 Python 网站销售的数据：

接下来，您可以使用Python和得到如下处理数据list的tuple对象：

incomes = [('Books', 1250.00),
           ('Books', 1300.00),
           ('Books', 1420.00),
           ('Tutorials', 560.00),
           ('Tutorials', 630.00),
           ('Tutorials', 750.00),
           ('Courses', 2500.00),
           ('Courses', 2430.00),
           ('Courses', 2750.00),]

使用此数据，您希望计算每个产品的总收入。为此，您可以使用defaultdict带有floatas的 Python ，.default_factory然后编写如下代码：

 1from collections import defaultdict
 2
 3dd = defaultdict(float)
 4for product, income in incomes:
 5    dd[product] += income
 6
 7for product, income in dd.items():
 8    print(f'Total income for {product}: ${income:,.2f}')

下面是这段代码的作用：

• 在第 1 行中，您导入 Pythondefaultdict类型。
• 在第 3 行中，您创建了一个设置为的defaultdict对象。.default_factoryfloat
• 在第 4 行中，您定义了一个for循环来遍历 的项目incomes。
• 在第 5 行中，您使用增广赋值操作 ( +=) 来累积字典中每个产品的收入。

第二个循环遍历 的项目dd并将收入打印到您的屏幕上。

如果您将所有这些代码放入一个名为的文件中incomes.py并从命令行运行它，那么您将获得以下输出：

$ python3 incomes.py
Total income for Books: $3,970.00
Total income for Tutorials: $1,940.00
Total income for Courses: $7,680.00

您现在拥有每个产品的收入摘要，因此您可以决定遵循哪种策略来增加网站的总收入。

defaultdict 对比 dict

为了更好地理解 Pythondefaultdict类型，一个很好的练习是将它与其超类dict. 如果您想知道特定于 Pythondefaultdict类型的方法和属性，则可以运行以下代码行：

>>> set(dir(defaultdict)) - set(dir(dict))
{'__copy__', 'default_factory', '__missing__'}

在上面的代码，你可以使用dir()以获取有效的属性列表dict和defaultdict。然后，您使用set差异来获取只能在defaultdict. 如您所见，这两个类之间的区别是。您有两种方法和一种实例属性。下表显示了方法和属性的用途：

在上表中，你可以看到，做的方法和属性defaultdict从一个普通的不同dict。其余的方法在两个类中都是相同的。

此外，您可能会注意到 adefaultdict等于dict具有相同项的 a：

>>> std_dict = dict(numbers=[1, 2, 3], letters=['a', 'b', 'c'])
>>> std_dict
{'numbers': [1, 2, 3], 'letters': ['a', 'b', 'c']}
>>> def_dict = defaultdict(list, numbers=[1, 2, 3], letters=['a', 'b', 'c'])
>>> def_dict
defaultdict(<class 'list'>, {'numbers': [1, 2, 3], 'letters': ['a', 'b', 'c']})
>>> std_dict == def_dict
True

在这里，您创建一个std_dict包含一些任意项目的常规字典。然后，您defaultdict使用相同的项目创建一个。如果您测试两个词典的内容是否相等，那么您会发现它们是相等的。

defaultdict.default_factory

Pythondefaultdict类型的第一个参数必须是一个不带参数并返回一个值的可调用对象。此参数分配给实例属性，.default_factory。为此，您可以使用任何可调用对象，包括函数、方法、类、类型对象或任何其他有效的可调用对象。默认值.default_factory是None。

如果您在defaultdict不将值传递给 的情况下进行实例化.default_factory，则字典的行为将与常规类似dict，并且通常KeyError会因缺少键查找或修改尝试而引发：

>>> from collections import defaultdict
>>> dd = defaultdict()
>>> dd['missing_key']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    dd['missing_key']
KeyError: 'missing_key'

在这里，您将defaultdict不带参数地实例化 Python类型。在这种情况下，实例的行为类似于标准字典。因此，如果您尝试访问或修改丢失的密钥，那么您将获得通常的KeyError. 从现在开始，您可以将其dd用作普通的 Python 字典，除非您将新的可调用对象分配给 ，否则.default_factory您将无法使用defaultdict自动处理丢失的键的功能。

如果您传递None给 的第一个参数defaultdict，则该实例的行为与您在上述示例中看到的相同。那是因为.default_factory默认为None，所以两个初始化是等效的。另一方面，如果将有效的可调用对象传递给.default_factory，则可以使用它以用户友好的方式处理丢失的键。这是您传递list给的示例.default_factory：

>>> dd = defaultdict(list, letters=['a', 'b', 'c'])
>>> dd.default_factory
<class 'list'>
>>> dd
defaultdict(<class 'list'>, {'letters': ['a', 'b', 'c']})
>>> dd['numbers']
[]
>>> dd
defaultdict(<class 'list'>, {'letters': ['a', 'b', 'c'], 'numbers': []})
>>> dd['numbers'].append(1)
>>> dd
defaultdict(<class 'list'>, {'letters': ['a', 'b', 'c'], 'numbers': [1]})
>>> dd['numbers'] += [2, 3]
>>> dd
defaultdict(<class 'list'>, {'letters': ['a', 'b', 'c'], 'numbers': [1, 2, 3]})

在此示例中，您创建了一个defaultdict名为的 Python dd，然后将list其用作第一个参数。调用第二个参数letters并保存一个字母列表。您会看到，它.default_factory现在拥有一个list对象，当您需要value为任何丢失的键提供默认值时将调用该对象。

请注意，当您尝试访问时numbers，会dd测试是否numbers在字典中。如果不是，则调用.default_factory(). 由于.default_factory持有一个list对象，返回的value是一个空列表（[]）。

现在dd['numbers']已用空初始化list，您可以使用.append()将元素添加到list. 您还可以使用增强赋值运算符 ( +=) 来连接列表[1]和[2, 3]。这样，您可以以更 Pythonic 和更有效的方式处理丢失的键。

另一方面，如果您将不可调用的对象传递给Pythondefaultdict类型的初始化程序，那么您将TypeError在以下代码中得到类似的结果：

>>> defaultdict(0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    defaultdict(0)
TypeError: first argument must be callable or None

在这里，您传递0到.default_factory。由于0不是可调用对象，您会得到一个TypeError告诉您第一个参数必须是可调用的或None. 否则，defaultdict不起作用。

请记住，.default_factory它仅从.__getitem__()其他方法调用，而不是从其他方法调用。这意味着 if ddis a defaultdictand keyis a missing key, then dd[key]will call .default_factoryto provide a default value，但dd.get(key)仍然返回None而不是提供的值.default_factory。那是因为.get()没有调用.__getitem__()来检索key.

看看下面的代码：

>>> dd = defaultdict(list)
>>> # Calls dd.__getitem__('missing')
>>> dd['missing']
[]
>>> # Don't call dd.__getitem__('another_missing')
>>> print(dd.get('another_missing'))
None
>>> dd
defaultdict(<class 'list'>, {'missing': []})

在此代码片段中，您可以看到dd.get()返回None值而不是提供的默认值.default_factory。那是因为.default_factory只调用 from .__missing__()，而不调用.get().

请注意，您还可以向 Python 中添加任意值defaultdict。这意味着您不限于与由 生成的值具有相同类型的值.default_factory。下面是一个例子：

>>> dd = defaultdict(list)
>>> dd
defaultdict(<class 'list'>, {})
>>> dd['string'] = 'some string'
>>> dd
defaultdict(<class 'list'>, {'string': 'some string'})
>>> dd['list']
[]
>>> dd
defaultdict(<class 'list'>, {'string': 'some string', 'list': []})

在这里，您创建 adefaultdict并将list对象传递给.default_factory。这会将您的默认值设置为空列表。但是，您可以自由添加包含不同类型值的新键。key 就是这种情况string，它保存一个str对象而不是一个list对象。

最后，您始终可以像处理任何实例属性一样更改或更新最初分配给的可调用对象.default_factory：

>>> dd.default_factory = str
>>> dd['missing_key']
''

在上面的代码中，您.default_factory从更改list为str。现在，每当您尝试访问丢失的密钥时，您的默认值将是一个空字符串 ( '')。

根据您对 Pythondefaultdict类型的使用案例，您可能需要在完成创建后冻结字典并将其设为只读。为此，您可以在完成字典填充后设置.default_factory为None。这样，您的字典将表现得像一个标准dict，这意味着您将不会有更多自动生成的默认值。

模拟 Pythondefaultdict类型

在本节中，您将编写一个 Python 类，其行为与defaultdict. 为此，您将子类化collections.UserDict，然后添加.__missing__(). 此外，您需要添加一个名为 的实例属性.default_factory，它将保存可调用以按需生成默认值。这是一段模拟 Pythondefaultdict类型的大部分行为的代码：

 1import collections
 2
 3class my_defaultdict(collections.UserDict):
 4    def __init__(self, default_factory=None, *args, **kwargs):
 5        super().__init__(*args, **kwargs)
 6        if not callable(default_factory) and default_factory is not None:
 7            raise TypeError('first argument must be callable or None')
 8        self.default_factory = default_factory
 9
10    def __missing__(self, key):
11        if self.default_factory is None:
12            raise KeyError(key)
13        if key not in self:
14            self[key] = self.default_factory()
15        return self[key]

下面是这段代码的工作原理：

• 在第 1 行中，您导入collections以访问UserDict.

• 在第 3 行中，您创建了一个子类化的类UserDict。

• 在第 4 行中，您定义了类初始值设定项.__init__()。此方法采用一个被default_factory调用的参数来保存您将用于生成默认值的可调用对象。请注意，default_factory默认为None，就像在defaultdict. 您还需要*args和**kwargs来模拟常规dict.

• 在第 5 行，您调用超类.__init__()。这意味着，我们在调用UserDict.__init__()和传递*args，并**kwargs给它。

• 在第 6 行，您首先检查是否default_factory是有效的可调用对象。在这种情况下，您使用callable(object)，它是一个内置函数，True如果object看起来是可调用的则返回，否则返回False。此检查可确保您.default_factory()在需要value为任何缺失的key. 然后，您检查是否.default_factory不是None。

• 在第 7 行中，您提出 aTypeError就像普通人dict会做的 if default_factoryis 一样None。

• 在第 8 行中，您初始化.default_factory.

• 在第 10 行，您定义了.__missing__()，正如您之前看到的那样实现。回想一下，当给定的字典不在字典中时，它.__missing__()会自动调用。.__getitem__()key

如果您有心情阅读一些C代码，那么您可以查看CPython 源代码中Python类型的完整代码。defaultdict

现在您已经完成了这个类的编码，您可以通过将代码放入一个名为的 Python 脚本中my_dd.py并从交互式会话中导入它来测试它。下面是一个例子：

>>> from my_dd import my_defaultdict
>>> dd_one = my_defaultdict(list)
>>> dd_one
{}
>>> dd_one['missing']
[]
>>> dd_one
{'missing': []}
>>> dd_one.default_factory = int
>>> dd_one['another_missing']
0
>>> dd_one
{'missing': [], 'another_missing': 0}
>>> dd_two = my_defaultdict(None)
>>> dd_two['missing']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    dd_two['missing']
  File "/home/user/my_dd.py", line 10,
 in __missing__
    raise KeyError(key)
KeyError: 'missing'

在这里，您首先my_defaultdict从my_dd. 然后，您创建 的实例my_defaultdict并传递list给.default_factory。如果您尝试通过订阅操作访问密钥，例如dd_one['missing']，则.__getitem__()Python 会自动调用。如果键不在字典中，则.__missing__()调用它，它通过调用生成一个默认值.default_factory()。

您还可以.default_factory使用正常的分配操作更改分配给的可调用对象，例如dd_one.default_factory = int。最后，如果您传递None给.default_factory，那么您将KeyError在尝试检索丢失的密钥时得到 。

您可能想知道为什么在此示例中使用子类collections.UserDict而不是常规dict。这样做的主要原因是对内置类型进行子类化可能容易出错，因为内置类型的 C 代码似乎不会始终如一地调用由用户覆盖的特殊方法。

这是一个示例，显示了在子类化时可能面临的一些问题dict：

>>> class MyDict(dict):
...     def __setitem__(self, key, value):
...         super().__setitem__(key, None)
...
>>> my_dict = MyDict(first=1)
>>> my_dict
{'first': 1}
>>> my_dict['second'] = 2
>>> my_dict
{'first': 1, 'second': None}
>>> my_dict.setdefault('third', 3)
3
>>> my_dict
{'first': 1, 'second': None, 'third': 3}

在本例中，您创建MyDict，它是一个子类化 的类dict。您的实现.__setitem__()始终将值设置为None. 如果您创建一个实例MyDict并将关键字参数传递给它的初始值设定项，那么您会注意到该类没有调用您.__setitem__()来处理分配。您知道这是因为first未分配密钥None。

相比之下，如果您运行像 那样的订阅操作my_dict['second'] = 2，那么您会注意到它second设置为None而不是2。所以，这一次您可以说订阅操作调用您的自定义.__setitem__(). 最后，请注意.setdefault()也不会调用.__setitem__()，因为您的third键最终的值为3。

UserDict不继承dict但模拟标准字典的行为。该类有一个dict名为的内部实例.data，用于存储字典的内容。UserDict在创建自定义映射时是一个更可靠的类。如果您使用UserDict，那么您将避免之前看到的问题。为了证明这一点，回到代码my_defaultdict并添加以下方法：

 1class my_defaultdict(collections.UserDict):
 2    # Snip
 3    def __setitem__(self, key, value):
 4        print('__setitem__() gets called')
 5        super().__setitem__(key, None)

在这里，您添加一个.__setitem__()调用 superclass的自定义.__setitem__()，它始终将值设置为None。在您的脚本中更新此代码my_dd.py并从交互式会话中导入它，如下所示：

>>> from my_dd import my_defaultdict
>>> my_dict = my_defaultdict(list, first=1)
__setitem__() gets called
>>> my_dict
{'first': None}
>>> my_dict['second'] = 2
__setitem__() gets called
>>> my_dict
{'first': None, 'second': None}

在这种情况下，当您实例化my_defaultdict并传递first给类初始值设定项时，您的自定义__setitem__()会被调用。此外，当您为 key 分配一个值时second，__setitem__()也会被调用。您现在有一个my_defaultdict始终调用您的自定义特殊方法的方法。请注意，字典中的所有值都等于None现在。

将参数传递给 .default_factory

正如您之前看到的，.default_factory必须设置为一个不带参数并返回值的可调用对象。该值将用于为字典中任何缺失的键提供默认值。即使.default_factory不应该接受参数，Python 也提供了一些技巧，您可以在需要为其提供参数时使用这些技巧。在本节中，您将介绍两种可用于此目的的 Python 工具：

1. lambda
2. functools.partial()

使用这两个工具，您可以为 Pythondefaultdict类型增加额外的灵活性。例如，您可以使用一个defaultdict带有参数的可调用对象初始化 a ，经过一些处理后，您可以使用新参数更新可调用对象，以更改您将从此时起创建的键的默认值。

>>> def factory(arg):
...     # Do some processing here...
...     result = arg.upper()
...     return result
...
>>> def_dict = defaultdict(lambda: factory('default value'))
>>> def_dict['missing']
'DEFAULT VALUE'

>>> def_dict.default_factory = lambda: factory('another default value')
>>> def_dict['another_missing']
'ANOTHER DEFAULT VALUE'

>>> from collections import defaultdict
>>> lst = [1, 1, 2, 1, 2, 2, 3, 4, 3, 3, 4, 4]
>>> def_dict = defaultdict(lambda: 1)
>>> for number in lst:
...     def_dict[number] *= number
...
>>> def_dict
defaultdict(<function <lambda> at 0x...70>, {1: 1, 2: 8, 3: 27, 4: 64})

>>> def factory(arg):
...     # Do some processing here...
...     result = arg.upper()
...     return result
...
>>> from functools import partial
>>> def_dict = defaultdict(partial(factory, 'default value'))
>>> def_dict['missing']
'DEFAULT VALUE'
>>> def_dict.default_factory = partial(factory, 'another default value')
>>> def_dict['another_missing']
'ANOTHER DEFAULT VALUE'

结论

Pythondefaultdict类型是 Python 标准库在名为collections. 该类继承自dict，其主要附加功能是为缺失的键提供默认值。在本教程中，您学习了如何使用 Pythondefaultdict类型来处理字典中缺失的键。

您现在可以：

• 创建并使用Pythondefaultdict来处理丢失的键
• 解决与分组、计数和累加操作相关的实际问题
• 了解defaultdict和之间的实现差异dict
• 决定何时以及为何使用 Pythondefaultdict而不是标准dict

Pythondefaultdict类型是一种方便且高效的数据结构，旨在帮助您处理字典中缺少的键。试一试，让你的代码更快、更易读、更 Pythonic！