defaultdict의 default_factory에 키를 전달하는 영리한 방법이 있습니까?

defaultdict의 default_factory에 키를 전달하는 영리한 방법이 있습니까?

클래스에는 하나의 매개 변수를 사용하는 생성자가 있습니다.

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

코드의 어딘가에서 딕트의 값이 키를 아는 것이 유용합니다.
키가 신생아 기본값으로 전달된 기본 딕트를 사용합니다.

d = defaultdict(lambda : C(here_i_wish_the_key_to_be))

좋은 의견이라도 있나?

영리하다고 보기는 어렵지만, 하위 분류는 여러분의 친구입니다.

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)

아니요, 없습니다.

그defaultdict누락을 전달하도록 구현을 구성할 수 없습니다.key에게default_factory기성품의유일한 옵션은 고객의 요구 사항을 충족하는defaultdict위의 @Johen Ritzel이 제안한 바와 같이 하위 클래스.

그러나 이는 표준 라이브러리 솔루션만큼 "똑똑하지도 않고" 깨끗하지도 않습니다(존재하는 경우).따라서 귀하의 간결한 예/아니오 질문에 대한 대답은 분명히 "아니오"입니다.

표준 라이브러리에 이렇게 자주 필요한 도구가 없는 것은 유감입니다.

그럴 필요는 없을 것 같습니다defaultdict전혀 여기에그냥 사용하는 게 어때요?dict.setdefault방법?

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

그 의지는 물론 많은 예를 만들어 낼 것입니다.C문제가 되는 경우에는 더 간단한 접근 방식으로 다음을 수행할 수 있습니다.

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

그것은 그것보다 빠를 것입니다.defaultdict제가 볼 수 있는 한 다른 대안일 수도 있습니다.

속도 관련 ETAin테스트 대 try-except 절 사용:

>>> 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

저는 단지 조첸 리첼의 대답을 타자기를 행복하게 만드는 버전으로 확장하고 싶습니다.

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

다음은 자동으로 값을 추가하는 사전의 작업 예제입니다./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)))

잠재적으로 원하는 기능을 달성할 수 있는 또 다른 방법은 장식기를 사용하는 것입니다.

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)()

그건 좀 추한...그러나 이 문제를 피하고 복잡성의 정도를 도입하려면 다음과 같은 키워드 매개 변수를 추가할 수 있습니다.factory에게argument_wrapper일반적인 행동을 허용할 수 있습니다.

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]

언급URL : https://stackoverflow.com/questions/2912231/is-there-a-clever-way-to-pass-the-key-to-defaultdicts-default-factory