如何定义和实现一个行为类似于字典的函数 constructor/update

Question

dicts 支持几个 initialization/update 参数：

d = dict([('a',1), ('b',2)]) # list of (key,value)
d = dict({'a':1, 'b':2})     # copy of dict
d = dict(a=1, b=2)           #keywords

如何编写签名并处理处理同一组案例的函数的参数？

我正在写一个 class，我想支持相同的参数集，但只存储 (key,value) 对的列表，以允许多个项目具有相同的键。我希望能够以与 dict.

相同的方式添加到字典中的对列表，或对列表或关键字列表中

更新的 C 实现对我不是很有帮助，因为我在 python 中实现它。

Answer 1

我并不是说这是一种安全或很好的方法，但是...

def getPairs(*args, **kwargs):
    pairs = []
    for a in args:
        if type(a) == dict:
            pairs.extend([[key, val] for key, val in a.items()])
        elif type(a) == list:
            for a2 in a:
                if len(a2) > 1:
                    pairs.append([a2[0], a2[1:]])

    pairs.extend([[key, val] for key, val in kwargs.items()])

    return pairs

Answer 2

这应该可以解决问题：

class NewDict:
    def __init__(self, *args, **kwargs):
        self.items = []
        if kwargs:
            self.items = list(kwargs.items())
        elif args:
            if type(args[0]) == list:
                self.items = list(args[0])
            elif type(args[0]) == dict:
                self.items = list(args[0].items())

    def __repr__(self):
        s = "NewDict({"
        for i, (k,v) in enumerate(self.items):
            s += repr(k) + ": " + repr(v)
            if i < len(self.items) - 1:
                s += ", "
        s += "})"
        return s

d1 = NewDict()
d2 = NewDict([('a',1), ('b',2), ('a',2)])
d3 = NewDict({'a':1, 'b':2})
d4 = NewDict(a=1, b=2)

print(d1, d2, d3, d4, sep="\n")
print(d2.items)

输出：

NewDict({})
NewDict({'a': 1, 'b': 2, 'a': 2})
NewDict({'a': 1, 'b': 2})
NewDict({'a': 1, 'b': 2})
[('a', 1), ('b', 2), ('a', 2)]

Answer 3

这是一个与 dict 行为相同的函数（除了支持多个键的要求）：

def func(*args, **kwargs):
    result = []
    if len(args) > 1:
        raise TypeError('expected at most 1 argument, got 2')
    elif args:
        if all(hasattr(args[0], a) for a in ('keys', '__getitem__')):
            result.extend(dict(args[0]).items())
        else:
            for k, v in args[0]:
                hash(k)
                result.append((k, v))
    result.extend(kwargs.items())
    return result

一些注意事项：

collections.abc.Mapping class isn't used to test for mapping objects, because dict has lower requirements than that.
可以使用 positional-only syntax 更精确地定义函数的签名，如下所示：def func(x=None, /, **kwargs)。但是，这需要 Python >= 3.8，因此首选更向后兼容的解决方案。
该函数应该引发与 dict 相同的异常，但消息不会总是完全相同。

下面是一些简单的测试，将函数的行为与 dict 构造函数进行比较（尽管它并不试图涵盖所有可能性）：

def test(fn):
    d1 = {'a': 1, 'b': 2, 'c': 3}
    d2 = {'d': 4, 'e': 5, 'f': 6}
    class Maplike():
        def __getitem__(self, k):
            return d1[k]
        def keys(self):
            return d1.keys()

    print('test %s\n=========\n' % fn.__name__)
    print('dict:', fn(d1))
    print('maplike:', fn(Maplike()))
    print('seq:', fn(tuple(d1.items())))
    print('it:', fn(iter(d1.items())))
    print('gen:', fn(i for i in d1.items()))
    print('set:', fn(set(d2.items())))
    print('str:', fn(['fu', 'ba', 'r!']))
    print('kwargs:', fn(**d1))
    print('arg+kwargs:', fn(d1, **d2))
    print('dup-keys:', fn(d1, **d1))
    print('empty:', fn())
    print()
    try:
        fn(d1, d2)
        print('ERROR')
    except Exception as e:
        print('len-args: %s' % e)
    try:
        fn([(1, 2, 3)])
        print('ERROR')
    except Exception as e:
        print('pairs: %s' % e)
    try:
        fn([([], 3)])
        print('ERROR')
    except Exception as e:
        print('hashable: %s' % e)
    print()

test(func)
test(dict)

输出：

test func
=========

dict: [('a', 1), ('b', 2), ('c', 3)]
maplike: [('a', 1), ('b', 2), ('c', 3)]
seq: [('a', 1), ('b', 2), ('c', 3)]
it: [('a', 1), ('b', 2), ('c', 3)]
gen: [('a', 1), ('b', 2), ('c', 3)]
set: [('d', 4), ('e', 5), ('f', 6)]
str: [('f', 'u'), ('b', 'a'), ('r', '!')]
kwargs: [('a', 1), ('b', 2), ('c', 3)]
arg+kwargs: [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6)]
dup-keys: [('a', 1), ('b', 2), ('c', 3), ('a', 1), ('b', 2), ('c', 3)]
empty: []

len-args: expected at most 1 argument, got 2
pairs: too many values to unpack (expected 2)
hashable: unhashable type: 'list'

test dict
=========

dict: {'a': 1, 'b': 2, 'c': 3}
maplike: {'a': 1, 'b': 2, 'c': 3}
seq: {'a': 1, 'b': 2, 'c': 3}
it: {'a': 1, 'b': 2, 'c': 3}
gen: {'a': 1, 'b': 2, 'c': 3}
set: {'d': 4, 'e': 5, 'f': 6}
str: {'f': 'u', 'b': 'a', 'r': '!'}
kwargs: {'a': 1, 'b': 2, 'c': 3}
arg+kwargs: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
dup-keys: {'a': 1, 'b': 2, 'c': 3}
empty: {}

len-args: dict expected at most 1 argument, got 2
pairs: dictionary update sequence element #0 has length 3; 2 is required
hashable: unhashable type: 'list'

如何定义和实现一个行为类似于字典的函数 constructor/update

How to define and implement a function that behaves like the dict constructor/update

python

dictionary

function

signature