python - 列表理解从元组列表构建嵌套字典

Question

我有从数据库中获取的 user_id 和 analysis_type_id 索引的数据(计数)。这是一个三元组的列表。示例数据:

counts  = [(4, 1, 4), (3, 5, 4), (2, 10, 4), (2, 10, 5)]

每个元组的第一项是 count，第二项是 analysis_type_id，最后一项是 user_id。

我想把它放入字典中，这样我就可以快速检索计数:给定 user_id 和 analysis_type_id。它必须是一个二级字典。有没有更好的结构？

要“手动”构建二级字典，我会编写代码:

dict = {4:{1:4,5:3,10:2},5:{10:2}}

其中user_id是第一个dict键级，analysis_type_id是第二个(子)键，count是里面的值字典。

我如何通过列表理解在字典键中创建“双深度”？或者我是否需要求助于嵌套的 for 循环，我首先遍历唯一的 user_id 值，然后找到匹配的 analysis_type_id 并填写计数......一-一次进入字典？

Answer 1

两个元组键

我会建议放弃嵌套字典的想法，直接使用两个元组作为键。像这样:

d = { (user_id, analysis_type_id): count for count, analysis_type_id, user_id in counts}

字典是一个哈希表。在 python 中，每两个元组都有一个散列值(不是两个散列值)，因此每两个元组都是根据其(相对)唯一的散列来查找的。因此，这比查找两个单独键的散列(首先是 user_id，然后是 analysis_type_id)更快(大多数情况下快 2 倍)。

然而，beware of premature optimization .除非您进行数百万次查找，否则平面 dict 的性能提升不太可能重要。赞成在这里使用二元组的真正原因是二元组解决方案的语法和可读性远远优于其他解决方案——也就是说，假设绝大多数时间您都希望访问基于一对值，而不是基于单个值的项目组。

考虑使用namedtuple

创建一个命名元组来存储这些键可能会很方便。这样做:

from collections import namedtuple
IdPair = namedtuple("IdPair", "user_id, analysis_type_id")

然后在你的字典理解中使用它:

d = { IdPair(user_id, analysis_type_id): count for count, analysis_type_id, user_id in counts}

然后像这样访问您感兴趣的计数:

somepair = IdPair(user_id = 4, analysis_type_id = 1)
d[somepair]

这有时有用的原因是您可以这样做:

user_id = somepair.user_id # very nice syntax

---

一些其他有用的选项

上述解决方案的一个缺点是查找失败。在这种情况下，您只会得到如下回溯:

>>> d[IdPair(0,0)]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: IdPair(user_id=0, analysis_type_id=0)

这不是很有帮助；是 user_id 不匹配，还是 analysis_type_id，或两者兼而有之？

您可以通过创建自己的 dict 类型来为自己创建一个更好的工具，该类型可以为您提供包含更多信息的良好回溯。它可能看起来像这样:

class CountsDict(dict):
    """A dict for storing IdPair keys and count values as integers.

    Provides more detailed traceback information than a regular dict.
    """
    def __getitem__(self, k):
        try:
            return super().__getitem__(k)
        except KeyError as exc:
            raise self._handle_bad_key(k, exc) from exc
    def _handle_bad_key(self, k, exc):
        """Provides a custom exception when a bad key is given."""
        try:
            user_id, analysis_type_id = k
        except:
            return exc
        has_u_id = next((True for u_id, _ in self if u_id==user_id), False)
        has_at_id  = next((True for _, at_id in self if at_id==analysis_type_id), False)
        exc_lookup = {(False, False):KeyError(f"CountsDict missing pair: {k}"),
                      (True, False):KeyError(f"CountsDict missing analysis_type_id: "
                                             f"{analysis_type_id}"),
                      (False, True):KeyError(f"CountsDict missing user_id: {user_id}")}
        return exc_lookup[(user_id, analysis_type_id)]

像普通的 dict 一样使用它。

但是，当您尝试访问丢失的对时，将新对添加到您的 dict(计数为零)可能更有意义。如果是这种情况，我会使用 defaultdict 并在缺少键时将计数设置为零(使用 int 的默认值作为工厂函数)被访问。像这样:

from collections import defaultdict
my_dict = defaultdict(default_factory=int, 
                      ((user_id, analysis_type_id), count) for count, analysis_type_id, user_id in counts))

现在，如果您尝试访问丢失的 key ，计数将设置为零。但是，此 方法的一个问题是所有键都将设置为零:

value = my_dict['I'm not a two tuple, sucka!!!!'] # <-- will be added to my_dict

为了防止这种情况，我们回到制作 CountsDict 的想法，除了在这种情况下，您的特殊 dict 将是 defaultdict< 的子类。然而，与常规的 defaultdict 不同，它会在添加之前检查以确保 key 是有效的类型。作为奖励，我们可以确保添加为键的任何两个元组成为 IdPair。

from collections import defaultdict

class CountsDict(defaultdict):
    """A dict for storing IdPair keys and count values as integers.

    Missing two-tuple keys are converted to an IdPair. Invalid keys raise a KeyError.
    """
    def __getitem__(self, k):
        try:
            user_id, analysis_type_id = k
        except:
            raise KeyError(f"The provided key {k!r} is not a valid key.")
        else:
            # convert two tuple to an IdPair if it was not already
            k = IdPair(user_id, analysis_type_id)
        return super().__getitem__(k)

像普通的 defaultdict 一样使用它:

my_dict = CountsDict(default_factory=int, 
                     ((user_id, analysis_type_id), count) for count, analysis_type_id, user_id in counts))

注意:在上面我没有做到在实例创建时将两个元组键转换为 IdPair(因为在实例创建期间未使用 __setitem__) .要创建此功能，我们还需要实现 __init__ 方法的覆盖。

总结

在所有这些中，更有用的选项完全取决于您的用例。