In , are named that an that a given can .
When , you may not be aware of all the use cases of your code, and may want to offer more for with the , or for users with the code. We can pass a of to a by using *args and ** in our code .
You have 3 and a set up on your or . If you don't have a set up, you can refer to the and setup for a local or for a on your for your (, , , etc.)
In , the - form of *args can be used as a to send a non- - list to . It is worth that the (*) is the here, as the word args is the idiom, it is not by the .
Info: To along with the code in this , open a shell on your local by the . Then you can copy, paste, or edit the by them after the >>> .
Let's look at a that uses two :
.py
def multiply(x, y):
print (x * y)
Copy
In the code above, we built the with x and y as , and then when we call the , we need to use to with x and y. In this case, we will pass the 5 in for x and the 4 in for y:
.py
def multiply(x, y):
print (x * y)
multiply(5, 4)
Copy
Now, we can run the above code:
- python lets_multiply.py
Copy
We'll the , that the 5 and 4 were as per the (x,y) :
Output20
What if, later on, we that we would like to three than just two? If we try to add an to the , as shown below, we'll an error.
.py
def multiply(x, y):
print (x * y)
multiply(5, 4, 3)
Copy
OutputTypeError: multiply() takes 2 positional arguments but 3 were given
So, if you that you may need to use more later on, you can make use of *args as your .
We can the same and code that we in the first , by x and y as , and them with *args:
.py
def multiply(*args):
z = 1
for num in args:
z *= num
print(z)
multiply(4, 5)
multiply(10, 9)
multiply(2, 3, 4)
multiply(3, 5, 10, 6)
Copy
When we run this code, we'll the for each of these calls:
Output20
90
24
900
we used *args to send a - list to our , we were able to pass in as many as we into the calls.
With *args you can more code that a of non- your .
The form of ** is used to pass a , - to a . Again, the two (**) are the here, as the word is used, not by the .
Like *args, ** can take many you would like to to it. , ** from *args in that you will need to .
First, let's print out the ** that we pass to a . We'll a short to do this:
.py
def print_kwargs(**kwargs):
print(kwargs)
Copy
Next, we'll call the with some into the :
.py
def print_kwargs(**kwargs):
print(kwargs)
print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True)
Copy
Let's run the above and look at the :
- python print_kwargs.py
Copy
Output{'kwargs_3': True, 'kwargs_2': 4.5, 'kwargs_1': 'Shark'}
on the of 3 you are using, the data type may be . In 3.6 and above, you'll the key-value pairs in order, but in , the pairs will be in a order.
What is to note is that a is and we can work with it just like we can work with other .
Let's short to show how we can make use of **. Here we'll a to greet a of names. First, we'll start with a of two names:
.py
def print_values(**kwargs):
for key, value in kwargs.items():
print("The value of {} is {}".format(key, value))
print_values(my_name="Sammy", your_name="Casey")
Copy
We can now run the and look at the :
- python print_values.py
Copy
OutputThe value of your_name is Casey
The value of my_name is Sammy
Again, may be , your may be with the name Casey first or with the name Sammy first.
Let's now pass to the to show that ** will many you would like to :
.py
def print_values(**kwargs):
for key, value in kwargs.items():
print("The value of {} is {}".format(key, value))
print_values(
name_1="Alex",
name_2="Gray",
name_3="Harper",
name_4="Phoenix",
name_5="Remy",
name_6="Val"
)
Copy
When we run the at this point, we'll the , which may again be :
OutputThe value of name_2 is Gray
The value of name_6 is Val
The value of name_4 is Phoenix
The value of name_5 is Remy
The value of name_3 is Harper
The value of name_1 is Alex
Using ** us with to use in our . When we use ** as a , we don't need to know how many we would like to pass to a .
When a or call, need to occur in a order:
* **
In , when with along with *args and **, your would look like this:
def example(arg_1, arg_2, *args, **kwargs):
...
Copy
And, when with along with named in to *args and **, your would look like this:
def example2(arg_1, arg_2, *args, kw_1="shark", kw_2="blobfish", **kwargs):
...
Copy
It is to keep the order of in mind when so that you do not a error in your code.
We can also use *args and ** to pass into .
First, let's look at an with *args.
.py
def some_args(arg_1, arg_2, arg_3):
print("arg_1:", arg_1)
print("arg_2:", arg_2)
print("arg_3:", arg_3)
args = ("Sammy", "Casey", "Alex")
some_args(*args)
Copy
In the above, there are three as arg_1, arg_, and arg_3. The will print out each of these . We then a that is set to an (in this case, a tuple), and can pass that into the with the .
When we run the with the .py , we'll the :
Outputarg_1: Sammy
arg_2: Casey
arg_3: Alex
We can also the above to an list data type with a name. Let's also the *args with a :
.py
def some_args(arg_1, arg_2, arg_3):
print("arg_1:", arg_1)
print("arg_2:", arg_2)
print("arg_3:", arg_3)
my_list = [2, 3]
some_args(1, *my_list)
Copy
If we run the above, it will the :
Outputarg_1: 1
arg_2: 2
arg_3: 3
, the ** can be used to call a . We will set up a equal to a with 3 key-value pairs (we'll use here, but it can be you want), and pass it to a with 3 :
.py
def some_kwargs(kwarg_1, kwarg_2, kwarg_3):
print("kwarg_1:", kwarg_1)
print("kwarg_2:", kwarg_2)
print("kwarg_3:", kwarg_3)
kwargs = {"kwarg_1": "Val", "kwarg_2": "Harper", "kwarg_3": "Remy"}
some_kwargs(**kwargs)
Copy
Let's run the above with the .py :
Outputkwarg_1: Val
kwarg_2: Harper
kwarg_3: Remy
When a , you can use *args and ** to pass .
We can use the of *args and ** a in order to pass a of to the .
that *args and ** are best used in where you that the of the list will small. The use of *args and ** is to and , but be done with care.