Difference between Arguments (*args) and Keywords Arguments (**kwargs)

Follow me

Please see this page first, if any doubt left then click here for another way: Click here

Arguments (*args) and Keywords Arguments (**kwargs)

In Python, *args and **kwargs are powerful tools for passing variable numbers of arguments to functions. They allow functions to accept an arbitrary number of positional and keyword arguments, respectively. Here’s a detailed breakdown of how *args and **kwargs work, along with examples and best practices.

1. *args (Positional Arguments)

The *args syntax in a function definition allows the function to accept a variable number of positional arguments. These arguments are stored as a tuple, which you can then access and manipulate within the function.

Basic Usage of *args

Python

def my_function(*args):

    print(args)

my_function(1, 2, 3)  

# Output: 

(1, 2, 3)

In this example:

• *args collects all positional arguments into a tuple named args.
• When my_function(1, 2, 3) is called, args becomes (1, 2, 3).

Iterating Over *args

Since *args is a tuple, you can iterate over it using a loop:

Python

def greet_all(*names):

    for name in names:

        print(f"Hello, {name}!")

greet_all("Alice", "Bob", "Charlie")

# Output:

# Hello, Alice!

# Hello, Bob!

# Hello, Charlie!

In this example:

• *names captures all arguments passed to greet_all into the names tuple.
• Each name is printed in a greeting format.

Using *args with Other Parameters

You can combine *args with other parameters, but *args must come after any regular positional parameters:

Python

def my_function(a, b, *args):

    print("a:", a)

    print("b:", b)

    print("args:", args)

my_function(1, 2, 3, 4, 5)

# Output:

# a: 1

# b: 2

# args: (3, 4, 5)

In this example:

• a and b capture the first two positional arguments.
• *args captures the remaining arguments as a tuple.

2. **kwargs (Keyword Arguments)

The **kwargs syntax allows a function to accept a variable number of keyword arguments. These arguments are stored as a dictionary, where the keys are argument names and the values are the corresponding argument values.

Basic Usage of **kwargs

Python

def my_function(**kwargs):

    print(kwargs)

my_function(name="Alice", age=30, job="Engineer")

# Output: 

{'name': 'Alice', 'age': 30, 'job': 'Engineer'}

In this example:

• **kwargs collects all keyword arguments into a dictionary named kwargs.
• Each key-value pair represents an argument and its value.

Accessing Values in **kwargs

Since **kwargs is a dictionary, you can access values by key or iterate over the dictionary:

Python

def print_details(**details):

    for key, value in details.items():

        print(f"{key}: {value}")

print_details(name="Alice", age=30, job="Engineer")

# Output:

# name: Alice

# age: 30

# job: Engineer

Using **kwargs with Other Parameters

You can combine **kwargs with other parameters, but **kwargs must come last in the function definition:

Python

def my_function(name, **kwargs):

    print("Name:", name)

    print("Other details:", kwargs)

my_function(name="Alice", age=30, job="Engineer")

# Output:

# Name: Alice

# Other details: {'age': 30, 'job': 'Engineer'}

3. Using *args and **kwargs Together

You can use *args and **kwargs together in a function definition to handle both positional and keyword arguments. If you do, the order should be:

1. Regular positional arguments
2. *args
3. **kwargs

Python

def my_function(a, b, *args, **kwargs):

    print("a:", a)

    print("b:", b)

    print("args:", args)

    print("kwargs:", kwargs)

my_function(1, 2, 3, 4, 5, name="Alice", age=30)

# Output:

# a: 1

# b: 2

# args: (3, 4, 5)

# kwargs: {'name': 'Alice', 'age': 30}

In this example:

• a and b capture the first two positional arguments.
• *args captures additional positional arguments as a tuple.
• **kwargs captures keyword arguments as a dictionary.

4. Unpacking *args and **kwargs in Function Calls

You can also use *args and **kwargs to unpack arguments from an existing list, tuple, or dictionary when calling a function.

Unpacking *args from a List or Tuple

Python

def add(a, b, c):

    return a + b + c

numbers = (1, 2, 3)

print(add(*numbers))  

# Output: 

6

Unpacking **kwargs from a Dictionary

Python

def introduce (name, age, job):

    print(f"{name} is {age} years old and works as a {job}.")

 

person_info = {"name": "Alice", "age": 30, "job": "Engineer"}

introduce(**person_info)

# Output: 

Alice is 30 years old and works as a Engineer.

In this example:

• **person_info unpacks the dictionary into individual keyword arguments, which introduce then accepts as name, age, and job.

5. Best Practices and Use Cases

1. Use *args for Variable Positional Arguments: If you expect a function to handle an arbitrary number of positional arguments, use *args.
2. Use **kwargs for Optional Keyword Arguments: When a function may accept optional named arguments, **kwargs provides flexibility without enforcing specific arguments.
3. Use Descriptive Names: Instead of using *args and **kwargs, consider using more descriptive names if it makes the function’s purpose clearer (e.g., *numbers or **settings).
4. Combine for Flexible APIs: *args and **kwargs are especially useful in APIs where functions may accept a range of inputs or configurations.

Summary

• *args collects extra positional arguments as a tuple.
• **kwargs collects extra keyword arguments as a dictionary.
• They can be combined to allow functions to handle both variable positional and keyword arguments flexibly.
• Unpacking with *args and **kwargs enables you to pass lists, tuples, and dictionaries as arguments easily.