What is kwargs in Python With Example?

In Python, kwargs is short for “keyword arguments,” and it refers to a special type of argument that allows you to pass a variable number of keyword-value pairs to a function. Keyword arguments are useful when you want to provide optional or named parameters to a function, allowing you to make function calls in a more readable and flexible manner.

Here’s how you use kwargs in Python:

def example_function(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

# Calling the function with keyword arguments
example_function(arg1='value1', arg2='value2', arg3='value3')

In the above example, the kwargs parameter inside the example_function is preceded by double asterisks **, which indicates that it will accept keyword arguments as a dictionary-like object. When you call example_function with keyword arguments, they are packed into a dictionary where the keyword becomes the key, and the provided value becomes the corresponding value.

The output of the above function call would be:

arg1 value1
arg2 value2
arg3 value3

Keyword arguments are particularly useful when you want to create functions that can accept a varying number of optional arguments without requiring the caller to provide them in a specific order. It provides more flexibility and clarity in function calls, especially when there are many optional parameters.

What is an example of kwargs in Python?

Here’s a more concrete example of how you might use kwargs in Python:

def display_info(**kwargs):
    if 'name' in kwargs:
        print(f"Name: {kwargs['name']}")
    if 'age' in kwargs:
        print(f"Age: {kwargs['age']}")
    if 'city' in kwargs:
        print(f"City: {kwargs['city']}")

# Calling the function with keyword arguments
display_info(name='Alice', age=30, city='New York')

In this example, the display_info function accepts keyword arguments using the **kwargs syntax. It then checks whether specific keys (‘name’, ‘age’, ‘city’) are present in the kwargs dictionary and prints out their corresponding values if they exist.

When you call the function like display_info(name='Alice', age=30, city='New York'), it will output:

Name: Alice
Age: 30
City: New York

Notice that you don’t have to provide the keyword arguments in any specific order, and you can omit any of them without causing errors.

This kind of flexibility is especially useful when dealing with functions that might have a variety of optional parameters, as it makes the function calls more readable and helps prevent errors due to parameter order mismatch.

How do you use kwargs in Python class?

You can use kwargs in a Python class constructor (__init__ method) and other methods just like you would in regular functions. The process is very similar. Here’s an example of using kwargs in a class:

class Person:
    def __init__(self, **kwargs):
        self.name = kwargs.get('name', 'Unknown')
        self.age = kwargs.get('age', 0)
        self.city = kwargs.get('city', 'Unknown')

    def display_info(self):
        print(f"Name: {self.name}")
        print(f"Age: {self.age}")
        print(f"City: {self.city}")

# Creating an instance of the class with keyword arguments
person1 = Person(name='Alice', age=30, city='New York')

In this example, the Person class has an __init__ method that accepts keyword arguments using **kwargs. It then uses the kwargs.get() method to fetch values for attributes like name, age, and city. If these attributes are not provided, default values are used.

The display_info method displays the attributes of the instance.

When you run the code, it will create an instance of the Person class with the provided keyword arguments and then display the information:

Name: Alice
Age: 30
City: New York

Using kwargs in a class constructor allows you to create instances with flexible and named parameters, enhancing readability and usability.

Is kwargs a dict in Python?

Yes, kwargs is a dictionary (dict) in Python. When you use **kwargs in a function or method definition, it collects the keyword arguments passed to that function into a dictionary. Each keyword becomes a key in the dictionary, and its associated value becomes the corresponding value in the dictionary.

Here’s a quick example to illustrate this:

def print_kwargs(**kwargs):
print_kwargs(arg1='value1', arg2='value2', arg3='value3')

When you call print_kwargs with the provided keyword arguments, it will output something like:

{'arg1': 'value1', 'arg2': 'value2', 'arg3': 'value3'}

In this case, kwargs is indeed a dictionary containing the keyword arguments as key-value pairs. You can perform dictionary operations on kwargs just like you would with any other dictionary object.

How do you pass kwargs to a function in Python?

To pass kwargs (keyword arguments) to a function in Python, you simply use the double asterisks ** followed by the dictionary-like object containing the keyword-value pairs you want to pass. Here’s how you do it:

def example_function(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

# Calling the function and passing keyword arguments
example_function(arg1='value1', arg2='value2', arg3='value3')

In the above example, you call the example_function and provide keyword arguments by using the key=value syntax. These keyword arguments are then packed into a dictionary-like object and passed to the function as the kwargs parameter.

You can also create a dictionary and then pass its contents as kwargs to the function:

def another_function(**kwargs):

# Creating a dictionary
data = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

# Passing the dictionary contents as keyword arguments

In this case, the double asterisks ** unpack the dictionary data into keyword arguments and pass them to the another_function.

Keep in mind that the keys in kwargs become the parameter names within the function, and the associated values are their respective values.

Read More;

  • Muhammad Nabil

    I am a skilled and experienced Python developer with a huge passion for programming and a keen eye for details. I earned a Bachelor's degree in Computer Engineering in 2019 from the Modern Academy for Engineering and Technology. I am passionate about helping programmers write better Python code, and I am confident that I can make a significant contribution to any team. I am also a creative thinker who can come up with new and innovative ways to improve the efficiency and readability of code. My specialization includes Python, Django, SQL, Apache NiFi, Apache Hadoop, AWS, and Linux (CentOS and Ubuntu). Besides my passion for Python, I am a solo traveler who loves Pink Floyd, online video games, and Italian pizza.

Leave a Comment