Function Arguments in Python and types of Argument with Examples

Python Function Arguments or parameters:

We have already superficially discussed what functions are. In this article, we will discuss function arguments or parameters and how to use them, and we will learn about three alternative techniques for passing function arguments or parameters.

Types of python Function Arguments:

Optional function arguments:

First, this means that this python function Argument can be omitted when the function is called. An optional function Argument must be pre-assigned a value within the function, usually, a standard value that is sufficient in most of the function calls. With the function range, the third parameter regulates the step size and is with 1pre-assigned. The following calls to the range are therefore equivalent:

This is interesting because a function often has a standard behavior that can be adapted to special circumstances using additional python function Arguments. In the majority of cases, in which the standard behavior is sufficient, it would be cumbersome to specify the Arguments that are superfluous for this call. For this reason, predefined function Argument values ​​are often a useful addition to a function interface.

In order to assign a default value to a python function arguments, this value is written after the function Argument name together with an equal sign when defining the function. The following function is intended to calculate the sum of two, three, or four whole numbers, depending on the application, and return the result. The programmer should only have to enter as many numbers as he needs when calling the function:

In order to carry out addition, at least two function Arguments must have been passed. The other two will be with0pre-assigned. If they are not explicitly specified when the function is called, they are not included in the addition. The function can be called as follows:

Note that optional function Arguments may only appear at the end of a functional interface. This means that an optional function Argument can no longer be followed by a non-optional function Argument. This restriction is important so that all specified arguments or parameters can be clearly assigned.

 Keyword function arguments or parameters 

In addition to the so-called positional arguments used so far(Positional Arguments), there is another way of passing Arguments in Python. Such Arguments become keyword arguments(Keyword parameter) called. This is an alternative technique for passing Arguments when calling a function. Nothing changed in the definition of the function. Let us consider our sum function, which we wrote in the previous section:

This function can also be called as follows:

For this purpose, the function argument or parameters are set to the desired value in the function call, as with an assignment. Since the respective function Argument name must be specified when transferring, the assignment is clear under all circumstances. This allows the programmer to specify keyword Arguments in any order.

It is possible to combine both types of parameter transfer. It should be noted that no positional arguments may follow keyword arguments, so the latter must always be at the end of the function call.

Please also note that only Arguments that have not already been passed as positional arguments in the same function call may be passed as keyword arguments.

Any number of function arguments or parameters:

Call yourself again using the built-in function print in remembrance:

Obviously, it is possible to function print pass any number of arguments. This property is not exclusive to the print Function, but you can also define your own functions, to which any number of Arguments can be transferred can be.

For both forms of argument transfer (positional and keyword), there is a notation that enables a function to accept any number of Arguments. Let’s stay with the positional arguments for now. To do this, consider the following function definition:

First of all, there are two classic Arguments a and b, and a third name Further. The star in front of its name is important. When this function is called, a and b as you already know, reference the first two instances passed. What is interesting is that Further henceforth a tuple is referenced, which contains all additionally passed instances. This becomes clear when we consider the following function calls:

The function Argument Further references an empty tuple on the first call and a tuple on the second call in which all over a and b outgoing instances are included in the order in which they were submitted.

At this point we would like the function defined in the previous example total expand so that it can calculate the sum of a number of parameters specified by the user:

The following example demonstrates the use of the enhanced function total in an interactive mode:

This way of enabling a function to accept any number of function arguments or parameters also works for keyword arguments. The difference is that the parameter, which is to contain all further instances, must be written with two asterisks in the function definition. In addition, it does not reference a tuple later, but a dictionary. This dictionary contains the respective function Argument name as a key and the transferred instance as a value. To do this, consider the following function definition:

The parameter other thus references a dictionary that contains all the transferred keyword Arguments with values.

Both techniques for receiving any number of Arguments can be used together, as the following function definition shows:

You see that positional a tuple with all positional and keyword a dictionary with all keyword Arguments is referenced.

Pure keyword function arguments:

It is possible to define Arguments exclusively in the form of keyword Arguments that may be handed over. Such pure keyword Arguments [64] (English keyword-only parameters ) are written in the function definition after the function Argument that accepts any number of positional arguments:

In this case, the functional interface consists of the two position Arguments a and b, the possibility for other position parameters * c, and the two pure keyword Arguments d and e. There is no way of changing the Arguments d and e to be passed, except in the form of keyword Arguments.

As with position Arguments, pure keyword Arguments must be specified unless they are assigned a default value:

If the transfer of any number of keyword Arguments is to be made possible, the necessary one follows **-Notation after the pure keyword Arguments at the end of the function definition:

It is also possible to define pure keyword Arguments without allowing any number of position Arguments at the same time. For this purpose, the pure keyword Arguments in the function interface are replaced by a* separated from the position Arguments.

Unpacking function arguments list:

In this section you will learn about another possibility, Arguments passed to a function. To do this, imagine we wanted to use the extended version of the. Defined in section ” Any Number of Arguments “total-Function determines the sum of all entries of a tuple. The following notation is currently required for this:

It’s very cumbersome. We also run the generality of the function total contrary, because the number of elements of the tuple t must always be known. What is desirable is a way of being able to pass a list of arguments stored in an iterable object directly to a function. This process is called unpacking .

An iterable object is unpacked by adding an asterisk (*) is passed. In the following example this is done by the built-in function range generated iterable object used to use the function total to calculate the sum of the first 100 natural numbers: [65] (This when calling the function range(n) returned iterable object iterates through all integers from 0 through n – 1, inclusive. Therefore, in the example, 101 must be passed instead of 100. )

When the function is called, each element of the iterable object, in this case, the numbers from 0 to 100, is passed as a separate parameter. Unpacking a function Argument list does not only work in connection with a function that expects any number of Arguments, it can also work with the original function total, which determines the sum of a maximum of four Arguments, can be used:

Please note that the iterable object to be unpacked also provides a maximum of four (and at least two) elements:

Analogous to unpacking a tuple to a list of position Arguments, a dictionary can be unpacked to a list of keyword Arguments. The difference in the notation is that two asterisks must be preceded by:

 

It should also be mentioned that the techniques for unpacking function Argument lists can be combined with one another, as the following example shows:

Since Python 3.5 it is possible to unpack several sequences or dictionaries in the same function call:

Keyword arguments may not be passed more than once.

Since Python 3.5 there has also been the option of using packing or unpacking when generating sequential data types, quantities and dictionaries:

If the same key is transferred multiple times in a dictionary, the last key-value pair counts:

Example:

How to write a program, which takes the name and id for the user using the function argument concept:

I am writing a program that asks the user for their name and their ID and the ID doesn’t really matter just give it like a one or two-digit number and I want to be able to print back on the screen your name is blank and your ID is whatever you put in.

 

output:

Program explanation:

First I make a definition of a function using keyword def and the function name is getdata and inside the  parentheses, I pass in an argument and what we can do is we can just set some variable name and I’m gonna pass name, I’ll just show you how to pass in one argument  after colon ( : ) press enter

I write a print, and inside the print statement I write hello and then concatenate that with the variable name that we passed then I call the function but we want to prompt the user to enter their name so the way I can do that is I define username variable. I am giving it the value input and inside an input, i  put in a string that prompts the user to write something so what we can say what’s your and input is a predefined function in Python that we’ve gone over before so you know that input will return the value that is entered after this string what’s your name, executed and it’ll be thrown into the variable named username now what we can do is throw in user name into the getdata function so the way we do that is we just say getdata(userName) and inside the parentheses, we’re just going to pass in the username, and the name is just a placeholder it’s a variable so this isn’t too important.