python Concept of Functions with Examples in hindi 

Advantages of Using Function

  • Ease of Use: This allows ease in debugging the code and prone to less error.
  • Reusability: It allows the user to reuse the functionality with a different interface without typing the whole program again.
  • Ease of Maintenance: It helps in less collision at the time of working on modules, helping a team to work with proper collaboration while working on a large application.

What is Function?

A function can be defined as the organized block of reusable code which can be called whenever required. A function is a block of code which only runs when it is called. Basically two  types of function.

1-SDF-System Defined Function

2-UDF-User Defined Function.

  • Python allows us to divide a large program into the basic building blocks known as function.
  • A function can be called multiple times to provide reusability and modularity to the python program.
  • The idea is to put some commonly or repeatedly done task together and make a function.

Function can be categorized in to:

  • Non-Parameterized Function
  • Parameterized Function

Function Definition

In python, we can use def keyword to define the function.


  def function_name(parameter_list): 


return <expression>  

  • The function block is started with the colon (:)
  • All the same level block statements remain at the same indentation.
  • A function can accept any number of parameters that must be the same in the definition and function calling.

Function Calling

In python, a function must be defined before the function calling otherwise the python interpreter gives an error.

Once the function is defined, we can call it from another function or the python prompt.

To call the function, use the function name followed by the parentheses.

def hello_world():

#function declaration

print(“This is first statement”)

   #function definition

print(“This is second statement”)


 Non-Parameterized Function

The non-parameterized function does not require any variable name in their declaration and calling.


def area_circle():

r=float(input(“Enter Radius of Circle:”))


print(“Area of circle:”,a)

area_circle()  #function calling

Parameterized Function

The parameterized function require variable name in their declaration and calling.

Function parameters

The information into the functions can be passed as the parameters. The parameters are specified in the parentheses.

A function may have any number of parameters.

Multiple parameters are separated with a comma

Example 1:

def area_circle(r):


print(“Area of circle:”,a)

radius=float(input(“Enter Radius:”))


  • Here, the function named area_circle() is declared with empty().
  • This means, the function called with empty() i.e. calling does not requires any parameter.

Example 2: Python function to calculate area of rectangle using parameterized function

def area_rect(l,b):  #parameterized function


  print(“Area of Rectangle:”,area_lb)

len=float(input(“Enter Length of rectangle:”))

brth=float(input(“Enter Breadth of rectangle:”))

area_rect(len, brth)


Enter Length of rectangle:30

Enter Breadth of rectangle:20

Area of Rectangle: 600.0

Return Statement

A function may return a value using return keyword. When a function produces a result, there are two possibilities:

a) The value of output is preserved within the function. As in above example.

b) Transfer the value of output to calling function.

  i)  Return statement is used in this scenario.

  ii)  A return statement is used to end the execution of the   function call and “returns” the result (value of the expression   following the return keyword) to the caller.

c. The statements after the return statements are not executed.

d. If the return statement is without any expression, then the special value None is returned.

Example 1:

def si_int(p,r,t): 


  return si  #returning the value of si to the calling function    


print(“Simple Interest=”,s)

  • In above example, the function si_int() will calculate the simple interest in variable named si and returns the value of si to the function calling.
  • At function calling, the returned value is stored in variable named s.
  • Now, we can use the value of s as per requirement. In above example, the value of s gets printed using print statement.

Example 2:

def area_rect(l,b): #parameterized function


  return area_lb  #returning the value of area_lb to calling function

len=float(input(“Enter Length of rectangle:”))

brth=float(input(“Enter Breadth of rectangle:”))

# Ar will store the value of area_lb, which is returned by the function

Ar=area_rect(len, brth)


Enter Length of rectangle:20

Enter Breadth of rectangle:10

Area of Rectangle: 200.0

Types of Parameter

There may be several types of arguments which can be passed at the time of function calling.

  • Required arguments
  • Keyword arguments
  • Default arguments
  • Variable-length arguments

Required Arguments

The required arguments are required to be passed at the time of function calling with the exact match of their positions in the function call and function definition. If either of the arguments is not provided in the function call, or the position of the arguments is changed, then the python interpreter will show the error.

Example 1:

def calculate(a,b):

     return a+b 

sum1=calculate(10) # this causes an error as we are missing a required arguments b.


Output: calculate() missing 1 required positional argument: ‘b’

Example 2:

def calculate(a,b):

     return a+b 



Output: Sum=20 

Keyword Arguments

Python allows us to call the function with the keyword arguments. This kind of function call will enable us to pass the arguments in the random order.


#The function simple_interest(p, t, r) is called with the keyword arguments the order of arguments doesn’t matter in this case 

def simple_interest(p,t,r): 

return (p*t*r)/100 

print(“Simple Interest: “,simple_interest(t=10,r=10,p=1900))

Output: Simple Interest:  1900.0

Note: In this case the name of argument is same in calling and definition.

Example 2:

#The function simple_interest(p, t, r) is called with the keyword arguments the order of arguments doesn’t matter in this case 

def simple_interest(p,t,r): 

return (p*t*r)/100

x=float(input(“Enter Amount”))

y=float(input(“Enter Time”))

z=float(input(“Enter Rate”))

print(“Simple Interest: “,simple_interest(t=y,r=z,p=x))


Enter Amount12000

Enter Time5

Enter Rate5

Simple Interest:  3000.0

  • If we provide the different name of arguments at the time of function call, an error will be thrown.

  simple_interest(20000,rate=7.5, time=6)  #error

  • The python allows us to provide the mix of the required arguments and keyword arguments at the time of function call.   simple_interest(20000,t=5,r=6.5)
  • The required argument must not be given after the keyword argument.

  simple_interest(20000,r=7.5,6)   #error

