有没有一种聪明的方法将键传递给defaultdict的default_factory？

Question

一个类有一个构造函数，它接受一个参数：

class C(object):
    def __init__(self, v):
        self.v = v
        ...

在代码的某个地方，对于字典中的值来说知道它们的键是很有用的。
我想使用一个defaultdict，并将键传递给新生默认值：

在代码中，有时需要知道字典中各个值所对应的键。为了实现这一点，我想要使用defaultdict，并且希望将传入的键作为新建条目的默认值：

d = defaultdict(lambda : C(here_i_wish_the_key_to_be))

有什么建议吗？

- Benjamin Nitlehoo

Answer 1

虽然这并不能算得上“聪明”，但是子类化可以帮助你实现目标：

class keydefaultdict(defaultdict):
    def __missing__(self, key):
        if self.default_factory is None:
            raise KeyError( key )
        else:
            ret = self[key] = self.default_factory(key)
            return ret

d = keydefaultdict(C)
d[x] # returns C(x)

- Jochen Ritzel

---

这正是我试图避免的丑陋情况... 即使使用一个简单的字典并检查键是否存在，也要更加简洁。 - Benjamin Nitlehoo

@Paul：然而这就是你的答案。丑陋？得了吧！ - tzot

我想把那段代码放到我的个人通用工具模块中，这样我就可以随时使用它了。这样做不会太丑陋... - weronika

+1 直接回答了 OP 的问题，对我来说看起来也不“丑陋”。此外，这是一个好的答案，因为许多人似乎没有意识到 defaultdict 的 __missing__() 方法可以被覆盖（自 2.5 版本以来，在任何内置 dict 类的子类中都可以）。 - martineau

missing 的整个目的是为了自定义在字典中查找缺失键时的行为。@silentghost 提到的 dict.setdefault() 方法也可以实现同样的效果（优点是 setdefault() 函数简短且已存在；缺点是它在效率上存在问题，而且没有人真正喜欢“setdefault”这个名称）。 - Raymond Hettinger

Answer 2

不，没有这样的功能。

defaultdict 实现不能直接配置传递缺失的 key 到 default_factory。你唯一的选择是像 @JochenRitzel 建议的那样实现自己的 defaultdict 子类。

但这并不像标准库中存在的解决方案一样“巧妙”或简洁。 因此，对于你简洁明了的问题，“是/否”的答案显然是“否”。

很遗憾标准库缺少如此频繁需要的工具。

- Stuart Berg

---

是的，让工厂使用键（一元函数而不是无元函数）会是更好的设计选择。当我们想要返回常量时，很容易丢弃参数。 - YvesgereY

尽管简洁是一个可以接受的目标（混淆术语和“大词汇”也很简洁），但当启动一些自动内置程序时（比如在构造函数中设置对象引用缓存）我认为defaultdict是必需的而不仅仅是好用的。如果没有与键的连接，defaultdict将远不如它本应该有的那么有用，并且很难用“丑陋”的解决方案替代。 - Chris

Answer 3

我只是想在Jochen Ritzel的答案基础上进行扩展，提供一个可以让类型检查器满意的版本：

from typing import Callable, TypeVar

K = TypeVar("K")
V = TypeVar("V")

class keydefaultdict(dict[K, V]):
    def __init__(self, default_factory: Callable[[K], V]):
        super().__init__()
        self.default_factory = default_factory

    def __missing__(self, key: K) -> V:
        if self.default_factory is None:
            raise KeyError(key)
        else:
            ret = self[key] = self.default_factory(key)
            return ret

- Paulo Costa

Answer 4

我认为在这里你根本不需要使用 defaultdict。为什么不直接使用 dict.setdefault 方法呢？

>>> d = {}
>>> d.setdefault('p', C('p')).v
'p'

当然，这会创建许多C的实例。如果这是一个问题，我认为简单的方法会更好：

>>> d = {}
>>> if 'e' not in d: d['e'] = C('e')

据我所见，与defaultdict或其他任何替代方案相比，这将更快。

关于使用in测试和使用try-except子句速度的预计时间到达（ETA）：

>>> def g():
    d = {}
    if 'a' in d:
        return d['a']


>>> timeit.timeit(g)
0.19638929363557622
>>> def f():
    d = {}
    try:
        return d['a']
    except KeyError:
        return


>>> timeit.timeit(f)
0.6167065411074759
>>> def k():
    d = {'a': 2}
    if 'a' in d:
        return d['a']


