In this lesson, We will examine the many functions in Python, including built-in, recursive, lambda, and user-defined functions, along with their syntax and examples. Also, we will learn about some of the python function’s lists, the advantages of using user-defined functions, and recommended best practices.
The Python Function Tutorial will now begin.
There are four categories into which we can divide functions:
Several features of the Python interpreter are available at all times. The functions whose functionality is predefined in Python are referred to as built-in functions in Python. You can find information on Python’s built-in functions on the https://docs.python.org/3/library/functions.html reference page.
The abs() function in Python returns the absolute value of a number.
The All() function in Python returns true when all elements in iterable are true.
The any() function in python checks if any element of an Iterable is True
The repr() function in Python returns a printable representation of the object.
The reversed() function in Python returns the reversed iterator of a sequence.
The python round() function rounds a number to specified decimals.
The python set() function constructs and returns a set.
The python setattr() function sets the value of an attribute of an object.
The python slice() function returns a slice object.
Python’s sorted() method uses the supplied iterable to produce a sorted list.
The python str() function returns the string version of the object.
The python sum() function adds items of an Iterable.
The python super() function returns a proxy object of the base class.
The tuple() function in Python returns a tuple.
The type() function in Python returns the type of the object.
The import statement calls the python import function.
User-defined functions are those that we define ourselves to carry out a particular purpose. We’ve already learned about how to define and call functions in Python.
Built-in functions are those that come pre-installed with Python. It is possible to refer to functions that are used that were created by others as library functions. User-defined functions include all additional functions that we create on our own. Therefore, to someone else, our user-defined function might be a library function.
You will discover how to develop a recursive function in this lesson (a function that calls itself).
The Latin verb recurrent, which means to hurry or hasten back, return, revert, or recur, is where the word “recursion” originates.
“The act of running back is recursion.”
A physical example would be to align two parallel mirrors to face one another. You can reflect any object in their path recursively.
Recursion requires great attention on the developer’s part because writing a function that never ends or consumes excessive amounts of memory or processing resources is very simple. However, Recursion may be a very effective and elegant mathematical method for programming if appropriately used.
The Python interpreter constructs a new local namespace when you call a function to prevent names declared within a function from colliding with those defined elsewhere. Because the objects have different names and live in different namespaces, one function can call another even if they declare identical objects.
Here is an illustration of a recursive function that calculates an integer’s factorial.
The sum of all the integers from 1 to a certain number is factorial. For instance, 1*2*3*4*5 = 120 is the factorial of 5.
Example
def facFunc(var):
if var == 1:
return 1
else:
rec_call = facFunc(var - 1)
res = rec_call * var
print (var, '*', rec_call, '=', res)
return res
number = 5
print ('Result= The Factorial of', number, 'is', facFunc(number))
Output
2 * 1 = 2 3 * 2 = 6 4 * 6 = 24 5 * 24 = 120 Result= The Factorial of 5 is 120
This function will call itself recursively by decreasing the number (facFunc(var-1) )when called with a positive integer. Until an integer equals one, each function multiplies it by the factorial of the number below it. When the number falls to 1, our Recursion comes to an end. Every recursive function needs a base condition to end the Recursion; otherwise, it will keep calling itself. The base condition is what we refer to as. The Python interpreter restricts the recursion depths to prevent infinite recursions that could lead to stack overflows.