Home

Learning Hub

Articles

Arguments and Parameters in Python – Everything You Need to Know

When we define a function in Python programming, we have to feed them values. This is where we use arguments and parameters in Python.

In some basic terms, parameters are those placeholders in a definition of a function waiting to be replaced by values. They are the variables that are defined in the function’s parentheses. Then, arguments are the actual values we pass into the function when we call it. Those arguments fill the placeholders that are called parameters when the function runs.

Let’s look at an example. Think of a function as a machine, taking some inputs (arguments) and then producing some outputs based on its design (parameters).

Output:

Here, name is the parameter in the function definition. It’s waiting to accept a value when the function is called. The actual input, “Devesh Kumar,” is the argument.

Also Read: Python Functions

Explain the Key Differences Between Arguments and Parameters

To simplify, parameters set the stage and arguments act on that stage. Here’s a quick comparison:

Types of Arguments in Python Functions

There are a number of ways of passing arguments into functions in Python. Arguments can be categorised into four major types depending on how we use them:

• Positional Arguments
• Keyword Arguments
• Default Arguments
• Variable-Length Arguments

Let’s break them down one by one:

1. Positional Arguments

Positional arguments are the most simple to work with in Python. Positionally, you must pass the arguments in the sequence defined by parameters. The position of each argument is important.

Example: Suppose a function has two parameters and is being called with two arguments. In that case, the first argument will go to the first parameter, and the second to the second parameter.

Now, let’s look at a code example:

Output:

In this example, the values that we pass in as num1 and num2 are passed into x and y in a way determined by the order in which the function is called.

Also Read: Python Function Overloading

2. Keyword Arguments

Keyword arguments allow us to pass arguments in by explicitly referencing the name of the parameter in the function call. This has the consequence that the order of the arguments becomes irrelevant so long as we reference the names of the parameters.

By using the keyword arguments, we can make our code pretty readable and avoid errors that could arise due to confusing the order of the arguments

Here’s how we can use keyword arguments in practice:

Output:

As you can see, we reversed the order of the arguments, but it worked fine because we used the parameter names x and y.

3. Default Arguments

The Default arguments are used to assign default values to parameters. If while calling the function no particular value is assigned for one of the arguments, Python uses the default value.

This is very useful when we wish for a function that can handle both cases: when an argument exists, and when it does not.

Let’s see this in action:

Output:

In the first function call, we didn’t pass any arguments, so Python used the default value “Guest.” In the second call, we passed “Sita,” which replaced the default.

4. Variable-Length Arguments

We may encounter situations where we do not know in advance how many arguments a function has to accept. Python lets us handle this situation by using *args for non-keyword arguments and **kwargs for keyword arguments.

• *args allows a function to accept any number of positional arguments.
• **kwargs allows a function to accept any number of keyword arguments.

Here’s an example of how to use *args:

Output:

Now, let’s look at **kwargs:

Output:

Importance of Argument Order and Common Pitfalls

When working with arguments and parameters in Python, it is important to know that the order matters. Have you ever passed arguments to a function only to get a really confusing error? This happens whenever the order of positional and keyword arguments gets mixed up.

In Python, positional arguments always go before keyword arguments. It’s not a good practice, it’s a rule. If we try to pass a positional argument after a keyword argument, Python raises a SyntaxError.

Here’s an extremely simple example:

Output:

In the second call, we tried to pass a positional argument (21) after a keyword argument (name=”Rahul”), and Python didn’t like it.

How to not do that:

• Always make sure that positional arguments are passed first.
• Use keyword arguments for flexibility if the position does not matter.

Common Mistakes:

• Missing Required Arguments: If all required positional arguments are not provided an error of TypeError is raised.
• Conflicting Argument Types: When combining positional and keyword arguments, in the wrong order as above, then a TypeError is raised too.

All the above are totally avoided if ordered properly

Python’s Special Argument-Passing Model: Call by Assignment

Another question developers are likely to have about Python is whether it uses call by value or call by reference. The answer? It’s neither! Python uses a method known as call by assignment.

What does this mean, exactly?

When we pass arguments to a function, Python assigns the object’s reference to the parameter. If we pass mutable objects, for example, lists, the function can actually modify the original object. If we pass immutable objects, for example, integers, a modification inside the function wouldn’t affect the value outside.

Here’s a code example to show how it works:

Output:

In this case, since lists are mutable, both inside and outside the function, the list was changed.

Now let’s see how it works with an immutable object like an integer:

Output:

