New

syllabus
2020-21

Chapter 2
Functions

Computer Science
Class XII ( As per CBSE Board)
Visit : python.mykvs.in for regular updates
 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.

Visit : python.mykvs.in for regular updates

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 : The length of the source program can be
reduced by using/calling functions at appropriate places so program become
more readable.
6.Function facilitates procedural abstraction : Once a function is written,
programmer would have to know to invoke a function only ,not its coding.
7.Functions facilitate the factoring of code : A function can be called in other
function and so on…
Visit : python.mykvs.in for regular updates
 Creating & calling a Function
(user defined)

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 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

Visit : python.mykvs.in for regular updates

 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!
Visit : python.mykvs.in for regular updates
 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)
Visit : python.mykvs.in for regular updates
 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
Visit : python.mykvs.in for regular updates
 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))
Visit : python.mykvs.in for regular updates
 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))
Visit : python.mykvs.in for regular updates
 Function
Parameters / Arguments Passing and return value
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 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.
Visit : python.mykvs.in for regular updates
 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.
Visit : python.mykvs.in for regular updates
 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
Visit : python.mykvs.in for regular updates
 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

Visit : python.mykvs.in for regular updates

 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
Visit : python.mykvs.in for regular updates
 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 and #In above function value of variable b is not
its contents are changing because it is mutable that’s being changed because it is immutable that’s
why it is behaving like pass by reference why it is behaving like pass by value
Visit : python.mykvs.in for regular updates
 Pass arrays/list to function

Arrays are popular in most programming languages like: Java,

C/C++, JavaScript and so on. However, in Python, they are not that
common. When people talk about Python arrays, more often than
not, they are talking about Python lists. Array of numeric values are
supported in Python by the array module.
e.g. OUTPUT:
def dosomething( thelist ): 1
for element in thelist: 2
3
print (element) red
green
dosomething( ['1','2','3'] ) Blue
Note:- List is mutable datatype that’s why it treat
alist = ['red','green','blue'] as pass by reference.It is already explained in topic
dosomething( alist ) Mutable/immutable properties of data objects
w/r function
Visit : python.mykvs.in for regular updates
 Pass String to a function

String can be passed in a function as argument but it is used as

pass by value.It can be depicted from below program. As it will
not change value of actual argument.
e.g.
def welcome(title):
title="hello"+title

r="Mohan"
welcome(r) OUTPUT
print(r) Mohan

Visit : python.mykvs.in for regular updates

 Pass tuple to a function
in function call, we have to explicitly define/pass the tuple.It is not
required to specify the data type as tuple in formal argument.
E.g.
def Max(myTuple):
first, second = myTuple
if first>second:
return first
else:
return second

r=(3, 1) OUTPUT
m=Max(r) 3
print(m)
Visit : python.mykvs.in for regular updates
 Pass dictionary to a function

In Python, everything is an object, so the dictionary can

be passed as an argument to a function like other
variables are passed.
def func(d):
for key in d:
print("key:", key, "Value:", d[key])

# Driver's code OUTPUT

Mydict = {'a':1, 'b':2, 'c':3} key: a Value: 1
func(Mydict) key: b Value: 2
key: c Value: 3

Visit : python.mykvs.in for regular updates

 Functions using libraries
Mathematical functions:
Mathematical functions are available under math module.To use
mathematical functions under this module, we have to import the
module using import math.
For e.g.
To use sqrt() function we have to write statements like given
below.
import math
r=math.sqrt(4)
print(r)

OUTPUT :
2.0
Visit : python.mykvs.in for regular updates
 Functions using libraries
Functions available in Python Math Module

Visit : python.mykvs.in for regular updates

 Functions using libraries
(System defined function)
String functions:
String functions are available in python standard module.These are
always availble to use.

For e.g. capitalize() function Converts the first character of string to

upper case.

s="i love programming"

r=s.capitalize()
print(r)

OUTPUT:
I love programming
Visit : python.mykvs.in for regular updates
 Functions using libraries
String functions:
Method Description
capitalize() Converts the first character to upper case
casefold() Converts string into lower case
center() Returns a centered string

count() Returns the number of times a specified value occurs in a string

encode() Returns an encoded version of the string

endswith() Returns true if the string ends with the specified value
Searches the string for a specified value and returns the position of
find()
where it was found
format() Formats specified values in a string
Searches the string for a specified value and returns the position of
index()
where it was found
Visit : python.mykvs.in for regular updates
 Functions using libraries
String functions:
Method Description
isalnum() Returns True if all characters in the string are alphanumeric
isalpha() Returns True if all characters in the string are in the alphabet
isdecimal() Returns True if all characters in the string are decimals
isdigit() Returns True if all characters in the string are digits
isidentifier() Returns True if the string is an identifier
islower() Returns True if all characters in the string are lower case
isnumeric() Returns True if all characters in the string are numeric
isprintable() Returns True if all characters in the string are printable
isspace() Returns True if all characters in the string are whitespaces
istitle() Returns True if the string follows the rules of a title
isupper() Returns True if all characters in the string are upper case
join() Joins the elements of an iterable to the end of the string
ljust() Returns a left justified version of the string
lower() Converts a string into lower case
lstrip() Returns a left trim version of the string
partition() Returns a tuple where the string is parted into three parts
Visit : python.mykvs.in for regular updates
 Functions using libraries
String functions:
Method Description
Returns a string where a specified value is replaced with a specified
replace()
value
split() Splits the string at the specified separator, and returns a list
splitlines() Splits the string at line breaks and returns a list
startswith() Returns true if the string starts with the specified value
swapcase() Swaps cases, lower case becomes upper case and vice versa
title() Converts the first character of each word to upper case
translate() Returns a translated string
upper() Converts a string into upper case

zfill() Fills the string with a specified number of 0 values at the beginning

Visit : python.mykvs.in for regular updates