In Python, the function is a block of code defined with a name. We use functions whenever we need to perform the same task multiple times without writing the same code again. It can take arguments and returns the value.
Python has a DRY principle like other programming languages. DRY stands for Don’t Repeat Yourself. Consider a scenario where we need to do some action/task many times. We can define that action only once using a function and call that function whenever required to do the same activity.
Function improves efficiency and reduces errors because of the reusability of a code. Once we create a function, we can call it anywhere and anytime. The benefit of using a function is reusability and modularity.
Table of contents
- Types of Functions
- Creating a Function
- Calling a function
- Return Value From a Function
- The pass Statement
- How does Function work in Python?
- Scope and Lifetime of Variables
- Python Function Arguments
- Recursive Function
- Python Anonymous/Lambda Function
Types of Functions
Python support two types of functions
- Built-in function
- User-defined function
The functions which are come along with Python itself are called a built-in function or predefined function. Some of them are listed below.
Example: Python range() function generates the immutable sequence of numbers starting from the given start integer to the stop integer.
for i in range(1, 10): print(i, end=' ') # Output 1 2 3 4 5 6 7 8 9
Functions which are created by programmer explicitly according to the requirement are called a user-defined function.
Creating a Function
Use the following steps to to define a function in Python.
- Use the
defkeyword with the function name to define a function.
- Next, pass the number of parameters as per your requirement. (Optional).
- Next, define the function body with a block of code. This block of code is nothing but the action you wanted to perform.
In Python, no need to specify curly braces for the function body. The only indentation is essential to separate code blocks. Otherwise, you will get an error.
Syntax of creating a function
def function_name(parameter1, parameter2): # function body # write some action return value
function_name: Function name is the name of the function. We can give any name to function.
parameter: Parameter is the value passed to the function. We can pass any number of parameters. Function body uses the parameter’s value to perform an action
function_body: The function body is a block of code that performs some task. This block of code is nothing but the action you wanted to accomplish.
- return value: Return value is the output of the function.
Note: While defining a function, we use two keywords,
def (mandatory) and
Creating a function without any parameters
Now, Let’s the example of creating a simple function that prints a welcome message.
# function def message(): print("Welcome to PYnative") # call function using its name message()
Welcome to PYnative
Creating a function with parameters
Let’s create a function that takes two parameters and displays their values.
In this example, we are creating function with two parameters ‘ name’ and ‘age’.
# function def course_func(name, course_name): print("Hello", name, "Welcome to PYnative") print("Your course name is", course_name) # call function course_func('John', 'Python')
Hello John Welcome to PYnative Your course name is Python
Creating a function with parameters and return value
Functions can return a value. The return value is the output of the function. Use the return keyword to return value from a function.
# function def calculator(a, b): add = a + b # return the addition return add # call function # take return value in variable res = calculator(20, 5) print("Addition :", res) # Output Addition : 25
Calling a function
Once we defined a function or finalized structure, we can call that function by using its name. We can also call that function from another function or program by importing it.
To call a function, use the name of the function with the parenthesis, and if the function accepts parameters, then pass those parameters in the parenthesis.
# function def even_odd(n): # check numne ris even or odd if n % 2 == 0: print('Even number') else: print('Odd Number') # calling function by its name even_odd(19) # Output Odd Number
Calling a function of a module
You can take advantage of the built-in module and use the functions defined in it. For example, Python has a random module that is used for generating random numbers and data. It has various functions to create different types of random data.
Let’s see how to use functions defined in any module.
- First, we need to use the import statement to import a specific function from a module.
- Next, we can call that function by its name.
# import randint function from random import randint # call randint function to get random number print(randint(10, 20)) # Output 14
In Python, the documentation string is also called a docstring. It is a descriptive text (like a comment) written by a programmer to let others know what block of code does.
We write docstring in source code and define it immediately after module, class, function, or method definition.
It is being declared using triple single quotes
(''' ''') or triple-double quote
We can access docstring using doc attribute
(__doc__) for any object like
dict, and user-defined function, etc.
The single-line docstring is a docstring that fits in one line. We can use the triple single or triple-double quotes to define it. The Opening and closing quotes need to be the same. By convention, we should use to use the triple-double quotes to define docstring.
def factorial(x): """This function returns the factorial of a given number.""" return x # access doc string print(factorial.__doc__)
This function is going to return the factorial of a given number
When you use the help function to get the information of any function, it returns the docstring.
# pass function name to help() function print(help(factorial))
Help on function factorial in module main: factorial(x) This function returns the factorial of a given number. None
A multi-line Docstrings is the same single-line Docstrings, but it is followed by a single blank line with the descriptive text.
The general format of writing a multi-line Docstring is as follows:
def any_fun(parameter1): """ Description of function Arguments: parameter1(int):Description of parameter1 Returns: int value """ print(any_fun.__doc__)
Description of function Arguments parameter1(int):Description of parameter1 Returns: int value
Return Value From a Function
In Python, to return value from the function, a
return statement is used. It returns the value of the expression following the returns keyword.
def fun(): statement-1 statement-2 statement-3 . . return [expression]
The return value is nothing but a outcome of function.
returnstatement ends the function execution.
- For a function, it is not mandatory to return a value.
- If a
returnstatement is used without any expression, then the
returnstatement should be inside of the function block.
def is_even(list1): even_num =  for n in list1: if n % 2 == 0: even_num.append(n) # return a list return even_num # Pass list to the function even_num = is_even([2, 3, 42, 51, 62, 70, 5, 9]) print("Even numbers are:", even_num)
Even numbers are: [2, 42, 62, 70]
Return Multiple Values
You can also return multiple values from a function. Use the return statement by separating each expression by a comma.
In this example, we are returning three values from a function. We will also see how to process or read multiple return values in our code.
def arithmetic(num1, num2): add = num1 + num2 sub = num1 - num2 multiply = num1 * num2 division = num1 / num2 # return four values return add, sub, multiply, division # read four return values in four variables a, b, c, d = arithmetic(10, 2) print("Addition: ", a) print("Subtraction: ", b) print("Multiplication: ", c) print("Division: ", d)
The pass Statement
In Python, the
pass is the keyword, which won’t do anything. Sometimes there is a situation where we need to define a syntactically empty block. We can define that block using the
When the interpreter finds a
pass statement in the program, it returns no operation.
def addition(num1, num2): # Implementation of addition function in comming release # Pass statement pass addition(10, 2)
How does Function work in Python?
In Python, functions allow the programmer to create short and clean code to be reused in an entire program.
The function helps us to organize code. The function accepts parameters as input, processes them, and in the end, returns values as output.
Let’s assume we defined a function that computes some task. When we call that function from another function, the program controller goes to that function, does some computation, and returns some value as output to the caller function.
The following diagram shows how the function works.
Scope and Lifetime of Variables
When we define a function with variables, then those variables’ scope is limited to that function. In Python, the scope of a variable is an area where a variable is declared. It is called the variable’s local scope.
We cannot access the local variables from outside of the function. Because the scope is local, those variables are not visible from the outside of the function.
Note: The inner function does have access to the outer function’s local scope.
When we are executing a function, the life of the variables is up to running time. Once we return from the function, those variables get destroyed. So function does no need to remember the value of a variable from its previous call.
The following code shows the scope of a variable inside a function.
global_lang = 'DataScience' def var_scope_test(): local_lang = 'Python' print(local_lang) var_scope_test() # Output 'Python' # outside of function print(global_lang) # Output 'DataScience' # NameError: name 'local_lang' is not defined print(local_lang)
In the above example, we print the local and global variable values from outside of the function. The global variable is accessible with its name
But when we try to access the local variable with its name
local_lang, we got a NameError, because the local variable is not accessible from outside of the function.
Local Variable in function
A local variable is a variable declared inside the function that is not accessible from outside of the function. The scope of the local variable is limited to that function only where it is declared.
If we try to access the local variable from the outside of the function, we will get the error as NameError.
def function1(): # local variable loc_var = 888 print("Value is :", loc_var) def function2(): print("Value is :", loc_var) function1() function2()
Value is : 888 print("Value is :", loc_var) # gives error, NameError: name 'loc_var' is not defined
Global Variable in function
A Global variable is a variable that declares outside of the function. The scope of a global variable is broad. It is accessible in all functions of the same module.
global_var = 999 def function1(): print("Value in 1nd function :", global_var) def function2(): print("Value in 2nd function :", global_var) function1() function2()
Value in 1nd function : 999 Value in 2nd function : 999
Global Keyword in Function
global is the keyword used to access the actual global variable from outside the function. we use the global keyword for two purposes:
- To declare a global variable inside the function.
- Declaring a variable as global, which makes it available to function to perform the modification.
Let’s see what happens when we don’t use global keyword to access the global variable in the function
# Global variable global_var = 5 def function1(): print("Value in 1st function :", global_var) def function2(): # Modify global variable # function will treat it as a local variable global_var = 555 print("Value in 2nd function :", global_var) def function3(): print("Value in 3rd function :", global_var) function1( function2() function3()
Value in 1st function : 5 Value in 2nd function : 555 Value in 3rd function : 5
As you can see,
global_var as a new variable (local variable). To solve such issues or access/modify global variables inside a function, we use the
# Global variable x = 5 # defining 1st function def function1(): print("Value in 1st function :", x) # defining 2nd function def function2(): # Modify global variable using global keyword global x x = 555 print("Value in 2nd function :", x) # defining 3rd function def function3(): print("Value in 3rd function :", x) function1() function2() function3()
Value in 1st function : 5 Value in 2nd function : 555 Value in 3rd function : 555
Nonlocal Variable in Function
nonlocal is the keyword used to declare a variable that acts as a global variable for a nested function (i.e., function within another function).
We can use a
nonlocal keyword when we want to declare a variable in the local scope but act as a global scope.
def outer_func(): x = 777 def inner_func(): # local variable now acts as global variable nonlocal x x = 700 print("value of x inside inner function is :", x) inner_func() print("value of x inside outer function is :", x) outer_func()
value of x inside inner function is : 700 value of x inside outer function is : 700
Python Function Arguments
The argument is a value, a variable, or an object that we pass to a function or method call. In Python, there are four types of arguments allowed.
- Positional arguments
- keyword arguments
- Default arguments
- Variable-length arguments
Positional arguments are arguments that are pass to function in proper positional order. That is, the 1st positional argument needs to be 1st when the function is called. The 2nd positional argument needs to be 2nd when the function is called, etc. See the following example for more understanding.
def add(a, b): print(a - b) add(50, 10) # Output 40 add(10, 50) # Output -40
If you try to use pass more parameters you will get an error.
def add(a, b): print(a - b) add(105, 561, 4)
TypeError: add() takes 2 positional arguments but 3 were given
In the positional argument number and position of arguments must be matched. If we change the order, then the result may change. Also, If we change the number of arguments, then we will get an error.
A keyword argument is an argument value, passed to function preceded by the variable name and an equals sign.
def message(name, surname): print("Hello", name, surname) message(name="John", surname="Wilson") message(surname="Ault", name="Kelly")
Hello John Wilson Hello Kelly Ault
In keyword arguments order of argument is not matter, but the number of arguments must match. Otherwise, we will get an error.
While using keyword and positional argument simultaneously, we need to pass 1st arguments as positional arguments and then keyword arguments. Otherwise, we will get
SyntaxError. See the following example.
def message(first_nm, last_nm): print("Hello..!", first_nm, last_nm) # correct use message("John", "Wilson") message("John", last_nm="Wilson") # Error # SyntaxError: positional argument follows keyword argument message(first_nm="John", "Wilson")
Default arguments are arguments that take the default value during the function call. If we do not pass any argument to the function, then the default argument will take place. We can assign default values using the
= assignment operator.
# function with default argument def message(name="Guest"): print("Hello", name) # calling function with argument message("John") # calling function without argument message()
Hello John Hello Guest
When we call a function with an argument, it will be considered that value.
Like in the above example, we passed
name="John" we pass to the function, then the function will consider that value. If we do not pass any argument, it will be considered
"name=Guest" as a default value.
In Python, sometimes, there is a situation where we need to pass multiple numbers of arguments to the function. Such types of arguments are called variable-length arguments. We can declare a variable-length argument with the
* (asterisk) symbol.
def fun(*var): function body
We can pass any number of arguments to this function. Internally all these values are represented in the form of a tuple.
def addition(*numbers): total = 0 for no in numbers: total = total + no print("Sum is:", total) # 0 arguments addition() # 5 arguments addition(10, 5, 2, 5, 4) # 3 arguments addition(78, 7, 2.5)
Sum is: 0 Sum is: 26 Sum is: 87.5
A recursive function is a function that calls itself, again and again.
Consider, calculating the factorial of a number is a repetitive activity, in that case, we can call a function again and again, which calculates factorial.
factorial(5) 5*factorial(4) 5*4*factorial(3) 5*4*3*factorial(2) 5*4*3*2*factorial(1) 5*4*3*2*1 = 120
def factorial(no): if no == 0: return 1 else: return no * factorial(no - 1) print("factorial of a number is:", factorial(8))
factorial of a number is: 40320
The advantages of the recursive function are:
- By using recursive, we can reduce the length of the code.
- The readability of code improves due to code reduction.
- Useful for solving a complex problem
The disadvantage of the recursive function:
- The recursive function takes more memory and time for execution.
- Debugging is not easy for the recursive function.
Python Anonymous/Lambda Function
Sometimes we need to declare a function without any name. The nameless property function is called an anonymous function or lambda function.
The reason behind the using anonymous function is for instant use, that is, one-time usage. Normal function is declared using the
def function. Whereas the anonymous function is declared using the
In opposite to a normal function, a Python lambda function is a single expression. But, in a lambda body, we can expand with expressions over multiple lines using parentheses or a multiline string.
When we define a function using the
lambda keyword, the code is very concise so that there is more readability in the code. A lambda function can have any number of arguments but return only one value after expression evaluation.
Let’s see an example to print even numbers without a
lambda function and with a
lambda function. See the difference in line of code as well as readability of code.
Example 1: Program for even numbers without lambda function
def even_numbers(nums): even_list =  for n in nums: if n % 2 == 0: even_list.append(n) return even_list num_list = [10, 5, 12, 78, 6, 1, 7, 9] ans = even_numbers(num_list) print("Even numbers are:", ans)
Even numbers are: [10, 12, 78, 6]
Example 2: Program for even number with a lambda function
l = [10, 5, 12, 78, 6, 1, 7, 9] even_nos = list(filter(lambda x: x % 2 == 0, l)) print("Even numbers are: ", even_nos)
Even numbers are: [10, 12, 78, 6]
We are not required to write explicitly return statements in the
lambda function because the lambda internally returns expression value.
Lambda functions are more useful when we pass a function as an argument to another function. We can also use the lambda function with built-in functions such as
reduce because this function requires another function as an argument.
filter() function in Python
In Python, the
filter() function is used to return the filtered value. We use this function to filter values based on some conditions.
- function – Function argument is responsible for performing condition checking.
- sequence – Sequence argument can be anything like list, tuple, string
lambda function with
l = [-10, 5, 12, -78, 6, -1, -7, 9] positive_nos = list(filter(lambda x: x > 0, l)) print("Positive numbers are: ", positive_nos)
Positive numbers are: [5, 12, 6, 9]
map() function in Python
In Python, the
map() function is used to apply some functionality for every element present in the given sequence and generate a new series with a required modification.
Ex: for every element present in the sequence, perform cube operation and generate a new cube list.
function– function argument responsible for applied on each element of the sequence
sequence– Sequence argument can be anything like list, tuple, string
lambda function with
list1 = [2, 3, 4, 8, 9] list2 = list(map(lambda x: x*x*x, list1)) print("Cube values are:", list2)
Cube values are: [8, 27, 64, 512, 729]
reduce() function in Python
In Python, the
reduce() function is used to minimize sequence elements into a single value by applying the specified condition.
The reduce() function is present in the
functools module; hence, we need to import it using the import statement before using it.
lambda function with
from functools import reduce list1 = [20, 13, 4, 8, 9] add = reduce(lambda x, y: x+y, list1) print("Addition of all list elements is : ", add)>/code>
Addition of all list elements is : 54