>>> timeit.timeit(k)
0.30074866358404506
>>> def p():
    d = {'a': 2}
    try:
        return d['a']
    except KeyError:
        return


>>> timeit.timeit(p)
0.28588609450770264

- SilentGhost

---

在访问d时，如果频繁访问且很少缺少键，则使用C(key)方法会造成极大的浪费：这将会创建大量不必要的对象供垃圾回收器收集。此外，在我的情况下，创建新的C对象也很慢，这是一种额外的痛苦。 - Benjamin Nitlehoo

我不确定它是否比defaultdict更快，但这是我通常做的事情（请参见我对THC4k答案的评论）。我希望有一种简单的方法来绕过default_factory不接受参数的事实，以使代码稍微更加优雅。 - Benjamin Nitlehoo

@SilentGhost：我不明白，这怎么解决OP的问题？我认为OP想要任何尝试读取d[key]都返回d[key] = C(key)，如果key not in d。但是你的解决方案要求他事先去预设d[key]？他怎么知道他需要哪个key？ - max

太棒了！没有丑陋的代码，只使用标准字典：D.setdefault(k[,d]) -> D.get(k,d)，同时如果k不在D中，则设置D[k]=d。 - Muposat

因为 setdefault 方法太难看了，而且 collection 模块中的 defaultdict 应该支持一个接收键值的工厂函数。Python 设计者们错过了这么好的机会！ - jgomo3

Answer 5

这是一个自动添加值的字典工作示例。演示任务是在 /usr/include 中查找重复文件。请注意，仅需要四行自定义字典 PathDict：

class FullPaths:

    def __init__(self,filename):
        self.filename = filename
        self.paths = set()

    def record_path(self,path):
        self.paths.add(path)

class PathDict(dict):

    def __missing__(self, key):
        ret = self[key] = FullPaths(key)
        return ret

if __name__ == "__main__":
    pathdict = PathDict()
    for root, _, files in os.walk('/usr/include'):
        for f in files:
            path = os.path.join(root,f)
            pathdict[f].record_path(path)
    for fullpath in pathdict.values():
        if len(fullpath.paths) > 1:
            print("{} located in {}".format(fullpath.filename,','.join(fullpath.paths)))

- gerardw

Answer 6

你可以使用装饰器来达到所需的功能。

def initializer(cls: type):
    def argument_wrapper(
        *args: Tuple[Any], **kwargs: Dict[str, Any]
    ) -> Callable[[], 'X']:
        def wrapper():
            return cls(*args, **kwargs)

        return wrapper

    return argument_wrapper


@initializer
class X:
    def __init__(self, *, some_key: int, foo: int = 10, bar: int = 20) -> None:
        self._some_key = some_key
        self._foo = foo
        self._bar = bar

    @property
    def key(self) -> int:
        return self._some_key

    @property
    def foo(self) -> int:
        return self._foo

    @property
    def bar(self) -> int:
        return self._bar

    def __str__(self) -> str:
        return f'[Key: {self.key}, Foo: {self.foo}, Bar: {self.bar}]'

然后你可以这样创建一个 defaultdict：

>>> d = defaultdict(X(some_key=10, foo=15, bar=20))
>>> d['baz']
[Key: 10, Foo: 15, Bar: 20]
>>> d['qux']
[Key: 10, Foo: 15, Bar: 20]

default_factory 将使用指定的参数创建 X 的新实例。

当然，这只有在您知道该类将用于 default_factory 时才有用。否则，为了实例化一个单独的类，您需要执行类似以下操作：

x = X(some_key=10, foo=15)()

这有点丑... 但如果你想避免这种情况，并引入一定程度的复杂性，你也可以向 argument_wrapper 添加一个关键字参数，比如 factory，以实现通用行为：

def initializer(cls: type):
    def argument_wrapper(
        *args: Tuple[Any], factory: bool = False, **kwargs: Dict[str, Any]
    ) -> Callable[[], 'X']:
        def wrapper():
            return cls(*args, **kwargs)

        if factory:
            return wrapper
        return cls(*args, **kwargs)

    return argument_wrapper

然后你可以这样使用该类：

>>> X(some_key=10, foo=15)
[Key: 10, Foo: 15, Bar: 20]
>>> d = defaultdict(X(some_key=15, foo=15, bar=25, factory=True))
>>> d['baz']
[Key: 15, Foo: 15, Bar: 25]

- Jake