Function
• Functions
• A function is a block of code that performs a specific task. Dividing a
complex problem into smaller chunks makes our program easy to
understand and reuse.
• A function runs only when it is called.
• They are defined using the def keyword
• They can be called multiple times.
• Types of function(2 types)
• Standard library functions - These are built-in functions in Python
that are available to use.
• User-defined functions - We can create our own functions based on
our requirements.
• Function Declaration
• syntax
– def function_name(arguments):
– # function body
– return
• def add(x,y):
• z=x+y
• return z
• a=10
• b=20
• add(a,b)
• #print(result)
• #print ("a = {} b = {} a+b = {}".format(a, b,
result))
• # via input box
• def add():
• n=int(input("Enter the FNo"))
• b=int(input("Enter the SNo"))
• print(n+b)
• add()
• Arguments : An argument is a value that is
accepted by a function.
Information can be passed into functions
as arguments . Arguments are specified after
the function name, inside the parentheses.
You can add as many arguments as you want.
4 types of arguments that can provide in a
function :
1. Default Arguments
2. Keyword Arguments
3. Variable length Arguments
4. Required Arguments or positional
• #passing argument / parameter
• def add(y):
– X=10
– C=x+y
• print(c)
• add(50)
• #no argument but use return
• def add():
• n=int(input("Enter the FNo"))
• b=int(input("Enter the SNo"))
• return(n+b)
• x=add()
• print(x)
• # find the square of n numbers
• def get_square(num):
• return num * num
• for i in [1,2,3,4,7,9]:
• # function call
• result = get_square(i)
• print('Square of',i, '=',result)
• # argument and return
• def add(x,y):
• return(x+y)
• z=add(10,20)
• print(z)
• Note :
– A parameter is the variable listed inside the
parentheses in the function definition.
– An argument is the value that is sent to the
function when it is called.
• #factorial of any number
• def fact(x):
• i=1
• f=1
• while x>=i:
• f=f*i
• i=i+1
• print(f)
• fact(5)
Types of Actual Arguments
• 4 types :
– Positional Arguments
– Keyword Arguments
– Default Arguments
– Variable Length Arguments
• Positional Arguments
– These arguments are passed to the function in correct
positional order.
– The number of arguments and their positions in the
function definition should be equal to the number and
position of the argument in the function call.
• # Positional Arguments or actual arguments
• def pw(x,y):
• z=x**y
• print(z)
• pw(5,3)
• Default Argument :
– Default values indicate that the function argument will take
that value if no argument value is passed during function
call. The default value is assigned by using assignment (=)
operator.
• Eg :
– def defa(name,location="Janakpuri"):
– print(f"name:{name} location: {location}")
– defa("MSI")
• Variable Length Arguments, *args
– Variable length argument is an argument that can accept any number of
values. The variable length argument is written with * symbol.
– It stores all value in a tuple.
• Eg :the user doesn’t know in advance how many no of arguments
will pass, them the *args will help it.
– Def calcval(*args):
– # Print(args)
– totalval=sum(args)
– return(totalval)
– ## call the fun
– Calcval(10,30,40,80,90,100,45)
• Eg : # using slicing
– def fun(*kids):
– print("The youngest child is ", kids[1:3])
– fun("hello","I","love","Python")
• Eg : # show only index value
– def fun(*kids):
– print("The programming is ", kids[3])
– fun("hello","I","love","Python")
• Eg :
– # show all values
– def fun(*kids):
– print("The programming is ", kids)
– fun("hello","I","love","Python")
Keyword Argument
• These arguments are passed to the function
with “name-value pair”. the keyword
arguments name and formal arguments name
must match.
• Note : number of argument must be equal in
formal and actual argument, not more not
less.
• Eg :
– def show(name,age):
– # print(name,age)
– print(f"Name:{name} Age:{age}")
– show(name="Sam Uncle",age=23)
• Keyword Variable Length Arguments
(**kwargs) :
– Is an argument that can accept any number of
values in form of “KEY-VALUE” pair.
– The keyword variable length argument is written
with ** symbol.
– It stores all the value in a dictionary in the form of
key-value pair.
• def add(**num):
• z=num['a']+num['b']+num['c']
• print("Addition is : ",z)
• add(a=10,b=20,c=30)
• Eg :
– # pass any variable
– def add(x,**num):
– z=x+num['a']+num['b']
– print("Addition is : ",z)
– add(40,a=10,b=20)
• map()
– The map() function applies a given function to
each element of an iterable (list, tuple etc.) and
returns an iterator containing the results.
– Syntax :
• Map(function,iterable,….)
• map() Return Value
– The map() function returns an object of map class.
The returned value can be passed to functions like
– list() - to convert to list
– set() - to convert to a set, and so on.
• def make_even(num):
• if num%2==0:
• return num+1
• else:
• return num
•
•
• x=[551,663,523,842,954,781,630,546]
• y=list(map(make_even,x))
• print(y)
• Eg :
– def calculateSquare(n):
– return n*n
– numbers = (1, 2, 3, 4)
– result = map(calculateSquare, numbers)
– print(result)
– # converting map object to set
– numbersSquare = set(result)
– print(numbersSquare)
Recursion
• A function calling itself again and again to compute a value is referred to
recursive or recursion.
• eg :
– # a Recursive function can call itself only 1000 times in IDLE in python, but in
jupyter its limit is 3000
– def myfun():
– print("Recursion")
– myfun()
– myfun()
• ### to check the Limit
• import sys
• print(sys.getrecursionlimit())
• # ### to set the Limit
• import sys
• sys.setrecursionlimit(500)
• print(sys.getrecursionlimit())
• #to print fibonacci series
• n=int(input("enter Number"))
• x=0
• y=1
• z=0
• while(z<=n):
• print(z)
• x=y
• y=z
• z=x+y
• Eg : through Recursion
– def fibo(i):
– if i<=1:
– return i
– else:
– return fibo(i-1)+fibo(1-2)
–
– #main code
– for i in range(10):
– print(fibo(i),end=',')
• # factorial of no
• def fact(num):
• if num==1:
• return num
• return num*fact(num-1)
• number=int(input("Enter a number : "))
• result=fact(number)
• print("factorail of ",number," is ",result)
• #program to find of a list of numbers using recursion
• def sum_list(nums):
• if len(nums)==0:
• return 0
• return nums[0]+sum_list(nums[1:])
• numbers=[]
• n=int(input("Enter how many number are there in a list : "))
• for a in range(n):
• num=int(input("Enter a number : "))
• numbers.append(num)
• print("List is ",numbers)
• print("sum of list is ",sum_list(numbers))
Pass by value / Call by Reference
• In python neither of these two concepts is
applicable rather the values are sent to
functions by means of object reference.
• When we pass value like number, strings,
tuples or list to function the reference of these
objects are passed to function.
