Chapter 2 :

Computer Science
Class XII ( As per CBSE Board)
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 in to 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 canuse
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
5.Increases program readability: It makes
possible top down modular programming. In
this style of programming , the high level logic
of the over all 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():
print("Hello from a function")
#program start here. Program code
print("hello before calling a function")
my_own_function() #function calling. nowfunction 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
non local keyword.

Local variable program:

deffun():
s = "I love India!" #local variable
print(s)
s = "I love World!"
fun()
print(s)
Output:
I love India!
I love World!
Global variable program:
Def fun():
global s #accessing/making global variable for
fun()
print(s)
s = "I love India!“ #changing global variable’s
value
print(s)
s = "I love world!"
fun()
print(s)
Output:
I love world!
I love India!
I love India!
Variable’s Scope in function
#Find the output of below program
Deffun (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) #passingvalue50 and 100 in
parameter x and y of function fun()
print(a, b, x, y)
Variable’s Scope in function
#Findtheoutput of belowprogram
deffun(x, y): # argument / parameterx 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) #passingvalue50 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
Visit : python.mykvs.in for regular updates
Global variables in nested function
deffun1():
x = 100
deffun2():
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
Visit : python.mykvs.in for regular updates
Non local variable
deffun1():
x = 100
deffun2():
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
defsquare(x):
z=x*x
return z
r=square()
print(r)
#In above function square() we have to definitely need to pass some value to
argument x. #Keyword arguments
deffun( name, age ):
"This prints a passed info into this function"
print ("Name: ", name)
print ("Age ", age)
return;
# Now you can call printinfofunction
fun( age=15, name="mohak" )
# value 15 and mohak is being passed to relevant argument based on keyword used
for them.
Function
#Default arguments
def sum(x=3,y=4):
z=x+y
return z
r=sum()
print(r)
r=sum(x=4)
print(r)
r=sum(y=45)
print(r)
#default value of x and yis being used when it is not passed
#Variable length arguments
defsum( *vartuple):
s=0
for varin vartuple:
s=s+int(var)
return s;
r=sum( 70, 60, 50 )
print(r)
r=sum(4,5)
print(r)
#now the above function sum() cansum n number of values
Lamda
PythonLambda
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
Mutable/immutable properties of data
objects w/r function
Visit : python.mykvs.in for regular updates
Every thing in Python is an object,and every
objects in Python can be either
Mutable or immutable.
Since every thing 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 run time and once set can never change, how
ever its state can be change difit is mutable.
Means a mutable object can be changed after
it is created, and an immutable object can’t.
Mutable objects: list,dict,set,bytearray
Immutable objects:
Mutable/immutable properties of data objects w/r function
Visit : python.mykvs.in for regular updates
How objects are passed to Functions #Pass by reference
Def update List(list1):
print(id(list1))
list1 += [10]
print(id(list1))
n = [50, 60]
print(id(n))
Update List(n)
print(n)
print(id(n))
OUTPUT
34122928
34122928
34122928
[50, 60, 10]
34122928
#In above function list1an object is being passed and its contents
are changing because it is mutable that’s why it is behaving like
pass by reference
#Pass by value
Def update Number(n):
print(id(n))
n += 10
print(id(n))
b=5
print(id(b))
Update Number(b)
print(b)
print(id(b))
OUTPUT
1691040064
1691040064
1691040224
5
1691040064
#In above function value of variable b is not being changed
because it is immutable that’s why it is behaving like pass by value
Pass arrays to functions
Arrays are popular in most programming languages like:Java,C/C+
+,JavaScriptand soon. 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.
Def do some thing(thelist):
Fore lemen tin thelist:
print(element)
Do something(['1','2','3'])
alist=['red','green','blue']
Do something(alist)
OUTPUT:
1
2
3
red
green
Blue
Note:-List is mutable data type that’s why it treat as pass by
reference. It is already explained into pic Mutable/immutable
properties of data bjects w/r function
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
Functions using libraries
Functions available in Python Math
Module
Functions using libraries(System defined
function)
Visit : python.mykvs.in for regular updates
String functions:
String functions are available in python
standard module. These are always available
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
 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
find() Searches the string for a specified value and returns
the position of where it was found
format() Formats specified values in a string
index() Searches the string for a specified value and
returns the position of where it was found
 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
 Functions using libraries

String functions:
Method Description
replace() Returns a string where a specified value is replaced
with a specified 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