Understanding **kwargs in Python: A Beginner’s Guide

In Python, the flexibility of functions is one of the things that makes it a favorite language for developers. You can pass arguments in multiple ways, which allows you to create more dynamic and versatile functions. One such way is through kwargs.

But what exactly is kwargs, and why is it so useful? Let’s dive into it!

What Are kwargs?

In Python, kwargs stands for “keyword arguments”. It’s a way to pass a variable number of arguments to a function, but unlike *args, **kwargs allows you to pass arguments as key-value pairs (like a dictionary).

When you use **kwargs in a function, it allows you to handle any number of named arguments (parameters), which can be very useful for functions that need to process a flexible number of inputs.

Syntax of **kwargs

To use kwargs, you specify it in the function definition using a double asterisk (**) before the parameter name, like so:

def my_function(**kwargs):
    # function body

Here, kwargs is just a variable name (it can be anything), but the ** is what tells Python to collect all keyword arguments into a dictionary.

Example: Using **kwargs

Let’s start with a basic example:

def greet(**kwargs):
    if 'name' in kwargs:
        print(f"Hello, {kwargs['name']}!")
    else:
        print("Hello, stranger!")
        
# Calling the function
greet(name="Alice")
greet()

Output:

Hello, Alice!
Hello, stranger!

In this example:

• When you call the function with the keyword argument name="Alice", it uses that value in the function body.
• If you don’t provide the argument, it defaults to “stranger”.

How Does **kwargs Work? 🛠️

The real magic of kwargs lies in its ability to handle dynamic and flexible function arguments. You can pass any number of named arguments to a function, and they will be packed into a dictionary, where the key is the argument name and the value is the corresponding argument value.

Example: Dynamic Arguments

def display_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# Calling the function
display_info(name="John", age=30, city="New York")

Output:

name: John
age: 30
city: New York

Here, the function display_info prints all the key-value pairs in the dictionary formed by kwargs. You can pass any combination of arguments, and the function will print them in a structured way.

Why Use **kwargs? 🤔

Using kwargs in your functions provides flexibility. Here are a few reasons why it’s useful:

1. Handling a Variable Number of Arguments: You don’t always know beforehand how many arguments a function will receive. kwargs helps you handle cases where the number of arguments can vary.
2. Code Readability: With kwargs, you can pass arguments with meaningful names, improving the readability of your code.
3. Working with Optional Arguments: Sometimes, you want to give your users the option to pass arguments, but not force them to do so. kwargs is perfect for handling such cases.

**kwargs and Function Overloading

In Python, you can’t overload functions by having multiple functions with the same name but different parameters. Instead, kwargs allows you to achieve a similar effect.

To understand function overloading in Python – https://brontowise.com/2025/05/09/function-overloading-in-python/

Example: Simulating Function Overloading

def describe_person(**kwargs):
    if 'name' in kwargs and 'age' in kwargs:
        print(f"{kwargs['name']} is {kwargs['age']} years old.")
    elif 'name' in kwargs:
        print(f"This person is {kwargs['name']}.")
    else:
        print("Unknown person.")
        
describe_person(name="Alice", age=25)
describe_person(name="Bob")
describe_person()

Output:

Alice is 25 years old.
This person is Bob.
Unknown person.

In this example:

• If both name and age are provided, it prints the full information.
• If only name is provided, it prints just the name.
• If no arguments are provided, it prints “Unknown person.”

Mixing **kwargs with Other Arguments 💡

You can mix kwargs with other parameters in your function. However, when you do that, kwargs must always be the last parameter in the function definition.

Example: Mixing Positional and Keyword Arguments

def create_profile(name, age, **kwargs):
    print(f"Name: {name}, Age: {age}")
    for key, value in kwargs.items():
        print(f"{key}: {value}")
        
create_profile("Alice", 25, city="New York", job="Engineer")

Output:

Name: Alice, Age: 25
city: New York
job: Engineer

In this example:

• The first two arguments, name and age, are positional arguments.
• The remaining arguments (such as city and job) are passed using **kwargs.

Important Things to Remember 📋

1. kwargs must always be the last parameter in the function definition if you are mixing it with other parameters.
2. You can use both *args and **kwargs together in the same function to handle a flexible number of positional and keyword arguments.
   def handle_data(*args, **kwargs): print(args) print(kwargs)
3. kwargs collects only the named arguments. It won’t capture positional arguments passed without a keyword.

Conclusion 🏁

In Python, kwargs provides a powerful way to handle dynamic arguments passed to functions. It allows for better readability and flexibility in your code and is particularly useful when working with optional parameters. With kwargs, you can easily handle varying inputs and simulate function overloading, which is not natively supported in Python.

Understanding kwargs will make you a better Python developer, enabling you to write more flexible and reusable code!

I hope this gives you a clear understanding of kwargs in Python! Happy coding!