Args and Kwargs in Python

Last Updated on June 27, 2023 by Prepbytes

*args specifies the number of non-keyworded arguments that can be passed and the operations that can be performed on the function in Python whereas **kwargs is a variable number of keyword arguments that can be passed to a function that can perform dictionary operations. args and kwargs in python are really very important, lets discuss why and also what is args and kwargs in python.

Why do we need *args and **kwargs?

When writing Python code, functions play a crucial role in removing code repetition and promoting modularity. They are designed to handle data, known as arguments, which can be in the form of strings, numbers, or even other functions.

Let’s consider a practical scenario to understand the importance of functions. Imagine you’re running a website where users can design greeting cards. To display a personalized greeting message like "Hello name_of_user," you need to ask the user to input their name. This input will be passed to a function responsible for displaying the greeting message.

However, there are cases where the number of arguments needed for a function may vary, making it challenging to predict in advance. Dealing with this uncertainty can be problematic if you don’t know how to handle it. It can lead to writing repetitive code for different argument scenarios, which is both time-consuming and error-prone.

To tackle this issue, Python provides a solution in the form of *args and **kwargs. These special syntaxes enable developers to handle functions with a variable number of arguments and keyword arguments, respectively. They offer flexibility and versatility, allowing functions to accommodate different argument scenarios without explicitly defining each one.

Using args, you can pass a variable number of positional arguments to a function. The asterisk (*) before "args" unpacks the arguments, creating a tuple-like object that can be accessed within the function.

Similarly, **kwargs allows you to pass a variable number of keyword arguments to a function. The double asterisks (**) before "kwargs" unpack the keyword arguments, creating a dictionary-like object that can be accessed within the function.

By leveraging *args and **kwargs, you can create functions that adapt to different argument situations, eliminating the need to write repetitive code for each variation. This makes your code more efficient, concise, and maintainable.

In conclusion, when writing Python code, understanding how to handle varying numbers of function arguments is essential. By utilizing *args and **kwargs, you can harness the power of flexible function parameters, promote code reuse, and enhance the overall modularity of your programs.

*args and **kwargs are the solution to your problem.

*args in Python

Let’s say your goal is to create a calculator that can only perform multiplication.

You can create a straightforward function that can accomplish this, and it will look like this-

Code Implementation

def multiply(num1,num2):
    return num1*num2
 
print("product:", multiply(2,3))

Output:

product:6

Now you want to multiply three numbers, so you have to make a new function.

Code Implementation

def multiplyThreeNumbers(num1, num2, num3):
    return num1*num2*num3
 
print("product:",multiplyThreeNumbers(1, 2, 3))

Output:

product:6

You can already see the problem. If you keep going on like this, you will end up doing a lot of functions.

*args can save you the trouble here.

You can use args to solve this problem in a simple and flexible piece of code-

Code Implementation

def multiplyNumbers(*numbers):
    product=1
    for n in numbers:
        product*=n
    return product
 
print("product:",multiplyNumbers(1,2,3,4,5))

Output:

product : 120

Now that we have resolved the issue, let’s delve into understanding the concept behind it.

In Python, there is a feature called *args that enables the passing of a variable number of non-keyword arguments to a function. Non-keyword arguments refer to arguments that are not in the form of key-value pairs, such as numbers or strings.

It is important to note that "args" is merely an identifier and can be named based on relevance or preference.

When an asterisk () is placed before the variable name in a Python function, it signals to Python that the number of arguments is not predetermined. Python then creates a tuple of these arguments using the name specified after the asterisk (). This variable becomes accessible within the function. This asterisk (*) is commonly referred to as the "unpacking operator," which we will explore further in this article.

Once inside the function, this variable containing the arguments can be utilized for various operations. In the case mentioned earlier, we iterated over the arguments and calculated their product.

Understanding the usage of *args allows for the creation of more flexible functions that can accommodate varying numbers of non-keyword arguments. This feature expands the capabilities of your code, making it adaptable to different scenarios.

As we progress in this article, we will explore more concepts related to *args and gain a deeper understanding of its applications.

**kwargs in Python

*args provides the ability to pass a variable number of non-keyword arguments to functions, but it does not support passing keyword arguments. Keyword arguments are arguments that consist of key-value pairs, similar to a Python dictionary.

To address the need for passing keyword arguments, Python offers **kwargs. With **kwargs, you can pass any number of keyword arguments to a function.

In Python, these keyword arguments are passed to the program as a dictionary object. When a variable name with two asterisks (**) preceding it is encountered in a function definition, Python recognizes it as a keyword argument.

By leveraging **kwargs, you gain the flexibility to pass and handle multiple keyword arguments within a function. This capability enhances the versatility of your code and allows for more expressive function calls.

As we delve deeper into this article, we will explore further aspects of **kwargs and its practical applications in Python programming.

Code Implementation

def makeSentence(**words):
    sentence=''
    for word in words.values():
        sentence+=word
    return sentence
 
print('Sentence:', makeSentence(a='Kwargs ',b='are ', c='awesome!'))

Output:

Sentence :Kwargs are awesome! 

In the makeSentence function, we are iterating over a dictionary, so we have to use values() to use the values. Otherwise, it will only return the keys and not the values.

