Могу ли я использовать динамическое сопоставление для распаковки аргументов ключевых слов в Python?

В Python 2 вы можете сделать это, используя класс string.Formatter.

>>> class Mapping(object):
...     def __getitem__(self, key):
...         return 'Proxied: %s' % key
...
>>> my_mapping = Mapping()
>>> from string import Formatter
>>> Formatter().vformat('{Thing1} and {other_thing}', (), my_mapping)
'Proxied: Thing1 and Proxied: other_thing'
>>>

vformat принимает 3 аргумента: строку формата, последовательность позиционных полей и сопоставление полей ключевых слов. Поскольку позиционные поля не нужны, я использовал пустой кортеж ().

Питон 3.2+:

'{Thing1} and {other_thing}'.format_map(my_mapping)

Это может быть немного некромантии, но я недавно столкнулся с этой проблемой, и этот ТАК вопрос был первым результатом. Мне не понравилось использование string.Formatter, и я хотел, чтобы он просто работал (TM).

Если вы реализуете функцию keys() для своего класса, а также __getitem__(), то **my_mapping будет работать.

I.e:

class Mapping(object):

  def __getitem__(self, key):
    return 'Proxied: %s' % key

  def keys(self):
    return proxy.keys()

куда

>>> my_mapping = Mapping()
>>> my_mapping.keys()
['Thing1','other_thing',...,'Thing2']

приведет к успешному отображению, которое будет работать с .format.

По-видимому (хотя я на самом деле не просматривал источник str.format), похоже, он использует keys() для получения списка ключей, затем сопоставляет идентификаторы, указанные в строке, с этими ключами, а затем использует __getitem__() для получения указанных значений.

Надеюсь это поможет.

ИЗМЕНИТЬ:

Если вы находитесь в положении @aaron-mcmillin и набор ключей велик, то возможный подход состоит в том, чтобы не генерировать полный набор ключей, а генерировать меньший подмножество. Конечно, это работает только в том случае, если вы знаете, что вам нужно будет отформатировать только небольшое подмножество.

I.e:

class Mapping(object):
  ...
  def keys(self):
    return ['Thing1','other_thing', 'Thing2']

Это лучшее, что я мог придумать:

Если у вас есть пользовательский объект сопоставления, который вы хотите передать функции, принимающей аргументы ключевого слова, то он должен иметь набор ключей (который может быть сгенерирован динамически, но это должен быть конечный набор), и он должен иметь возможность как-то сопоставить эти ключи. Итак, если вы можете предположить, что у него будет __iter__ для получения ключей и __getitem__, который будет успешным для каждого из этих ключей, например:

class Me(object):
    def __init__(self):
        pass

    def __iter__(self):
        return iter(['a', 'b', 'c'])

    def __getitem__(self, key):
        return 12

Скажем, функция:

def myfunc(**kwargs):
    print kwargs, type(kwargs)

Затем мы можем передать его, сделав диктовку:

m = Me()
myfunc(**dict((k, m[k]) for k in m))

В результате чего:

{'a': 12, 'c': 12, 'b': 12} <type 'dict'>

По-видимому, так и должно быть... даже если вы передадите объект, производный от dict, функция все равно будет иметь dict для kwargs:

class Me(dict): pass

m = Me()
print type(m) #prints <class '__Main__.Me'>

def myfunc(**kwargs):
    print type(kwargs)
myfunc(**m) #prints <type 'dict'>

Поскольку похоже, что вы хотели сделать что-то вроде возврата значения на основе ключа, не имея в виду конкретный набор ключей, кажется, что вы не можете использовать функцию format.