Правильный способ использования ** kwargs в Python

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

kwargsвозвращает словарь, но каков наилучший способ установить значения по умолчанию, или он есть? Должен ли я просто получить доступ к нему как словарь? Использовать функцию get?

class ExampleClass:
    def __init__(self, **kwargs):
        self.val = kwargs['val']
        self.val2 = kwargs.get('val2')

Простой вопрос, но на который я не могу найти хорошие ресурсы. Люди делают это по-разному в коде, который я видел, и трудно понять, что использовать.

Вы можете передать значение по умолчанию get()для ключей, которых нет в словаре:

self.val2 = kwargs.get('val2',"default value")

Однако, если вы планируете использовать определенный аргумент с определенным значением по умолчанию, почему бы не использовать именованные аргументы в первую очередь?

def __init__(self, val2="default value", **kwargs):

Хотя большинство ответов говорят, что, например,

def f(**kwargs):
    foo = kwargs.pop('foo')
    bar = kwargs.pop('bar')
    ...etc...

такой же как"

def f(foo=None, bar=None, **kwargs):
    ...etc...

это неправда. В последнем случае fможет быть вызвано как f(23, 42), тогда как в первом случае принимаются только именованные аргументы - никаких позиционных вызовов. Часто вы хотите позволить вызывающей стороне максимальную гибкость, и поэтому вторая форма, как утверждают большинство ответов, предпочтительнее, но это не всегда так. Когда вы принимаете много необязательных параметров, из которых обычно передаются только несколько, может оказаться отличной идеей (избегая аварий и нечитаемого кода на ваших сайтах вызовов!) Принудительно использовать именованные аргументы - threading.Threadпример. Первая форма - это то, как вы реализуете это в Python 2.

Эта идиома настолько важна, что в Python 3 теперь он имеет специальный поддерживающий синтаксис: каждый аргумент после единственного *в defподписи является ключевым словом, то есть не может быть передан как позиционный аргумент, а только как именованный. Таким образом, в Python 3 вы можете написать код выше:

def f(*, foo=None, bar=None, **kwargs):
    ...etc...

Действительно, в Python 3 вы даже можете иметь аргументы только для ключевых слов, которые не являются необязательными ( аргументы без значения по умолчанию).

Однако в Python 2 впереди долгие годы продуктивной жизни, поэтому лучше не забывать методы и идиомы, которые позволяют реализовывать в Python 2 важные идеи проектирования, которые непосредственно поддерживаются в языке Python 3!

Я предлагаю что-то подобное

def testFunc( **kwargs ):
    options = {
            'option1' : 'default_value1',
            'option2' : 'default_value2',
            'option3' : 'default_value3', }

    options.update(kwargs)
    print options

testFunc( option1='new_value1', option3='new_value3' )
# {'option2': 'default_value2', 'option3': 'new_value3', 'option1': 'new_value1'}

testFunc( option2='new_value2' )
# {'option1': 'default_value1', 'option3': 'default_value3', 'option2': 'new_value2'}

А затем используйте значения любым способом

dictionaryA.update(dictionaryB)добавляет содержимое dictionaryBк dictionaryAперезаписи любых дубликатов ключей.

Ты бы сделал

self.attribute = kwargs.pop('name', default_value)

или

self.attribute = kwargs.get('name', default_value)

Если вы используете pop, то вы можете проверить, отправлены ли какие-либо ложные значения, и предпринять соответствующие действия (если таковые имеются).

Использовать ** kwargs и значения по умолчанию легко. Однако иногда вам не следует использовать ** kwargs.

В этом случае мы не особо используем ** kwargs.

class ExampleClass( object ):
    def __init__(self, **kwargs):
        self.val = kwargs.get('val',"default1")
        self.val2 = kwargs.get('val2',"default2")

Выше это "зачем?" декларация. Это так же, как

class ExampleClass( object ):
    def __init__(self, val="default1", val2="default2"):
        self.val = val
        self.val2 = val2

Когда вы используете ** kwargs, вы имеете в виду, что ключевое слово не просто необязательно, а условно. Есть более сложные правила, чем простые значения по умолчанию.

Когда вы используете ** kwargs, вы обычно подразумеваете что-то более похожее на следующее, где простые значения по умолчанию не применяются.

