*args and **kwargs in Python

In Python, *args and **kwargs are used to allow functions to accept an arbitrary number of arguments. These features provide great flexibility when designing functions that need to handle a varying number of inputs.

Example:

# *args example
def fun(*args):
    return sum(args)

print(fun(1, 2, 3, 4)) 
print(fun(5, 10, 15))   

# **kwargs example
def fun(**kwargs):
    for k, val in kwargs.items():
        print(k, val)

fun(a=1, b=2, c=3)

10
30
a 1
b 2
c 3

Let’s explore *args and **kwargs in detail:

There are two special symbols to pass multiple arguments:

*args and **kwargs in Python

Special Symbols Used for passing arguments in Python:

• *args (Non-Keyword Arguments)
• **kwargs (Keyword Arguments)

Note: “We use the “wildcard” or “*” notation like this – *args OR **kwargs – as our function’s argument when we have doubts about the number of  arguments we should pass in a function.” 

Python *args

The special syntax *args in function definitions is used to pass a variable number of arguments to a function. It is used to pass a non-keyworded, variable-length argument list. 

• For example, we want to make a multiply function that takes any number of arguments and is able to multiply them all together. It can be done using *args.
• Using * the variable that we associate with the * becomes iterable, meaning you can do things like iterate over it, run some higher-order functions such as map and filter, etc.

Example 1:

Python program to illustrate *args for a variable number of arguments

def myFun(*argv):
    for arg in argv:
        print(arg)


myFun('Hello', 'Welcome', 'to', 'GeeksforGeeks')

Hello
Welcome
to
GeeksforGeeks

Example 2:

Python program to illustrate *args with a first extra argument.

def fun(arg1, *argv):
    print("First argument :", arg1)
    for arg in argv:
        print("Argument *argv :", arg)


fun('Hello', 'Welcome', 'to', 'GeeksforGeeks')

First argument : Hello
Argument *argv : Welcome
Argument *argv : to
Argument *argv : GeeksforGeeks

Python **kwargs

The special syntax **kwargs in function definitions is used to pass a variable length argument list. We use the name kwargs with the double star **.

• A keyword argument is where you provide a name to the variable as you pass it into the function.
• It collects all the additional keyword arguments passed to the function and stores them in a dictionary.

Example 1: 

def fun(**kwargs):
    for k, val in kwargs.items():
        print("%s == %s" % (k, val))


# Driver code
fun(s1='Geeks', s2='for', s3='Geeks')

s1 == Geeks
s2 == for
s3 == Geeks

For s1=’Geeks’, s1 is key and ‘Geeks’ is a value. In simple words, what we assign is value and to whom we assign is key. 

Example 2:

def fun(arg1, **kwargs):
    for k, val in kwargs.items():
        print("%s == %s" % (k, val))


# Driver code
fun("Hi", s1='Geeks', s2='for', s3='Geeks')

s1 == Geeks
s2 == for
s3 == Geeks

Using both *args and **kwargs

We can use both *args and **kwargs in the same function to accept a mix of positional and keyword arguments.

Example:

def fun(*args, **kwargs):
    print("Positional arguments:", args)
    print("Keyword arguments:", kwargs)

fun(1, 2, 3, a=4, b=5)

Positional arguments: (1, 2, 3)
Keyword arguments: {'a': 4, 'b': 5}

In this example, the fun can handle both positional and keyword arguments. The args parameter collects positional arguments into a tuple, while the kwargs parameter collects keyword arguments into a dictionary.

*args and **kwargs in Python – FAQs

Why use *args and **kwargs in Python?

*args and **kwargs allow functions to accept a variable number of arguments:

• *args (arguments) allows you to pass a variable number of positional arguments to a function.
• **kwargs (keyword arguments) allows you to pass a variable number of keyword arguments (key-value pairs) to a function.

Difference between *args and **kwargs in Python?

*args collects additional positional arguments as a tuple, while **kwargs collects additional keyword arguments as a dictionary.

def example_function(*args, **kwargs):
    print(args)    # tuple of positional arguments
    print(kwargs)  # dictionary of keyword arguments

example_function(1, 2, 3, name='Alice', age=30)
Output:
(1, 2, 3)
{'name': 'Alice', 'age': 30}

Is *args a list or tuple in Python?

*args collects additional positional arguments into a tuple, not a list. The arguments are accessible using tuple indexing and iteration.

def example_function(*args):
    print(type(args))  # <class 'tuple'>
example_function(1, 2, 3)

Why use *args instead of a list?

*args is used when you want to pass a variable number of arguments to a function without explicitly specifying each argument in a list. It allows for flexibility and simplicity when defining functions that may take an unknown number of arguments.

def sum_values(*args):
    total = sum(args)
    return total
result = sum_values(1, 2, 3, 4, 5)
print(result)  # Output: 15

How to pass **kwargs?

To pass keyword arguments (**kwargs) to a function, you provide key-value pairs when calling the function.

def example_function(**kwargs):
    print(kwargs)
example_function(name='Alice', age=30)
Output:
{'name': 'Alice', 'age': 30}

Inside the function, kwargs will be a dictionary containing the passed keyword arguments.

kartik

Follow

Improve

Article Tags :

• Python

Practice Tags :

• python