Default Arguments

Python allows us to initialize the arguments at the function definition. If the value of any of the argument is not provided at the time of function call, then the default value for the argument will be used.

Example 1:

def printme(name,age=22): 


printme(“Ravi”)   # name=Ravi age=22 (default value)

printme(“Sachin”, 33)  #name =Sachin age=33


Name: Ravi

Age: 22

Name: Sachin

Age: 33

Variable Length Arguments

Variable length argument is a feature that allows a function to receive any number of arguments. However, at the function definition, we have to define the variable with * (star) as *<variable – name >.

Example 1:

def printme(*names): 

print(“type of passed argument is “,type(names)) 

print(“printing the passed arguments…”) 

for name in names: 


#calling printme function



type of passed argument is  <class ‘tuple’>

printing the passed arguments…





Example 2:

def adder(*num):

sum = 0

for n in num:

     sum = sum + n


adder(3,5)                 #calling adder with 2 argument

adder(4,5,6,7)              #calling adder with 4 argument

adder(1,2,3,5,6)       #calling adder with 5 argument


Sum: 8

Sum: 22

Sum: 17

Local Variable

  • A local variable is a type of variable declared within programming block or function.
  • It can only be used only inside that function or code block in which they were declared.
  • The local variable exists until the block of the function is in under execution. After that, it will be destroyed automatically.

Example 1:

def func():


print(“Value of a in function:”,a)


print(“Value of ‘a’ outside function:”,a)

Output: name ‘a’ is not defined

In  example1, it is clearly shown that the value of variable ‘a’ is only accessible inside the function func(). The value variable ‘a’ cannot be accessible outside the function because variable ‘a’ is a local variable of the function func(). It can only be accessible inside the function func().

Global Variable

  • Global variables are defined outside of a subroutine or function.
  • The global variable will hold its value throughout the lifetime of a program.
  • They can be accessed within any function defined for the program.

Example 1:


def func():

print(“Value of a in function:”,a)


print(“Value of ‘a’ outside function:”,a)


Value of a in function: 10

Value of ‘a’ outside function: 10

Here, variable ‘a’ is defined outside the function func(). The variable ‘a’ will now become a global variable. It can be accessed inside any function as well as outside the function.

Global Keyword

So far, we haven’t had any kind of a problem with global scope. So let’s take an .

Example 1:

i=10  #global variable

def counter():

i=20 #local variable of function counter

print(“Value of i in function:”,i)           


print(“Value of i Outside Function:”,i)


Value of i in function: 20

Value of i Outside Function: 10

Now, when we make a reference to ‘i’ outside this function, we get 10 instead of 20.

Global keyword is a keyword that allows a user to modify a variable outside of the current scope.

  • It is used to create global variables from a non-global scope i.e. inside a function.
  • Global keyword is used inside a function only when we want to do assignments or when we want to change a variable.
  • Global is not needed for printing and accessing.

Rules of Global Keywords

If a variable is assigned a value anywhere within the function’s body, it’s assumed to be a local unless explicitly declared as global.

  • Variables that are only referenced inside a function are implicitly global.
  • We Use global keyword to use a global variable inside a function.
  • There is no need to use global keyword outside a function.

Use of Global Keywords

To access a global variable inside a function there is no need to use global keyword.

Example 1:

# global variable

a = 15

b = 10

 # function to perform addition

def add():

c = a + b


# calling a function


Output: 25

If we need to assign a new value to a global variable then we can do that by declaring the variable as global.

Code: Without global keyword

a = 15

  # function to change a global value

def change():

   # increment value of a by 5

a = a + 5



If we need to assign a new value to a global variable then we can do that by declaring the variable as global.

Code : Without global keyword

a = 15

  # function to change a global value

def change():

  a = a + 5  # increment value of a by 5



Output: UnboundLocalError: local variable ‘a’ referenced before assignment

This output is an error because we are trying to assign a value to a variable in an outer scope. This can be done with the use of global variable.

Code : With global keyword

# Python program to modify a global

# value inside a function

x = 15

def change():    

global x  # using a global keyword      

x = x + 5 # increment value of a by 5 

print(“Value of x inside a function :”, x)


print(“Value of x outside a function :”, x)


Value of x inside a function : 20

Value of x outside a function : 20

Python docstrings

Python documentation strings (or docstrings) provide a convenient way of associating documentation with Python modules, functions, classes, and methods.

General Rules:

  • The doc string line should begin with a capital letter and end with a period.
  • The first line should be a short description.
  • If there are more lines in the documentation string, the second line should be blank, visually separating the summary from the rest of the description.
  • The following lines should be one or more paragraphs describing the object’s calling conventions, its side effects, etc.

Declaring Docstrings: The docstrings are declared using “””triple double quotes””” just below the class, method or function declaration. All functions should have a docstring.

Accessing Docstrings: The docstrings can be accessed

  • using the __doc__ method of the object or
  • using the help function.


def my_function():

“””Demonstrate docstrings and does nothing really.”””

return None

print(“Printing DocString Using __doc__:”)

print(my_function.__doc__ )

print(“Printing DocString Using help function:”)



Printing DocString Using __doc__:

Demonstrate docstrings and does nothing really.

Printing DocString Using help function:

Help on function my_function in module __main__:


     Demonstrate docstrings and does nothing really.

Leave a Reply

Your email address will not be published.