Function Introduction
A function is a programming block of codes which is
used to perform a single, related task. It only runs
when it is called. We can pass data, known as
parameters, into a function. A function can return data
as a result.
We have already used some python built in functions
like print(),[Link] we can also create our own
functions. These functions are called user-defined
functions.
Advantages of Using functions:
[Link] development made easy and fast : Work can be divided among project
members thus implementation can be completed fast.
[Link] testing becomes easy : Easy to locate and isolate a faulty function for
further investigation
[Link] sharing becomes possible : A function may be used later by many other
programs this means that a python programmer can use function written by
others, instead of starting over from scratch.
[Link] re-usability increases : A function can be used to keep away from rewriting
the same block of codes which we are going use two or more locations in a
program. This is especially useful if the code involved is long or complicated.
[Link] program readability : The length of the source program can be
reduced by using/calling functions at appropriate places so program become
more readable.
[Link] facilitates procedural abstraction : Once a function is written,
programmer would have to know to invoke a function only ,not its coding.
[Link] facilitate the factoring of code : A function can be called in other
function and so on…
Creating & calling a Function
(user defined)/Flow of execution
A function is defined using the def keyword in python.E.g.
program is given below.
#Function block/
def my_own_function(): definition/creation
print("Hello from a function")
#program start [Link] code
print("hello before calling a function")
my_own_function() #function [Link] function codes will be executed
print("hello after calling a function")
Save the above source code in python file and execute it
Variable’s Scope in function
There are three types of variables with the view of scope.
1. Local variable – accessible only inside the functional block where it is declared.
2. Global variable – variable which is accessible among whole program using global
keyword.
3. Non local variable – accessible in nesting of functions,using nonlocal keyword.
Local variable program: Global variable program:
def fun(): def fun():
s = "I love India!" #local variable global s #accessing/making global variable for fun()
print(s) print(s)
s = "I love India!“ #changing global variable’s value
s = "I love World!" print(s)
fun() s = "I love world!"
print(s) fun()
Output: print(s)
I love India! Output:
I love World! I love world!
I love India!
I love India!
Variable’s Scope in function
#Find the output of below program
def fun(x, y): # argument /parameter x and y
global a
a = 10
x,y = y,x
b = 20
b = 30
c = 30
print(a,b,x,y)
a, b, x, y = 1, 2, 3,4
fun(50, 100) #passing value 50 and 100 in parameter x and y of
function fun()
print(a, b, x, y)
Variable’s Scope in function
#Find the output of below program
def fun(x, y): # argument /parameter x and y
global a
a = 10
x,y = y,x
b = 20
b = 30
c = 30
print(a,b,x,y)
a, b, x, y = 1, 2, 3,4
fun(50, 100) #passing value 50 and 100 in parameter x and y of function fun()
print(a, b, x, y)
OUTPUT :-
10 30 100 50
10 2 3 4
Variable’s Scope in function
Global variables in nested function
def fun1():
x = 100
def fun2():
global x
x = 200
print("Before calling fun2: " + str(x))
print("Calling fun2 now:")
fun2() OUTPUT:
print("After calling fun2: " + str(x)) Before calling fun2: 100
Calling fun2 now:
fun1() After calling fun2: 100
x in main: 200
print("x in main: " + str(x))
Variable’s Scope in function
Non local variable
def fun1():
x = 100
def fun2():
nonlocal x #change it to global or remove this declaration
x = 200
print("Before calling fun2: " + str(x))
print("Calling fun2 now:")
fun2() OUTPUT:
print("After calling fun2: " + str(x)) Before calling fun2: 100
Calling fun2 now:
x=50 After calling fun2: 200
fun1() x in main: 50
print("x in main: " + str(x))
Function
Parameters / Arguments Passing and return value
These are specified after the function name, inside the parentheses. Multiple
parameters are separated by [Link] following example has a function with
two parameters x and y. When the function is called, we pass two values, which
is used inside the function to sum up the values and store in z and then return
the result(z):
def sum(x,y): #x, y are formal arguments
z=x+y
return z #return the value/result
x,y=4,5
r=sum(x,y) #x, y are actual arguments
print(r)
Note :- 1. Function Prototype is declaration of function with name ,argument
and return type. 2. A formal parameter, i.e. a parameter, is in the function
definition. An actual parameter, i.e. an argument, is in a function call.
Function
Function Arguments
Functions can be called using following types of formal arguments −
• Required arguments/Positional parameter - arguments passed in correct positional order
• Keyword arguments - the caller identifies the arguments by the parameter name
• Default arguments - that assumes a default value if a value is not provided to argu.
• Variable-length arguments – pass multiple values with single argument name.
#Required arguments #Keyword arguments
def fun( name, age ):
def square(x): "This prints a passed info into this
z=x*x function"
return z print ("Name: ", name)
print ("Age ", age)
r=square() return;
print(r)
#In above function square() we have to # Now you can call printinfo function
definitely need to pass some value to fun( age=15, name="mohak" )
argument x. # value 15 and mohak is being passed to
relevant argument based on keyword
used for them.
Function
#Default arguments / #Variable length arguments
def sum( *vartuple ):
#Default Parameter s=0
def sum(x=3,y=4): for var in vartuple:
z=x+y s=s+int(var)
return z return s;
r=sum() r=sum( 70, 60, 50 )
print(r) print(r)
r=sum(x=4) r=sum(4,5)
print(r) print(r)
r=sum(y=45)
print(r)
#now the above function sum() can
#default value of x and y is being used sum n number of values
when it is not passed
Lamda
Python Lambda
A lambda function is a small anonymous function which can take
any number of arguments, but can only have one expression.
E.g.
x = lambda a, b : a * b
print(x(5, 6))
OUTPUT:
30