Another example of how kwargs can be used is given below-

Code Implementation

def whatTechTheyUse(**kwargs):
    result = []
    for key, value in kwargs.items():
        result.append("{} uses {}".format(key, value))
    return result
 
print(whatTechTheyUse(Google='Angular', Facebook='react', Microsoft='.NET'))

Output:

[‘Google uses Angular’, ‘Facebook uses react’, ‘Microsoft uses .NET’]

In this code, we have used .items() because we want to get both the key and the value.

Using Both *args and **kwargs in a Python Function

Now that we have gained an understanding of *args and **kwargs, you may be interested in designing a function that utilizes both of them. It is important to note that the order of the arguments is crucial, and *args must come before **kwargs.

If you intend to use standard arguments along with *args and **kwargs, it is necessary to follow this specific order:

Standard arguments: These are the arguments defined in the function signature without any special syntax.

*args: This allows for a variable number of non-keyword arguments to be passed to the function.

**kwargs: This enables the passing of a variable number of keyword arguments to the function.

By adhering to this order, you ensure the proper handling and unpacking of the arguments within the function. Following this convention maintains consistency and clarity when working with functions that accept multiple types of arguments.

As you continue to explore and implement *args and **kwargs in your Python code, keeping this order in mind will help you effectively leverage their capabilities and create more flexible and versatile functions.

Code Implementation

def printingData(codeName, *args, **kwargs):
    print("I am ", codeName)
    for arg in args:
        print("I am arg: ", arg)
    for keyWord in kwargs.items():
        print("I am kwarg: ", keyWord)
 
printingData('007', 'agent', firstName='James', lastName='Bond')

Output:

  I am 007 
  I am arg: agent 
  I am kwarg: (‘firstName’, ‘James’) 
  I am kwarg: (‘lastname’ , ‘Bond’)

Packing and Unpacking Using *args and **kwargs in Python

Unpacking operators are what we refer to as single and double asterisks.

Variables from iterable data types like lists, tuples, and dictionaries are unpacked using unpacking operators.

Any iterable that Python provides is marked with a solitary asterisk(*).

To iterate through dictionaries, use the double asterisk (**).

Let’s take some examples,

Code Implementation

carCompany = ['Audi','BMW','Lamborghini']
print(*carCompany)

Output:

Audi BMW Lamborghini

Here the asterisk(*) passed before carCompany unpacked all the values. In other words, the values are printed as separate strings rather than a list.

Code Implementation

techStackOne = {"React": "Facebook", "Angular" : "Google", "dotNET" : "Microsoft"}
techStackTwo = {"dotNET" : "Microsoft"}
mergedStack = {**techStackOne, **techStackTwo}
print(mergedStack)

Output:

{'React': 'Facebook', 'Angular': 'Google', 'dotNET': 'Microsoft'}

The double-asterisk in this case unpacked the key-value pairs inside the mergedStack variable, giving us access to all of the key-value pairs inside. When it comes to unpacking the contained values, Python’s args and kwargs perform the same function, but they have different inputs and outputs.

Conclusion
In conclusion, *args and **kwargs are powerful features in Python that enable developers to create more flexible and versatile functions. Understanding their usage and benefits can significantly enhance your ability to handle varying numbers of arguments and keyword arguments in your code.

With *args, you can pass a variable number of non-keyword arguments to a function, while **kwargs allows you to pass a variable number of keyword arguments. By leveraging these features, you can design functions that adapt to different input scenarios without the need for explicitly defining each possibility.

Combining args and **kwargs in a single function definition offers even greater flexibility. Remember to follow the order of standard arguments, args, and **kwargs when designing functions that utilize all three.

The usage of *args and **kwargs is not limited to specific programming domains. They can be employed in various contexts, including web development, data analysis, and system programming, among others. Embracing these features empowers you to write more modular, reusable, and adaptable code.

FAQ Related to argos and kwargs in Python

Q1: Can I use both *args and **kwargs in the same function?
Yes, you can use both *args and **kwargs in the same function. However, it is important to follow the recommended order: standard arguments, *args, and then **kwargs. This ensures proper handling and unpacking of the arguments within the function.

Q2: What is the difference between *args and **kwargs?
*args allows you to pass a variable number of non-keyword arguments to a function, while **kwargs enables you to pass a variable number of keyword arguments. *args collects the arguments into a tuple, while **kwargs collects the keyword arguments into a dictionary.

Q3: When should I use *args and **kwargs?
*args and **kwargs are particularly useful when the number of arguments or keyword arguments is uncertain or can vary. They provide flexibility in handling different input scenarios and make your code more adaptable and reusable.

Q4: Can I pass arguments by name using *args and **kwargs?
No, *args and **kwargs are used for passing arguments without specifying their names. *args handles non-keyword arguments, while **kwargs handles keyword arguments. If you need to pass arguments by name, you can use standard arguments in combination with **kwargs.

Q5: Are *args and **kwargs limited to specific programming domains?
No, *args and **kwargs can be utilized in various programming domains and scenarios. They are not limited to specific areas of programming and can be applied wherever flexibility and variability in function arguments are required.