Python *args and **kwargs Explained in Function Parameters

By the end of this page, you will understand how *args collects extra positional arguments, how **kwargs collects extra keyword arguments, when to use each one, and how they fit into real Python function design.

In Python function definitions, *args and **kwargs let a function accept a flexible number of arguments.

• *args collects extra positional arguments into a tuple.
• **kwargs collects extra keyword arguments into a dictionary.

This is useful when you do not know in advance exactly how many arguments will be passed to a function, or when you want to forward arguments to another function.

For example:

def foo(x, y, *args):
    print(x)
    print(y)
    print(args)

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

Output:

1
2
(3, 4, 5)

Here:

• x gets 1
• y gets

Think of a function like a bag-check desk at an airport.

• Regular parameters like x and y are for bags with fixed labels.
• *args is a large bin for any extra unlabeled bags.
• **kwargs is a separate bin for extra bags with labels attached.

So if a function knows it always needs two required values, but might receive more:

• the extra unnamed values go into *args
• the extra named values go into **kwargs

Another way to think about it:

• *args = "collect leftover positional items"
• **kwargs = "collect leftover named items"

This makes functions more flexible without forcing you to define every possible parameter up front.

Basic syntax

def func(required1, required2, *args, **kwargs):
    print(required1)
    print(required2)
    print(args)
    print(kwargs)

Example with *args

def add_numbers(*args):
    return sum(args)

print(add_numbers(1, 2, 3))
print(add_numbers(10, 20, 30, 40))

Output:

6
100

Explanation:

• All positional arguments are collected into the tuple args
• sum(args) works because args behaves like a normal tuple of numbers

Example with

Consider this code:

def show(a, b, *args, **kwargs):
    print("a:", a)
    print("b:", b)
    print("args:", args)
    print("kwargs:", kwargs)

show(1, 2, 3, 4, color="blue", size="M")

Step 1: Match required positional parameters

Python assigns the first positional argument to a:

• a = 1

Then the second positional argument to b:

• b = 2

Step 2: Collect remaining positional arguments into args

The remaining positional arguments are 3 and 4.

So:

• args = (3, 4)

1. Wrapper functions

You may write a function that adds logging before calling another function.

def logged_call(func, *args, **kwargs):
    print(f"Calling {func.__name__}")
    return func(*args, **kwargs)

This lets the wrapper accept any arguments the wrapped function needs.

2. Framework and library APIs

Many frameworks accept optional settings through keyword arguments.

def connect(host, port, **options):
    print(host, port, options)

This allows new options to be added later without changing every call.

3. Building utility functions

A function might need to accept any number of values.

def average(*numbers):
    return sum(numbers) / len(numbers)

4. Passing configuration data

Keyword arguments are useful for configuration-like input.

 ():
     {
        : username,
        : profile
    }

In real projects, developers use *args and **kwargs carefully, not everywhere.

Common patterns

Forwarding arguments

A function may pass received arguments to another function.

def save_with_log(*args, **kwargs):
    print("Saving data...")
    return save(*args, **kwargs)

This is common in wrappers, adapters, and decorators.

Optional extension points

Libraries sometimes use **kwargs to allow extra options without breaking older code.

def send_email(to, subject, **options):
    timeout = options.get("timeout", 30)
    retry = options.get("retry", False)

Validation

Good code often validates values inside kwargs.

def create_product(name, **kwargs):
    allowed = {, , }
    unknown = (kwargs) - allowed
     unknown:
         TypeError()

1. Thinking args and kwargs are special names

They are just conventional names.

def test(*values, **options):
    print(values)
    print(options)

The special part is the * and **.

2. Forgetting the data types they create

• *args becomes a tuple
• **kwargs becomes a dictionary

Broken expectation:

def bad(*args):
    args.append(5)  # tuples do not have append

Fix:

def good(*args):
    values = list(args)
    values.append(5)
    return values

3. Using without checking valid keys

*args vs **kwargs

# Collect extra positional arguments
def func(*args):
    print(args)   # tuple

# Collect extra keyword arguments
def func(**kwargs):
    print(kwargs) # dict

# Use both
def func(a, b, *args, **kwargs):
    pass

Rules

• *args collects leftover positional arguments
• **kwargs collects leftover keyword arguments
• args and kwargs are naming conventions, not keywords
• *args is a tuple
• **kwargs is a dictionary
• Use them when the number or names of inputs may vary

Example

def demo(x, *args, **kwargs):
    print(x)
    print(args)
    (kwargs)

demo(, , , color=)

What does *args mean in Python?

*args means a function can accept any number of extra positional arguments. Inside the function, they are stored as a tuple.

What does **kwargs mean in Python?

**kwargs means a function can accept any number of extra keyword arguments. Inside the function, they are stored as a dictionary.

Are args and kwargs special Python keywords?

No. They are just common names. The special meaning comes from * and ** in the function definition.

Can I use both *args and **kwargs in the same function?

Yes. This is very common in wrappers and decorators.

When should I use *args?

Use *args when a function should accept a variable number of positional values, such as many numbers to sum.

When should I use **kwargs?

Use **kwargs when a function should accept optional named settings or when forwarding options to another function.

• Function parameters — *args and **kwargs are part of how Python defines function inputs.
• Positional arguments — *args specifically collects extra positional values.
• Keyword arguments — **kwargs specifically collects extra named values.
• Tuples — values collected by *args are stored in a tuple.
• Dictionaries — values collected by **kwargs are stored in a dictionary.
• Argument unpacking — in function calls, * and ** unpack sequences and mappings.
• Decorators — decorators often use *args and **kwargs to support many function signatures.
• Wrapper functions — wrappers commonly collect and forward arguments.
• Default parameters — often used together with flexible arguments for optional behavior.