Как определить и реализовать функцию, которая ведет себя как конструктор / обновление dict - PullRequest
Новая
       3

Как определить и реализовать функцию, которая ведет себя как конструктор / обновление dict

1 голос
/ 31 января 2020

dict s поддерживает несколько аргументов инициализации / обновления: 

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

Как написать подпись и обработать аргументы функции, которая обрабатывает один и тот же набор случаев?

Я пишу класс, который хочу поддерживать один и тот же набор аргументов, но просто сохранить список пар (key,value), чтобы можно было использовать несколько элементов с одним и тем же ключом. Я хотел бы иметь возможность добавлять к списку пар из диктов или списков пар или ключевых слов таким же образом, как для dict.

Реализация C обновления не мне не очень полезно, так как я реализую это в python.

Ответы [ 3 ]

1 голос
/ 01 февраля 2020

Это должно сработать: 

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)]
1 голос
/ 01 февраля 2020

Вот функция, которая должна вести себя так же, как и 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

Несколько замечаний:

  • Класс collection.ab c .Mapping не используется для тестирования объектов сопоставления, поскольку dict предъявляет более низкие требования, чем .
  • Подпись функция может быть определена более точно, используя только для позиционного синтаксиса , например: 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)

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'
0 голосов
/ 31 января 2020

Я не говорю, что это безопасный или отличный способ сделать это, но как насчет ... 

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