Hi there folks. I have come to see that most new python programmers have a hard time figuring out the *args and **kwargs magic variables. So what are they ? First of all let me tell you that it is not necessary to write *args or **kwargs. Only the * (aesteric) is necessary. You could have also written *var and **vars. Writing *args and **kwargs is just a convention. So now lets take a look at *args first.
Usage of *args
*args and **kwargs are mostly used in function definitions. *args and **kwargs allow you to pass a variable number of arguments to a function. What does variable mean here is that you do not know before hand that how many arguments can be passed to your function by the user so in this case you use these two keywords. *args is used to send a non-keyworded variable length argument list to the function. Here’s an example to help you get a clear idea:
def test_var_args(f_arg, *argv):
print "first normal arg:", f_arg
for arg in argv:
print "another arg through *argv :", arg
test_var_args('yasoob','python','eggs','test')
This produces the following result:
first normal arg: yasoob another arg through *argv : python another arg through *argv : eggs another arg through *argv : test
I hope this cleared away any confusion that you had. So now lets talk about **kwargs
Usage of **kwargs
**kwargs allows you to pass keyworded variable length of arguments to a function. You should use **kwargs if you want to handle named arguments in a function. Here is an example to get you going with it:
def greet_me(**kwargs):
if kwargs is not None:
for key, value in kwargs.iteritems():
print "%s == %s" %(key,value)
>>> greet_me(name="yasoob")
name == yasoob
So can you see how we handled a keyworded argument list in our function. This is just the basics of **kwargs and you can see how useful it is. Now lets talk about how you can use *args and **kwargs to call a function with a list or dictionary of arguments.
Using *args and **kwargs to call a function
So here we will see how to call a function using *args and **kwargs. Just consider that you have this little function:
def test_args_kwargs(arg1, arg2, arg3):
print "arg1:", arg1
print "arg2:", arg2
print "arg3:", arg3
Now you can use *args or **kwargs to pass arguments to this little function. Here’s how to do it:
# first with *args
>>> args = ("two", 3,5)
>>> test_args_kwargs(*args)
arg1: two
arg2: 3
arg3: 5
# now with **kwargs:
>>> kwargs = {"arg3": 3, "arg2": "two","arg1":5}
>>> test_args_kwargs(**kwargs)
arg1: 5
arg2: two
arg3: 3
Order of using *args **kwargs and formal args
So if you want to use all three of these in functions then the order is
some_func(fargs,*args,**kwargs)
I hope you have understood the usage of *args and **kwargs. If you have got any problems or confusions with this then feel free to comment below. For further study i suggest the official python docs on defining functions and *args and **kwargs on stackoverflow.
You might also like :
*) Making a url shortener in python
*) 20 Python libraries you can’t live without
*) Targeting python 2 and 3 at the same time.
Saw your links to this in the python programmers group on fb. I have been coding for a while now, but didn’t know anything about this. your blog is really really helpful! Thank’s for posting this, and keep the fb group updated with your posts!
Thanx i am glad that you found this helpful. If you want regular updates then consider following this blog. The link for following is available in the menu.
Ahhh thanks 🙂
No problem , cheers
U0 PrintF(U8 *fmt,…)
{
//like “this” in C++, in HolyC argv[] and argc
}
Great article, exactly what I needed.
Thanks for nice explanation.
No problem……I am glad that i could help you guys.
Pingback: Python socket network programming | Bite Sized Python Tips
Pingback: The self keyword in python explained | Bite Sized Python Tips
Pingback: The self variable in python explained | Bite Sized Python Tips
Pingback: Storing and Loading Data with JSON | Bite Sized Python Tips
I am definly going to follow this blog
Pingback: Best Python Resources for Beginners and Professionals | Bite Sized Python Tips
Pingback: Yasoob Khalid: Best Python Resources for Beginners and Professionals | The Black Velvet Room
Hi im trying to use a fill_between command but i dont know what to put in the **kwargs “section”.
This is my coding:
(…)
fill_between(x, y1, y2=0, where=None, **kwargs)
What should i write in the kwargs** section?
Greetings from Norway.
Hi Per. Welcome to my blog. Now regarding your problem I am sorry that I am not able to clearly understand you. What you can do is that you can write a detailed email to me or use stackoverflow 🙂 In both cases you will get help.
The thingy **kwargs by itself and then refer to them in your function as kwargs.
Pingback: Naudingos python nuorodos
Quick and easy.
Still learning python from a book and I didn’t find anything on it reletated to to *args
and *kwargs
Thanks for sharing your knowlegde and time.
I am glad you liked it 🙂
hi really it’s I needed, I searched a lot finally I found and I understand *args and **kwargs. can you please in the same way explain django views modesls program and urls patterens mapping.thank you very much.
Hi Mahesh I am glad that you liked the post. I will consider writing on django views in the future.
Very helpful. Thank you Yasoob.
“bite sized” is written “bite-sized”, btw…
thnx dear yasoob a great article
will u also explain about a library storm
Pingback: args and kwargs in python explained | Bite Sized Python Tips | timcoleman3d
Thank you! It’s the best explanation I’ve read but I don’t really see the point in them.
In PHP we just pass variables onto functions. A variable can be well… anything. A number, a string, an array or even a multidimensional array – can all be handled by just saying:
function hello($some_variable) {
//do some stuff
}
In PHP the function doesn’t really care what gets passed to it. Whether you through into the function, PHP will deal with it. So, if PHP is able to live quite happily without args and kwargs, how come Python seems to have a problem here?
This is not a loaded question. It’s a sincere question from a dude who is trying to learn. Perhaps I’m missing something.
Many thanks,
-DC
Python is dynamically typed language.
Python functions really doesn’t care about what you pass to them.
But you got it the wrong way… please re-read the post.
If you want to pass one thousand arguments to your function, then you can’t explicitly define every parameter in your function definition. For the reason you will use *args and your function will be automagically able to handle all the arguments you pass to them for you.
Awesome…. doubt cleared… thanks a lot.. 🙂
Notice one thing: **kwargs arrange keys in alphabetical order
e.g:
def print_it(f_arg, **kwargs):
print f_arg
for key,value in kwargs.iteritems():
print “%s=%s”%(key,value)
print_it(‘sumer’,name=’panda’,age=12)
output:
sumer
age=12
name=panda
‘age’ gets printed before ‘name’
once again….this post helped me a lot…. thanks dude.
Pingback: Programming for Everybody – Week 7 | The Lit Tech
Pingback: NotesIndex: Index of Notes | Never Ending Security
thank you so much
easy explanations.
The best explanation about *args and **kwargs I have ever seen. Thank you a lot.
For Python3 now please note a difference:
in the first example for usage of **kwargs the line that has this:
for key, value in kwargs.iteritems():
gave me an error because it needs to be:
for key, value in kwargs.items():
since iteritems() no longer is defined in Python3 because items() can do the same thing.
OMG you r like the best teacher EVER! thnx a bunch
In the second paragraph, you’ve said:
“*args is used to send a non-keyworded variable length argument list to the function”.
As far as I understand, what you’re passing is any number of non-keyworded arguments in the function call. But NOT in a list. Am I wrong?
Thanks for the article : )
Pingback: *args and **kwargs in python explained | Zack's Ad hoc Page
Reblogged this on codaborate.
That was a short but insightful explanation. Thank you very much, I’m sure I can make good use of *args and *kwargs in my future coding!
That was a short but insightful explanation. Thank you very much, I’m sure I can make good use of *args and **kwargs in my future coding!
I am glad that it helped!
Well, this was quite nice. now I know how to use *args and **kwargs correctly. If’s easier thant what I thought before. Thank you for the tips.
Excellent tutorial. Thanks a lot!
When using **kwargs, we call those ‘keyword’ arguments.
But in Python, I thought ‘keyword’ referred to Python keywords like ‘if’, ‘else’, ‘while’, ‘for’, etc.
I’m guessing the term ‘keyword’ means two completely different things depending on the context (Python language keywords vs. keyword arguments) but I wasn’t sure, can someone clarify?
just a minor (and late) correction: * is not “aesteric”, but “asterisk” 🙂
Nice. Very usefull.
Wonderful explaining Thank You Very very much
I have one doubt on kwarg.pop(). What is the use of this method? I am bit confused on this. Can you please explain it to me?
Nice explanation 😀 , thanks
Very well explained. Thank you 🙂
Pingback: *args and **kwargs in python explained – Swetha's Tech Blogs
Awesome…Thanks for Nice explanation..This is what i was looking for!
Thank you, awesome explanation and very noble of you to teach the public 🙂
Reblogged this on Vigneshwer Dhinakaran and commented:
Learn to play with *args and *kwargs
Thank you for the wonderful simple and neat documentation on the topic.
I hope this doesn’t add too much confusion, but I wanted to note that in the most general case, Python allows all 4 forms of passing arguments used together:
>>> def f(a1, *args, a2=2, **kwargs): print(a1, args, a2, kwargs)
# we’ve defined function f that takes a1 as a positional argument, args as a collection of any number of additional positional arguments, a2 as a keyworded argument, and finally kwargs as an arbitrary dict of other keyworded arguments
# At a minimum, we have to supply a1 argument. Note that args and kwargs are not None, but are just empty tuple and dict, respectively
>>> f(1)
1 () 2 {}
# Now let’s try specifying everything
>>> f(1, 2, 3, a2=20, a3=30, a4=40)
1 (2, 3) 20 {‘a4’: 40, ‘a3’: 30}
# We can pass in all arguments by unrolling a tuple and a dict at the call site
>>> f(1, *(2,), a2=20, **{‘a3’: 30, ‘a4’: 40})
1 (2,) 20 {‘a4’: 40, ‘a3’: 30}
# Notice how we can override a2 without using standard keyworded argument syntax and how it does not appear in kwargs inside the function itself
>>> f(1, *(2,), **{‘a3’: 30, ‘a4’: 40, ‘a2’: 666})
1 (2,) 666 {‘a4’: 40, ‘a3’: 30}
I have a question:
>>> def run_with_func(func, *args):
… return func(*args)
>>> def sum_args(*args):
… return sum(args)
can you indicate the situation when to use *args, when to use args,