Richtige Verwendung von ** kwargs in Python

Was ist die richtige Verwendung **kwargsin Python, wenn es um Standardwerte geht?

kwargsgibt ein Wörterbuch zurück, aber wie lassen sich Standardwerte am besten festlegen, oder gibt es einen? Soll ich nur als Wörterbuch darauf zugreifen? Get-Funktion verwenden?

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

Eine einfache Frage, für die ich keine guten Ressourcen finden kann. Die Leute machen es auf unterschiedliche Weise in Code, den ich gesehen habe, und es ist schwer zu wissen, was sie verwenden sollen.

Sie können einen Standardwert get()für Schlüssel übergeben, die nicht im Wörterbuch enthalten sind:

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

Wenn Sie jedoch ein bestimmtes Argument mit einem bestimmten Standardwert verwenden möchten, warum nicht zuerst benannte Argumente verwenden?

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

Während die meisten Antworten sagen, dass z.

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

ist das gleiche wie"

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

das ist nicht wahr. Im letzteren Fall fkann als aufgerufen werden f(23, 42), während im ersteren Fall nur benannte Argumente akzeptiert werden - keine Positionsaufrufe. Oft möchten Sie dem Anrufer maximale Flexibilität gewähren, und daher ist die zweite Form, wie die meisten Antworten behaupten, vorzuziehen. Dies ist jedoch nicht immer der Fall. Wenn Sie viele optionale Parameter akzeptieren, von denen normalerweise nur wenige übergeben werden, ist es möglicherweise eine hervorragende Idee (Vermeidung von Unfällen und unlesbarem Code an Ihren Anrufstellen!), Die Verwendung benannter Argumente zu erzwingen - threading.Threadist ein Beispiel. Das erste Formular ist, wie Sie das in Python 2 implementieren.

Das Idiom ist so wichtig, dass es in Python 3 jetzt eine spezielle unterstützende Syntax hat: Jedes Argument nach einem einzelnen *in der defSignatur ist nur ein Schlüsselwort, dh es kann nicht als Positionsargument übergeben werden, sondern nur als benanntes. In Python 3 können Sie Folgendes wie folgt codieren:

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

In Python 3 können Sie sogar Argumente nur mit Schlüsselwörtern verwenden, die nicht optional sind (solche ohne Standardwert).

Python 2 hat jedoch noch lange Jahre produktiven Lebens vor sich. Vergessen Sie daher nicht die Techniken und Redewendungen, mit denen Sie wichtige Designideen in Python 2 implementieren können, die direkt in der Sprache in Python 3 unterstützt werden!

Ich schlage so etwas vor

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'}

Und dann verwenden Sie die Werte wie Sie wollen

dictionaryA.update(dictionaryB)Fügt den Inhalt dictionaryBzum dictionaryAÜberschreiben doppelter Schlüssel hinzu.

Das würdest du tun

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

oder

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

Wenn Sie verwenden pop, können Sie überprüfen, ob falsche Werte gesendet wurden, und die entsprechenden Maßnahmen ergreifen (falls vorhanden).

Die Verwendung von ** kwargs und Standardwerten ist einfach. Manchmal sollten Sie jedoch überhaupt keine ** kwargs verwenden.

In diesem Fall nutzen wir ** kwargs nicht wirklich optimal.

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

Das obige ist ein "warum sich die Mühe machen?" Erklärung. Es ist das gleiche wie

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

Wenn Sie ** kwargs verwenden, bedeutet dies, dass ein Schlüsselwort nicht nur optional, sondern auch bedingt ist. Es gibt komplexere Regeln als einfache Standardwerte.

Wenn Sie ** kwargs verwenden, meinen Sie normalerweise etwas wie das Folgende, bei dem einfache Standardeinstellungen nicht zutreffen.

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" )

Da dies verwendet **kwargswird, wenn die Anzahl der Argumente unbekannt ist, warum nicht?

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

Hier ist ein anderer Ansatz:

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)

Ich denke, der richtige Weg, um **kwargsin Python zu verwenden, wenn es um Standardwerte geht, ist die Verwendung der Wörterbuchmethode setdefault, wie unten angegeben:

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

Auf diese Weise werden Benutzer verwendet, die im Schlüsselwort 'val' oder 'val2' übergeben args. Andernfalls werden die festgelegten Standardwerte verwendet.

Sie könnten so etwas tun

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

Im Anschluss an @srhegde Vorschlag der Verwendung von 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]

Diese Variante ist nützlich, wenn von der Klasse erwartet wird, dass sie alle Elemente in unserer acceptableListe enthält.

Wenn Sie dies mit * args kombinieren möchten, müssen Sie * args und ** kwargs am Ende der Definition behalten.

Damit:

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

@AbhinavGupta und @Steef schlugen die Verwendung vor update(), was ich für die Verarbeitung großer Argumentlisten sehr hilfreich fand:

args.update(kwargs)

Was ist, wenn wir überprüfen möchten, ob der Benutzer keine falschen / nicht unterstützten Argumente übergeben hat? @VinaySajip wies darauf hin, dass pop()die Liste der Argumente iterativ verarbeitet werden kann. Dann sind alle verbleibenden Argumente falsch. Nett.

Hier ist eine andere Möglichkeit, dies zu tun, wobei die einfache Syntax der Verwendung beibehalten wird 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_argsist a und setenthält die Namen von Argumenten, die in den Standardeinstellungen nicht vorkommen.

Eine andere einfache Lösung für die Verarbeitung unbekannter oder mehrerer Argumente kann sein:

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 gibt die Freiheit, eine beliebige Anzahl von Schlüsselwortargumenten hinzuzufügen. Man kann eine Liste von Schlüsseln haben, für die man Standardwerte festlegen kann. Das Festlegen von Standardwerten für eine unbestimmte Anzahl von Schlüsseln erscheint jedoch nicht erforderlich. Schließlich kann es wichtig sein, die Schlüssel als Instanzattribute zu haben. Also würde ich das wie folgt machen:

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)