As you progress in Python programming, you will undoubtedly want to use some functions to perform specific programming tasks, so understanding what they are is critical.
In this article, we'll look at these functions, learning what they are and when and how to use them.
What Is a Function?
As the name implies, a function is simply a block of code that performs a task when called. Taking, for instance, I want my program to print a statement. I can call out the print() function to perform this task.
x='Hello World'
print(x)
That's how functions work; you call them, and they perform their tasks:
Types of Python Functions
The python functions are grouped into the following.
- Python Built-in functions
- User-defined function
- Lambda function
- Recursion function
Built-in Functions
Built-in functions are pre-defined functions in Python. They are the functions included with Python interpreters. The tasks they are to complete have already been created; you need to call them out to complete those tasks in line with your program.
The print() function in the example stated earlier is an example of a built-in function. There are many other built-in functions like input(), map(),len(), etc. To know more about the built-in functions, you can check my blog here: basic built-in python functions to know
User-Defined Functions
These are functions that we create to perform specific tasks. A user-defined function can be given any name.
It differs from the built-in function in many ways. One of which is that it is a function that we develop in our program to fulfill the purpose for which it was developed, as opposed to a built-in function, which already has tasks and only needs to be called to perform them.
Another significant difference is that, unlike built-in functions, where the names have been programmed with the python interpreter, we are always free to change the name of our function.
We define them with the def keyword, followed by the name we want to give to the function. For instance:
def variable(x):
return x/2
print(variable(10))
Output:
5.0
The above example is a simple way of performing an arithmetic operation using our created function. As you can see above, the function's name is variable, and I might wish to change its name and give it whichever name I love without it affecting the output:
def my_name(Name):
print('My name is ' + Name)
my_name('John')
my_name('Collins')
Output:
My name is John
My name is Collins
The example above is another way of how the user-defined function operates. The idea is to use the def word to define the function while adding the name we want to call it and assigning the task we want it to perform.
Lambda Function
They are referred to as nameless or anonymous functions. A lambda function is just like any python function, except that it has no name when it is being defined and is usually contained in one line of code. We create the lambda function using the lambda operator.
As I mentioned earlier, one thing to keep in mind about the lambda function is that it is usually contained in a single line of code. Instead of writing a bunch of programs to do what you want the computer to do, you can call the lambda function and tell it what task you want it to do, and it will do it.
Using the first user-defined function example, I can rewrite the code by calling the lambda function as follows:
y=lambda x:x/2
y(10)
Output:
5.0
The output is the same, but notice how I assigned the task using the lambda function in a single line of code, which adds to the brevity of my code. That is a significant advantage of the lambda function. Although this is not the best way to use a lambda function, it is still one of the things it can do to your program.
As demonstrated in the preceding example, a lambda function is created using the lambda operator. They work best when combined with other higher-order functions.
Note: Higher-order functions are those that interact with other functions. Filter(), map(), and reduce() are built-in functions that are higher-order function
Take, for example, the filter() function. This function filters elements from a given iterable (lists, sets, tuples) and returns true if the function is true. When used with the lambda function, it verifies that all elements are true per the expression passed within the lambda function.
Old_list =[0, 2,5,7,9,]
new=list(filter(lambda x:(x*2==10), Old_list))
print(new)
Output:
[5]
This example explains the previous statement. The filter() function checked if the condition made with the lambda function was actual for all iterables and returned [5] as the output, indicating that it was the only element that fit the condition made with the lambda function.
The lambda function interacts with a higher-order function in this manner.
Recursive Function
The recursion function is a function that keeps calling itself and repeating its behavior until some condition is met, at which point it returns itself. It's a function that can invoke itself.
We use them mainly because they decompose complicated issues into simpler ones and because using recursion to create sequences is more straightforward than using loops inside loops.
The recursive function can be used to find the factorial of an integer.
def fact(x):
if x==1:
return x
else:
return x* fact(x-1)
value=4
answer=fact(4)
print(' The factorial of', value, 'is', answer)
Output:
The factorial of 4 is 24
Our x, which begins with four, is not equal to one, so it executes the command in the else statement and continues until the condition that x is equal to one is met.
That is how recursion operates. It must always be subject to a condition that stops it from calling itself; otherwise, the program would continue to execute, which is one of its disadvantages.
They can also be challenging to debug, but the recursion function is the most useful for sequence generation.
Conclusion
The functions mentioned above are the most important in Python. As a result, it is critical to understand what they are and how to apply them best. Try out the use cases to better understand and create your use case.
Constant practice makes perfect.