Although the number changed inside the function, it didn’t affect the value outside because integers are immutable.

So, when working with mutable objects like lists, dictionaries, or sets, you will be careful. Modifying something inside a function has an effect outside.

As we pass arguments in Python, we need to know whether the object that we’re passing is mutable or immutable. Why? Because it changes the way Python passes those modifications around inside that function.

Mutable Objects

Mutable objects are those that can be changed once constructed. These are:

• Lists
• Dictionaries
• Sets

If we pass a mutable object into a function and alter it inside the function then changes will reflect on that original object also, outside of the function.

Here’s another example with a dictionary:

Output:

Both inside and outside the function, the dictionary was updated.

Immutable Objects

Immutable objects, on the other hand, cannot be changed after they are created. Examples include:

• Integers
• Strings
• Tuples

When we pass immutable objects to a function, any changes made inside the function won’t affect the original object.

Here’s an example with a string:

Output:

Since strings are immutable, the change inside the function did not propagate to the original student_name variable.

Function Parameters in Python and Their Flexibility in Function Design

Python functions have a lot of flexibility in designing them because of the several types of parameters available to use. We can mix up the compulsory, optional types of parameters along with the variable-length parameters such as *args and **kwargs.

Let’s see how to apply them in practice.

Required Parameters

These are the most basic type. We must provide arguments for every required parameter.

Here, a and b are required. If we don’t provide values for both, Python will raise an error.

Optional Parameters with Default Values

Sometimes, we don’t need to pass every argument. This is where default values come in handy. We can set a default value for a parameter, and if no argument is passed, Python uses the default.

Variable-Length Parameters (*args and **kwargs)

Quite often, however, we do not know how many arguments we need to pass. *args lets us specify a variable number of positional arguments; **kwargs handles keyword arguments

Output:

In the above example, we passed a variable number of grades to the function, and it handled them smoothly.

Python gives us the flexibility to design functions based on our needs:

• Required parameters for strict control.
• Optional parameters for flexibility.
• Variable-length parameters when we don’t know how many arguments we’ll get.

Enroll Now: Free Python Course

Common Mistakes When Using Arguments and Parameters in Python

When working with arguments and parameters in Python, we can easily run into mistakes that can break our code. Even the best programmers have these problems sometimes. Let’s discuss the most common mistakes and how you avoid them.

Forgetting to Provide Required Arguments

If a function has parameters that don’t have default values, Python expects us to provide them. Forgetting to pass a required argument results in a TypeError.

Solution: Always check that you’ve provided values for all required parameters.

Mixing Positional and Keyword Arguments Incorrectly

As we discussed earlier, the order of arguments matters. Positional arguments must come before keyword arguments. Mixing them up leads to a SyntaxError.

Solution: Keep keyword arguments at the end when calling a function.

Modifying Mutable Default Arguments

The consequence of using mutable objects, such as lists or dictionaries, as default arguments is that you might get some unexpected behaviour. Changes made in the first call will be observed in the next because the object used is shared across all function calls.

Solution: Use None as the default value for mutable objects and initialise them inside the function.

Passing Too Many or Too Few Arguments

When there are more arguments than expected or fewer arguments than expected, a TypeError is raised. A function expects to take the same amount of arguments as parameters unless we’re using *args or **kwargs.

Solution: Double-check the number of arguments passed and make sure it matches the function definition.

Misusing *args and **kwargs

Sometimes, developers get confused about how *args and **kwargs work, especially when used with other arguments. The key is to understand their placement: *args collects extra positional arguments, and **kwargs collects extra keyword arguments.

Solution: Remember that *args and **kwargs should always come after regular parameters in the function definition.

Also Read: Python Interview Questions and Answers

Conclusion

A Programmer must know the difference between arguments and parameters in Python to write clean, effective code. With the ability to pass arguments of various kinds, including positional, keyword, default and variable-length, flexibility in function design is greatly added.

Knowing how Python behaves when passing arguments via call by assignment prevents people from stumbling over common pitfalls, especially involving both mutable and immutable objects. Avoid wasting time and getting frustrated over common errors involving either a mix-up of positional and keyword arguments or the use of mutable objects for default parameters.

Mastering these concepts helps us design flexible functions that can easily make their way through a wide array of inputs and sidestep common pitfalls for efficient coding in Python.

Want to dive deeper into Python and beyond? Then you must check out the Integrated Program in Data Science, Artificial Intelligence & Machine Learning by Hero Vired. This will prove beneficial in advancing your knowledge and being ready for future technology.