Có cách nào thông minh để chuyển khóa đến default_factory của defaultdict không?

Một lớp có một hàm tạo nhận một tham số:

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

Ở đâu đó trong mã, sẽ rất hữu ích cho các giá trị trong một lệnh để biết các khóa của chúng.
Tôi muốn sử dụng một sắc lệnh mặc định với khóa được truyền cho các giá trị mặc định mới sinh:

d = defaultdict(lambda : C(here_i_wish_the_key_to_be))

Bất kỳ đề xuất?

Nó hầu như không đủ tiêu chuẩn là thông minh - nhưng phân lớp là bạn của bạn:

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)

Không có.

Việc defaultdicttriển khai không thể được định cấu hình để chuyển phần thiếu keyvào default_factoryhộp. Tùy chọn duy nhất của bạn là triển khai defaultdictlớp con của riêng bạn , như được đề xuất bởi @JochenRitzel ở trên.

Nhưng điều đó không "thông minh" hoặc gần như sạch sẽ như một giải pháp thư viện tiêu chuẩn sẽ là (nếu nó tồn tại). Do đó, câu trả lời ngắn gọn cho câu hỏi có / không của bạn rõ ràng là "Không".

Thật tệ là thư viện chuẩn đang thiếu một công cụ thường xuyên cần thiết như vậy.

Tôi không nghĩ bạn cần defaultdictở đây chút nào. Tại sao không chỉ sử dụng dict.setdefaultphương pháp?

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

Điều đó tất nhiên sẽ tạo ra nhiều trường hợp C. Trong trường hợp đó là một vấn đề, tôi nghĩ rằng cách tiếp cận đơn giản hơn sẽ làm:

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

Nó sẽ nhanh hơn defaultdicthoặc bất kỳ thay thế nào khác theo như tôi có thể thấy.

ETA liên quan đến tốc độ inkiểm tra so với sử dụng điều khoản thử ngoại trừ:

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

Đây là một ví dụ hoạt động của từ điển tự động thêm giá trị. Nhiệm vụ trình diễn trong việc tìm kiếm các tệp trùng lặp trong / usr / include. Lưu ý rằng từ điển tùy chỉnh PathDict chỉ yêu cầu bốn dòng:

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