class ExampleClass( object ):
    def __init__(self, **kwargs):
        self.val = "default1"
        self.val2 = "default2"
        if "val" in kwargs:
            self.val = kwargs["val"]
            self.val2 = 2*self.val
        elif "val2" in kwargs:
            self.val2 = kwargs["val2"]
            self.val = self.val2 / 2
        else:
            raise TypeError( "must provide val= or val2= parameter values" )

Так **kwargsкак используется, когда число аргументов неизвестно, почему бы не сделать это?

class Exampleclass(object):
  def __init__(self, **kwargs):
    for k in kwargs.keys():
       if k in [acceptable_keys_list]:
          self.__setattr__(k, kwargs[k])

Вот еще один подход:

def my_func(arg1, arg2, arg3):
    ... so something ...

kwargs = {'arg1': 'Value One', 'arg2': 'Value Two', 'arg3': 'Value Three'}
# Now you can call the function with kwargs like this:

my_func(**kwargs)

Я думаю, что правильный способ использовать **kwargsв Python, когда дело доходит до значений по умолчанию, это использовать метод словаря setdefault, как указано ниже:

class ExampleClass:
    def __init__(self, **kwargs):
        kwargs.setdefault('val', value1)
        kwargs.setdefault('val2', value2)

Таким образом, если пользователь передает ключевое слово «val» или «val2» args, они будут использоваться; в противном случае будут использоваться значения по умолчанию, которые были установлены.

Вы могли бы сделать что-то вроде этого

class ExampleClass:
    def __init__(self, **kwargs):
        arguments = {'val':1, 'val2':2}
        arguments.update(kwargs)
        self.val = arguments['val']
        self.val2 = arguments['val2']

Следуя предложению @srhegde об использовании setattr :

class ExampleClass(object):
    __acceptable_keys_list = ['foo', 'bar']

    def __init__(self, **kwargs):
        [self.__setattr__(key, kwargs.get(key)) for key in self.__acceptable_keys_list]

Этот вариант полезен, когда ожидается, что у класса будут все элементы в нашем acceptableсписке.

Если вы хотите объединить это с * args, вы должны оставить * args и ** kwargs в конце определения.

Так:

def method(foo, bar=None, *args, **kwargs):
    do_something_with(foo, bar)
    some_other_function(*args, **kwargs)

@AbhinavGupta и @Steef предложили использовать update(), что я нашел очень полезным для обработки больших списков аргументов:

args.update(kwargs)

Что если мы хотим проверить, что пользователь не передал никаких ложных / неподдерживаемых аргументов? @VinaySajip указал, что pop()может использоваться для итеративной обработки списка аргументов. Тогда любые оставшиеся аргументы являются ложными. Ницца.

Вот еще один возможный способ сделать это, который сохраняет простой синтаксис использования update():

# kwargs = dictionary of user-supplied arguments
# args = dictionary containing default arguments

# Check that user hasn't given spurious arguments
unknown_args = user_args.keys() - default_args.keys()
if unknown_args:
    raise TypeError('Unknown arguments: {}'.format(unknown_args))

# Update args to contain user-supplied arguments
args.update(kwargs)

unknown_argsявляется setсодержащими имена аргументов , которые не встречаются в значениях по умолчанию.

Другое простое решение для обработки неизвестных или нескольких аргументов может быть:

class ExampleClass(object):

    def __init__(self, x, y, **kwargs):
      self.x = x
      self.y = y
      self.attributes = kwargs

    def SomeFunction(self):
      if 'something' in self.attributes:
        dosomething()

** kwargs дает свободу добавлять любое количество аргументов ключевого слова. У каждого может быть список ключей, для которых он может устанавливать значения по умолчанию. Но установка значений по умолчанию для неопределенного количества ключей кажется ненужной. Наконец, может быть важно иметь ключи в качестве атрибутов экземпляра. Итак, я бы сделал это следующим образом:

class Person(object):
listed_keys = ['name', 'age']

def __init__(self, **kwargs):
    _dict = {}
    # Set default values for listed keys
    for item in self.listed_keys: 
        _dict[item] = 'default'
    # Update the dictionary with all kwargs
    _dict.update(kwargs)

    # Have the keys of kwargs as instance attributes
    self.__dict__.update(_dict)