Chapter 2 :

Computer Science

Functions
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(),etc.But we can also create
our own functions. These functions are
called user-defined functions.
Advantages of Using functions:
1.Program development made easy and fast : Work can be divided among
project members thus implementation can be completed fast.
2.Program testing becomes easy : Easy to locate and isolate a faulty function
for further investigation
3.Code 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.
4.Code 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.
5.Increases program readability : It makes possible top down modular
programming. In this style of programming, the high level logic of the overall
problem is solved first while the details of each lower level functions is addressed
later. The length of the source program can be reduced by using functions at
appropriate places.
6.Function facilitates procedural abstraction : Once a function is written,
it serves as a black box. All that a programmer would have to know to invoke a
function would be to know its name, and the parameters that it expects
7.Functions facilitate the factoring of code : A function can be called in
other function and so on…
 Creating & calling a Function(user defined)

A function is defined using the def keyword in

python.E.g. program is given below.

def my_own_function():
#Function block/
print("Hello from a function") definition/creation

#program start here.program code

print("hello before calling a function")
my_own_function() #function calling.now 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()
print(s) s = "I love world!"
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()
print("After calling fun2: " + str(x))

fun1()
print("x in main: " + str(x))

OUTPUT:
Before calling fun2: 100
Calling fun2 now:
After calling fun2: 100
x in main: 200
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()
print("After calling fun2: " + str(x))

x=50
fun1()
print("x in main: " + str(x))

OUTPUT:
Before calling fun2: 100
Calling fun2 now:
After calling fun2: 200
x in main: 50
Function
Parameters / Arguments
These are specified after the function name, inside the parentheses. Multiple
parameters are separated by comma.The 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 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 - arguments passed to a function 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)
# Now you can call printinfo function
#In above function square() we have to fun( age=15, name="mohak" )
definitely need to pass some value to # value 15 and mohak is being passed
argument x. to relevant argument based on keyword
used for them.
 Function
#Default arguments #Variable length arguments
def sum(x=3,y=4): def sum( *vartuple ):
z=x+y s=0
return z for var in vartuple:
s=s+int(var)
r=sum() return s;
print(r)
r=sum(x=4) r=sum( 70, 60, 50 )
print(r) print(r)
r=sum(y=45) r=sum(4,5)
print(r) print(r)

#default value of x and y is being used #now the above function sum() can sum
when it is not passed n number of values
Mutable/immutable properties of data objects w/r function

Everything in Python is an object,and every objects in Python can be

either mutable or immutable.
Since everything in Python is an Object, every variable holds an object
instance. When an object is initiated, it is assigned a unique object id. Its
type is defined at runtime and once set can never change, however its
state can be changed if it is mutable.
Means a mutable object can be changed after it is created, and
an immutable object can’t.

Mutable objects: list, dict, set, byte array

Immutable objects: int, float, complex, string, tuple, frozen set ,bytes
Mutable/immutable properties of data objects w/r function
How objects are passed to Functions
#Pass by reference #Pass by value
def updateList(list1): def updateNumber(n):
print(id(list1)) print(id(n))
list1 += [10] n += 10
print(id(list1)) print(id(n))
n = [50, 60] b=5
print(id(n)) print(id(b))
updateList(n) updateNumber(b)
print(n) print(b)
print(id(n)) print(id(b))
OUTPUT OUTPUT
34122928 1691040064
34122928 1691040064
34122928 1691040224
[50, 60, 10] 5
34122928 1691040064
#In above function list1 an object is being passed #In above function value of variable b is not
and its contents are changing because it is mutable being changed because it is immutable that’s
that’s why it is behaving like pass by reference why it is behaving like pass by value