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

Question

dicts support several initialization/update arguments:

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

How do I write the signature and handle the arguments of a function that handles the same set of cases?

I'm writing a class that I want to support the same set of arguments, but just store the list of (key,value) pairs in order to allow for multiple items with the same key. I'd like to be able to add to the list of pairs from dicts, or lists of pairs or keywords in a way that is the same as for dict.

The C implementation of update isn't very helpful to me as I'm implementing this in python.

Answer 1

Here is a function that should behave the same as dict (except for the requirement to support multiple keys):

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

A few notes:

• The collections.abc.Mapping class isn't used to test for mapping objects, because dict has lower requirements than that.
• The signature of the function could be defined more precisely using positional-only syntax, like this: def func(x=None, /, **kwargs). However, that requires Python >= 3.8, so a more backwards-compatible solution has been preferred.
• The function should raise the same exceptions as dict, but the messages won't always be exactly the same.

Below are some simple tests that compare the behaviour of the function with the dict constructor (although it does not attempt to cover every possibility):

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)

Ouput:

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'

Answer 2

This should do the trick:

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)

Output:

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

I'm not saying this is a safe or great way to do this, but how about ...

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