Or, How to use variable length argument lists in Python.
The special syntax, *args and **kwargs
in function definitions is used to pass a variable number of arguments
to a function. The single asterisk form (*args) is used to pass
a non-keyworded, variable-length argument list, and the double asterisk form
is used to pass a keyworded, variable-length argument list.
Here is an example of how to use the non-keyworded form. This example
passes one formal (positional) argument, and two more variable length arguments.
def test_var_args(farg, *args):
print "formal arg:", farg
for arg in args:
print "another arg:", arg
test_var_args(1, "two", 3)
Results:
formal arg: 1 another arg: two another arg: 3
Here is an example of how to use the keyworded form. Again, one formal argument and two keyworded variable arguments are passed.
def test_var_kwargs(farg, **kwargs):
print "formal arg:", farg
for key in kwargs:
print "another keyword arg: %s: %s" % (key, kwargs[key])
test_var_kwargs(farg=1, myarg2="two", myarg3=3)
Results:
formal arg: 1 another keyword arg: myarg2: two another keyword arg: myarg3: 3
*args and **kwargs when calling a functionThis special syntax can be used, not only in function definitions, but also when calling a function.
def test_var_args_call(arg1, arg2, arg3):
print "arg1:", arg1
print "arg2:", arg2
print "arg3:", arg3
args = (1, "two", 3)
test_var_args_call(*args)
Results:
arg1: 1 arg2: two arg3: 3
Here is an example using the keyworded form when calling a function:
def test_var_args_call(arg1, arg2, arg3):
print "arg1:", arg1
print "arg2:", arg2
print "arg3:", arg3
kwargs = {"arg3": 3, "arg2": "two", "arg1": 1}
test_var_args_call(**kwargs)
Results:
arg1: 1 arg2: two arg3: 3See also (updated 2009-04-12):
Reference: Core Python Programming, Second Edition, Section 11.6
Thanks for the succinct explanation of args and *kwargs. You made it nice and easy to understand.
thanks for this explanation. It's pretty cool to have such informations easy to understand.
Thanks for your explanation.
Thanks just learnt python from Think Python free book, but there was no mention of this. I was seeing it frequently in other peoples code and it was confusing me. Not now. Thanks again!
Mike, I had not heard of Think Python. It looks like a great free Python resource.
Awesome! This is THE explanation I was looking for :).
I have newly discovered your blog and it is awsome. Also this is a very good tip. Thanks you!
I too want to thank you for your explanation. Just started Python/Django and blogs like this really speed up the task.
Excellent explanation, no wonder it's the first google-hit for 'kwargs'. You might mention that the terms 'args' and 'kwargs' are arbitrary, though. I found out later that you can use any non-keyword identifier, as long as you use the asterisks.
Protector one, you make a good point, the terms "args" and "kwargs" are arbitrary. thank you. i'll try to add a note in the post when i get a chance.
Excellent, clear explanation. Thanks for the post.
Thanks a lot! I have a question:
Here is a function: def myfunction(self, a=None, b=None): pass
Is it possible to make sure that the user will call the function like this:
self.myfunction(a=2, b=3)
self.myfunction(a=2)
self.myfunction(b=3),
and that he won't be able to call the function without specifying which number is which parameter. I don't want this: self.myfunction(2, 3)
self.myfunction(2)
Emma
Emma, That's a good question-- I don't know the answer. If you find the answer, let me know.
Pretty usefull stuff. I found it usefull for my hobby project.
Python is so cool. :-)
For Emma
if you define your function like this:
def myfunction(self,**kwargs):pass
then u can call it like this:
self.myfunction()
self.myfunction(a=1)
self.myfunction(a=1,b=2)
self.myfunction(a=1,b=2,c=3)
....
if called like self.myfunction(1,2) it will throw an exception.
the problem is that with **kwargs u may specify as many parameters as u want (0 to n). U can check how many parameters the user entered (kwargs length) and then print an error message or whatever.
Thanks!
I second all that! Thanks for the explanation!
Thanks rubixC,
I'm not sure that's exactly what I need.
If I define the function like this:
def myfunction(self,**kwargs):pass,
I won't be able to make the user call the arguments a and b. I won't be able to refer to them in the function either, like this:
def myfunction(self,**kwargs):print a,
because for all I know the user could have called this a anything I have no way of finding out, right?
Hi Sofeng and rubixC, I have thought of a way to do what I wanted, but it doesn't look particularly elegant:
def myfunc(self, **kwargs):
kwargsdict = {}
expected_args = ["a","b","c"]
for key in kwargs.keys():
if key in expected_args:
kwargsdict[key] = kwargs[key]
else:
raise Exception("Unexpected Argument")
self.__myfunc_help(kwargsdict)
def __myfunc_help(self,a=None,b=None,c=None):
"real code here"
pass
#(not tested)
But I don't really like this solution... Emma
Hi Emma,
Thanks for giving us your solution. Have you tried asking on Stack Overflow? They have been helpful to me in the past.
That was easy! Thanks!
Thanks for the brief explanation. It was really useful. :-)
I'm Eliot and this is my notepad for programming topics such as Python, Django, Ubuntu, Emacs, etc... more »
algorithms
(2)
aws
(4)
bison_flex
(1)
blogger
(4)
c
(11)
cardstore
(7)
colinux
(2)
concurrency
(8)
conkeror
(2)
cygwin
(17)
datetime
(3)
dell
(3)
django
(34)
eclipse
(30)
emacs
(18)
error
(11)
hosting
(1)
keyboard
(3)
linux
(34)
matplotlib
(5)
mercurial
(3)
openid
(1)
personal
(4)
preferences
(7)
pyqt
(18)
python
(95)
rails
(1)
ratpoison
(3)
rsync
(3)
ruby
(2)
softwaretools
(16)
sql
(11)
subversion
(4)
twisted
(5)
ubuntu
(39)
untagged
(7)
urxvt
(3)
vxworks
(25)
webservices
(2)
wmii
(5)