**kwargs is a dictionary of keyword arguments. The ** allows us to pass any number of keyword arguments. A keyword argument is basically a dictionary.
Thus, it does the same operation as *args but for keyword arguments. **kwargs allow a function to take any number of keyword arguments. By default, **kwargs is an empty dictionary. Each undefined keyword argument is stored as a key-value pair in the **kwargs dictionary.
Inside the function, the kwargs argument is a dictionary that contains all keyword arguments as its name-value pairs. Precede double stars ( ** ) to a dictionary argument to pass it to **kwargs parameter. Always place the **kwargs parameter at the end of the parameter list, or you'll get an error.
Yes, it means "keyword arguments", but kwargs is not actually a reserved word. It is just the idiomatic thing to call the argument that collects all the unused keyword arguments.
You want
if 'errormessage' in kwargs:
print("found it")
To get the value of errormessage
if 'errormessage' in kwargs:
print("errormessage equals " + kwargs.get("errormessage"))
In this way, kwargs
is just another dict
. Your first example, if kwargs['errormessage']
, means "get the value associated with the key "errormessage" in kwargs, and then check its bool value". So if there's no such key, you'll get a KeyError
.
Your second example, if errormessage in kwargs:
, means "if kwargs
contains the element named by "errormessage
", and unless "errormessage
" is the name of a variable, you'll get a NameError
.
I should mention that dictionaries also have a method .get()
which accepts a default parameter (itself defaulting to None
), so that kwargs.get("errormessage")
returns the value if that key exists and None
otherwise (similarly kwargs.get("errormessage", 17)
does what you might think it does). When you don't care about the difference between the key existing and having None
as a value or the key not existing, this can be handy.
DSM's and Tadeck's answers answer your question directly.
In my scripts I often use the convenient dict.pop()
to deal with optional, and additional arguments. Here's an example of a simple print()
wrapper:
def my_print(*args, **kwargs):
prefix = kwargs.pop('prefix', '')
print(prefix, *args, **kwargs)
Then:
>>> my_print('eggs')
eggs
>>> my_print('eggs', prefix='spam')
spam eggs
As you can see, if prefix
is not contained in kwargs
, then the default ''
(empty string) is being stored in the local prefix
variable. If it is given, then its value is being used.
This is generally a compact and readable recipe for writing wrappers for any kind of function: Always just pass-through arguments you don't understand, and don't even know if they exist. If you always pass through *args
and **kwargs
you make your code slower, and requires a bit more typing, but if interfaces of the called function (in this case print
) changes, you don't need to change your code. This approach reduces development time while supporting all interface changes.
It is just this:
if 'errormessage' in kwargs:
print("yeah it's here")
You need to check, if the key is in the dictionary. The syntax for that is some_key in some_dict
(where some_key
is something hashable, not necessarily a string).
The ideas you have linked (these ideas) contained examples for checking if specific key existed in dictionaries returned by locals()
and globals()
. Your example is similar, because you are checking existence of specific key in kwargs
dictionary (the dictionary containing keyword arguments).
One way is to add it by yourself! How? By merging kwargs
with a bunch of defaults. This won't be appropriate on all occasions, for example, if the keys are not known to you in advance. However, if they are, here is a simple example:
import sys
def myfunc(**kwargs):
args = {'country':'England','town':'London',
'currency':'Pound', 'language':'English'}
diff = set(kwargs.keys()) - set(args.keys())
if diff:
print("Invalid args:",tuple(diff),file=sys.stderr)
return
args.update(kwargs)
print(args)
The defaults are set in the dictionary args
, which includes all the keys we are expecting. We first check to see if there are any unexpected keys in kwargs. Then we update args
with kwargs
which will overwrite any new values that the user has set. We don't need to test if a key exists, we now use args
as our argument dictionary and have no further need of kwargs
.
You can discover those things easily by yourself:
def hello(*args, **kwargs):
print kwargs
print type(kwargs)
print dir(kwargs)
hello(what="world")
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With