Python, a versatile and expressive programming language, is known for its rich set of operators. Among these operators, the double asterisk (**), often referred to as the double star or double splat, is one of the less common yet powerful ones. In this blog post, we’ll delve into the world of double asterisks in Python, explaining its primary usage and providing code examples to demystify its role in the language.

The Double Asterisk Operator

In Python, the double asterisk (**) serves a specific purpose: it is used for dictionary unpacking. This operator is primarily associated with function definitions and function calls, allowing you to work with keyword arguments and dictionaries more flexibly.

Let’s explore its primary use cases and how it simplifies working with dictionaries.

Unpacking Dictionaries

One of the most common uses of the double asterisk is to unpack dictionaries. Consider a scenario where you have a dictionary, and you want to pass its key-value pairs as keyword arguments to a function. The double asterisk operator makes this process remarkably straightforward.

Here’s an example:

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

user_data = {
'name': 'John',
'age': 30,
'city': 'New York'


In this example, the print_user_info function accepts keyword arguments using the **kwargs syntax. We then pass the user_data dictionary to the function using **user_data, effectively unpacking the dictionary and passing its key-value pairs as keyword arguments.

The output will be:

User Information:
name: John
age: 30
city: New York

Merging Dictionaries

The double asterisk operator is also useful for merging dictionaries. You can combine the contents of multiple dictionaries into a single dictionary with ease.

Here’s an example of merging two dictionaries:

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}

merged_dict = {**dict1, **dict2}

print("Merged Dictionary:", merged_dict)

The result will be a merged dictionary:

Merged Dictionary: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

This technique is especially handy when you need to update the contents of a dictionary or create a new dictionary by combining existing ones.

Forwarding Arguments in Function Calls

The double asterisk operator is not limited to dictionary unpacking; it’s also valuable for forwarding keyword arguments in function calls. This is commonly seen in wrapper functions or decorators.

Consider a simple example:

def greeting_decorator(func):
def wrapper(**kwargs):
print("Hello, this is a greeting from the decorator.")
return wrapper

def greet(name):
print(f"Hello, {name}!")


In this example, the greet function is decorated with greeting_decorator. The decorator function wrapper accepts **kwargs and adds a greeting message before calling the original function. The double asterisk operator allows the decorator to forward any keyword arguments to the decorated function.

Handling Unspecified Keyword Arguments

The double asterisk operator is also useful when you want to accept unspecified keyword arguments in a function. By using **kwargs, you can capture any keyword arguments that are not explicitly defined in the function’s parameter list.

Here’s an example:

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

process_data(name='John', age=30, city='New York', occupation='Engineer')

In this case, the function process_data does not have predefined parameters, but it can accept any keyword arguments passed to it.


The double asterisk operator (**) in Python is a powerful tool that simplifies dictionary unpacking, merging, forwarding keyword arguments, and handling unspecified keyword arguments. It’s a key feature for functions that need to work with variable numbers of keyword arguments and is commonly used in advanced Python programming, such as decorators, function wrappers, and data manipulation.

By mastering the double asterisk operator, you can make your Python code more flexible and expressive, enhancing your ability to work with dictionaries and functions effectively.

Categorized in:

Learn to Code, Python, Python,

Last Update: May 2, 2024