How to Call a Function in Python?

Understanding how to call a function in Python correctly is pivotal for effective code execution. Functions, serving as vital building blocks of code, are designed to fulfill specific tasks. Proficiency in invoking these functions not only ensures cleaner code but also contributes to code reusability. This guide will help you understand the basics of calling functions in Python.

How to define a function with def keyword?

For defining a function, we use the def keyword to declare or write the function statements :

Suppose we have created a function using the above syntax, then we can call the function by writing function_name().

Below syntax can be followed :

Example : 1

In this example, we are defining a function and then calling it and printing the values.

Output

Example : 2

In this example, we are printing the value from inside the function.

Output

How To Call A Function In Python ?

To call a function, use the function name followed by parentheses:

Output

Arguments

Data can be passed into functions as arguments. Arguments are specified after the function name, inside the parentheses. You can add as many arguments as you want, separated with commas.

Output

Arguments are often shortened to args in Python documentations.

Parameters or Arguments?

The terms parameter and argument can be used for the same thing: information that is passed into a function.

From a function's perspective:

• A parameter is the variable listed inside the parentheses in the function definition.
• An argument is the value that is sent to the function when it is called.

Number of Arguments

By default, a function must be called with the correct number of arguments. Meaning that if your function expects 2 arguments, you have to call the function with 2 arguments, not more, and not less.

Output

If you try to call the function with 1 or 3 arguments, you will get an error:

Output

Arbitrary Arguments, *args

If you do not know how many arguments will be passed into your function, add a * before the parameter name in the function definition.

This way, the function will receive a tuple of arguments and can access the items accordingly:

Output

Arbitrary Arguments are often shortened to *args in Python documentations.

Keyword Arguments

You can also send arguments with the key = value syntax. This way, the order of the arguments does not matter.

Output

The phrase Keyword Arguments is often shortened to kwargs in Python documentations.

Arbitrary Keyword Arguments, **kwargs

If you do not know how many keyword arguments will be passed into your function, add two asterisks: ** before the parameter name in the function definition.

This way, the function will receive a dictionary of arguments and can access the items accordingly:

Output

Arbitrary Keyword Arguments are often shortened to **kwargs in Python documentations.

Default Parameter Value

The following example shows how to use a default parameter value. If we call the function without argument, it uses the default value:

Output

Passing a List as an Argument

You can send any data types of arguments to a function (string, number, list, dictionary, etc.), and it will be treated as the same data type inside the function.

For example, if you send a List as an argument, it will still be a List when it reaches the function:

Output

Return Values

To let a function return a value, use the return statement:

Output

The pass Statement

Function definitions cannot be empty, but if you, for some reason, have a function definition with no content, put in the pass statement to avoid getting an error.

Positional-Only Arguments

You can specify that a function can have ONLY positional arguments or ONLY keyword arguments.

To specify that a function can have only positional arguments, add , / after the arguments:

Output

Without , /, you are actually allowed to use keyword arguments even if the function expects positional arguments:

Output

But when adding , /, you will get an error if you try to send a keyword argument:

Output

Keyword-Only Arguments

To specify that a function can have only keyword arguments, add *, before the arguments:

Output

Without the *, you are allowed to use positional arguments even if the function expects keyword arguments:

Output

But when adding *, /, you will get an error if you try to send a positional argument:

Output

Combine Positional-Only and Keyword-Only

You can combine the two argument types in the same function. Any argument before the / is positional-only, and any argument after the *, is keyword-only.

Output

Recursion

Python also accepts function recursion, which means a defined function can call itself. Recursion is a common mathematical and programming concept. It means that a function calls itself. This has the benefit of meaning that you can loop through data to reach a result.

The developer should be very careful with recursion, as it can be quite easy to slip into writing a function that never terminates or one that uses excess amounts of memory or processor power. However, when written correctly, recursion can be a very efficient and mathematically-elegant approach to programming.

In this example, recur() is a function that we have defined to call itself ("recurse"). We use the x variable as the data, which decrements (-1) every time we recurse. The recursion ends when the condition is not greater than 0 (i.e., when it is 0).

Output

Calling Nested Function In Python

We can also create and call the nested function, for that we just have to create the nested function inside the main function and call it in the main function for executing it.

Example :

In this example, we are creating the main function and a nested function inside it. For executing the nested function, we can just simply call the nested function inside the main function definition.

Output :