Unit - 2

FUNCTIONS, EXCEPTION,
MODULES AND FILES
PYTHON FUNCTIONS
 PYTHON FUNCTIONS
 A Function is a self block of code which is used to
organize the functional code.
 Function can be called as a section of a program that
is written once and can be executed whenever
required in the program, thus making code reusability.
 Types of Functions: There are two types of Functions.
 a) Built-in Functions: Functions that are predefined
and organized into a library.
 b) User- Defined: Functions that are created by the
programmer to meet the requirements.
 DIFFERENCE BETWEEN A FUNCTION AND A METHOD
FUNCTION METHOD
1. A Function can be 1. When a Function is
written individually in written inside a class, it
a python program. becomes a‘method’.
2. A Function is called 2. A method can be
using its name. called by object name
3. Example: display() or class name.
3. Example:
Object.methodname()
Class.methodname()
 DEFINING FUNCTIONS
 A Function defined in Python should follow the
format:
1) Keyword def is used to start and declare a function.
2) def is followed by function-name followed by
parenthesis.
3) Parameters are passed inside the parenthesis. At the
end a colon is marked.
4) Python code requires indentation (space) of code to
keep it associate to the declared block.
5) The first statement of the function is optional. It is
 DEFINING FUNCTIONS

 Example: def sum(a,b):

 CALLING FUNCTIONS
 To execute a function it needs to be called. This is
called function calling.
 Syntax: <function_name>(parameters)
 Example : sum(a,b)

 Python Function Example:

def sum(x,y):
s=x+y
print "Sum of two numbers is“, s
#Calling the sum Function
sum(10,20)
RETURNING RESULT FROM FUNCTION
 We can return the result or output from the
function using a ‘return’ statement in the body of
the function.
 Syntax: return object

 Python Example:

def sum(x,y):
s=x+y
return s
#Calling the sum Function
add=sum(10,20)
print “Sum of x and y =“,add
 RETURNING MULTIPLE VALUES FROM
FUNCTION
 A function returns a single values in programming languages
like C or Java.
 But in Python, a function can return multiple values.

 Example: return a,b,c

 Python Example:

def sum_sub(x,y):
c=x+y
d=x-y

return c,d
#Calling the sum Function
a,b=sum(10,20)
print “Sum of x and y =“,a
FUNCTIONS ARE FIRST CLASS OBJECTS
 In Python, functions are considered as first class
objects. It means we can use functions as prefect objects.
 In fact, when we create a function, the Python
interpreter internally creates a object.
 We can pass a function to another function just like we
pass an object(or value) to a function.
 Also it is possible to return a function from another
function.
 The following possibilities are noteworthy:
 assign function to a variable
 define one function inside another function
 pass a function as parameter to another function

FUNCTIONS ARE FIRST CLASS OBJECTS
 assign function to a variable:
def display(str):
return “hello”+str
#assign display () to variable x
x=display(“Python”)
print x
 define one function inside another function:

def display(str):
def message():
return “How are you?”
return message() +str
#call display function
FUNCTIONS ARE FIRST CLASS OBJECTS
 pass function as a paarmeters to other functions
def display(fun):
return “hello”+fun
def message():
return “how are you?”
#call display () and pass message() to it.
print(display(message()))
 A function can return another function:

def display(str):
def message():
return “How are you?”
return message()
#call display function
 PASS BY OBJECT REFERENCE
 In Python, the values are  Example:
sent to the functions by def modify(x):
means of object references. x=15 #reassign 15 to x
print (x,id(x))
 In Python, x=10 , here 10 is
x=10
an object and x is the name modify(x) #assign 10 to x
or tag given to that object. print(x,id(x))
 To know the location of  Output:
object, we can use id() 15 1617805096
function that gives identity 10 1617805016
number of an object. Ex :  Here integer is
id(x) immutable so another
int object is created.
 FORMAL AND ACTUAL ARGUMENTS
 here can be two types of data passed in the
function.
 1) The First type of data is the data passed in the

function call. This data is called actual arguments

 2) The second type of data is the data received in

the function definition. This data is called Formal

Arguments.
 Example :

def sum(a,b): #a, b are formal

print a+b
x=10, y =15
 TYPES OF ACTUAL ARGUMENTS
 The actual arguments used in function call are of 4
types:
1. Positional arguments

2. Keyword arguments
3. Default arguments

4. Variable Length arguments

1. Positional Arguments: When the function call
statement must match the number and order of
arguments as defined in the function definition.
It is Positional Argument
 Example: refer previous slide example.
 TYPES OF ACTUAL ARGUMENTS
2. Keyword Argument :: the argument passed
in function call is matched with function
definition on the basis of the name of the
parameter.
 Python keyword Argument Example

def msg(id,name):
print id ,name
msg(id=100,name='Raj')
msg(name='Rahul',id=101)
 TYPES OF ACTUAL ARGUMENTS
3. Default Argument : is the argument which
provides the default values to the parameters passed
in the function definition, in case value is not
provided in the function call default value is used.
 Python Function Default Argument Example

def msg(Id,Name,Age=21):
print Id , Name, Age
msg(Id=100,Name='Ravi',Age=20)
msg(Id=101,Name='Ratan') #default value will be
used.
 TYPES OF ACTUAL ARGUMENTS
4. Variable Length Argument : is the argument that
can accept any number of values provided in the
format of keys and values. If we want use it we need
to declare ‘*’ before the argument.
 Python Variable Length Argument Example

def add(fargs, *args):

print “Formal argument::”,fargs
sum=0
for i in args:
sum+=i
print “sum =“,fargs+sum
 LOCAL AND GLOBAL VARIABLES
 Variables declared inside a function body is
known as Local Variable.
 These have a local access thus these variables
cannot be accessed outside the function body
in which they are declared.
 Variable defined outside the function is
called Global Variable.
 Global variable is accessed all over
program thus global variable have widest
accessibility.
 LOCAL AND GLOBAL VARIABLES
 Example:
b=20 # b is global variable
def msg():
a=10 #a is local variable
print "Value of a is",a
print "Value of b is",b
msg()
print b
 GLOBAL KEYWORD
 Sometimes, the global variable and local
variable may have the same name.
 So In that case, the function, by default, refers
to local variable and ignores the global
variable.
 If we wants to use the global variable inside
a function, we can use the keyword “global”
before the variable in the beginning of the
function body.
 GLOBAL KEYWORD
 Example:
a=20 # b is global variable
def msg():
global a
print “Global a is",a
a=2
print ”Modified a is",a
msg()
print a
PASSING GROUP OF ELEMENTS TO FUNCTION
 We can accept a group of integers from the
keyboard in a single line using the following
statement:
lst=[int(x) for x in input().split()]
 Example:
def sum(lst):
for i in lst:
sum+=i
return sum
lst=[int(x) for x in input().split()]
X=sum(lst)
print “Total=“,X
 RECURSIVE FUNCTIONS
 A function that calls itself is known as
“Recursive Function”.
 Recursion is useful to solve complex
programs in fewer steps.
 Example:
4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1
Replacing the calculated values gives us the
following expression
4! = 4 * 3 * 2 * 1
 RECURSIVE FUNCTIONS
 Example:
def factorial(n):
if n == 0:
return 1
else:
res = n * factorial(n-1)
return result
No=input(“Enter Num::”)
factorial(No)
ANONYMOUS FUNCTIONS OR LAMBDAS
 Anonymous function does not has a name.
 Anonymous Functions are created by using a

keyword "lambda".
 Lambda takes any number of arguments and returns

an evaluated expression.
 Python Anonymous Function Syntax:

lambda arg1,args2,args3,?,argsn :expression

 Python Anonymous Function Example:

square=lambda x1: x1*x1

#Calling square as a function
print "Square of number is", square(10)
 LAMBDAS WITH FILTER() FUNCTION
 The Filter() is useful to filter out the elements of a
sequence depending on the result of a function.
 Syntax: filter(function, sequence)

 Example: A lambda that returns even numbers

from a list
lst=[10,23,45,46,78,99]
lst1=list(filter(lambda x : (x%2 == 0) , lst))
Print lst1
 LAMBDAS WITH MAP() FUNCTION
 The map() is similar to filter() function but it acts
on each element of the sequence and perhaps
changes the elements.
 Syntax: map(function, sequence)

 Example: A lambda that returns squares of

elements in a list.
lst=[1,2,3,4,5]
lst1=list(map(lambda x : x*x , lst))
Print lst1
 LAMBDAS WITH REDUCE() FUNCTION
 The reduce() reduces a sequence of elements to a
single value by processing the elements according to
a function supplied.
 Syntax: reduce(function, sequence)

 Example: A lambda that returns products of

elements of a list.
lst=[1,2,3,4,5]
result=reduce(lambda x, y : x*y , lst)
print result
 FUNCTION DECORATORS
 A decorator is a function that accepts a
function as parameter and returns a
function.
 A decorator takes the result of a function,
modifies the result and returns it.
 Thus decorators are useful to perform some
additional processing required by a function.
 To apply the decorator to any function, we
can use the ‘@’ symbol and decorator name
just above the function definition.
 FUNCTION DECORATORS
 Example: a decorator that increments the value of a
function by 2
def decor(fun): #decorator function
def inner(): #inner function that modifies
value=fun()
return value+2
return inner
@decor
def num(): #apply decorator
return 10
#call function
print num()
 GENERATORS
 Generators are functions that return a
sequence of values.
 A generator function is written like an
ordinary function but it uses ‘yield’
statement.
 Yield Statement is useful to return the
value.
 Once generator object is created, we can store
the elements of the generator into a list.
 GENERATORS
def my_generator(n):
value = 0
while value < n:
yield value
value += 1
# iterate over the generator object produced by my_generator
for value in my_generator(3):
print(value)

# x is a generator object
x = simpleGeneratorFun()
def simpleGeneratorFun():
yield 1
yield 2
yield 3
# Iterating over the generator object using next
print(next(x))
print(next(x))
print(next(x))
 STRUCTURED PROGRAMMING
 Structured Programming is the strategy used
by programmers to divide the main task into
several parts called sub tasks.
 Each of these sub tasks is represented by one
or more functions.
 By using these functions, the programmer can
accomplish the main task.
 It is used to solve the complex tasks.
CREATING OWN MODULES IN PYTHON
 A Module represents a group of classes,
methods, functions and variables.
 In Python, there are built –in modules like
sys, io, os, etc. Just like these modules, we can
also create our own modules and use them
whenever we need them.
 To import the module, we can write:
 import Module_Name
 from Module_Name import *
CREATING OWN MODULES IN PYTHON
 Example:
def add(a,b):
c=a+b
print c
return

 Save the file by the name addition.py. To import this

file "import" statement is used.
import addition
addition.add(10,20)
addition.add(30,40)
 THE SPECIAL VARIABLE __NAME__
 When a program is executed in Python, there is a
special variable internally created by the name
“__name__”.
 This variable stores information regarding whether
the program is executed as an individual program
or as a module.
 When program is imported as module, then Python
Interpreter stores the module name into this
variable.
 When program is executed directly, then Python
Interpreter stores the value “__main__” into this
variable.
 THE SPECIAL VARIABLE __NAME__
 Example:
def display():
print “Hello Python”

if __name == “__main__”:
display()
print “This code run as a program”
else:
print “This code is run as module”
PYTHON EXCEPTION
ERRORS IN PYTHON PROGRAM

 The errors in the software called ‘bugs’ and the

process of removing them is called ‘debugging’.
 We can classify errors into three types:
 Compile Time Errors: Syntactical Errors
 Runtime Errors: insufficient memory, inability of
PVM to execute some statements.
 Logical Errors: depict flaws in the logic of the
program.
 EXCEPTION
 Exception can be said to be any abnormal condition
in a program resulting to the disruption in the flow
of the program.
 Whenever an exception occurs the program halts
the execution and thus further code is not executed.
Thus exception is that error which python script is
unable to tackle with.
 All exceptions are represented as classes in Python.
 The Base class exceptions is “BaseException”
class. The sub class “Exception” is derived.
 TYPES OF EXCEPTION
 Important Exception Classes in Python
 TYPES OF EXCEPTION
Sr. No. Exception Class
1 Exception :Base class for all exceptions
StopIteration: Raised when next() method of iterator doesn’t point to any
2
object.
3 SystemExit: Raised by the sys.exit() function.
StandardError: Base class for all built-in exceptions except StopIteration and
4
SystemExit.
5 ArithmeticError: Base class for all errors that occur for numeric calculation.
OverflowError: Raised when a calculation exceeds maximum limit for a
6
numeric type.
7 FloatingPointError: Raised when a floating point calculation fails.
ZeroDivisionError: Raised when division or modulo by zero takes place for
8
all numeric types.
9 AssertionError: Raised in case of failure of the Assert statement.
 TYPES OF EXCEPTION
Sr. No. Exception Class
AttributeError:Raised in case of failure of attribute reference or
10
assignment.
EOFError:Raised when there is no input from either the
11
raw_input() or input() function and the end of file is reached.
12 ImportError: Raised when an import statement fails.
NameError:Raised when an identifier is not found in the local or
14
global namespace.
UnboundLocalError:Raised when trying to access a local
15 variable in a function or method but no value has been assigned
to it.
16 IOError:Raised when an input/ output operation fails.
17 SyntaxError:Raised when there is an error in Python syntax.
 EXCEPTION HANDLING
 The erroneous code can be handled by using try block. The
try block is followed except statement. It is then further
followed by statements which are executed during exception
and in case if exception does not occur.
 Syntax:

try:
malicious code
except Exception:
execute code
else:
In case of no exception, execute the else block code.
finally:
code which is must to be executed.
 EXCEPTION HANDLING
 Single Exception Multiple Exception
Example: Example:
try: a=10/0; try: a=10/0;
except: print "Arithmeti except ArithmeticError,Stan
c Exception" dard Error:
print "Arithmetic Excepti
else: print "Successfully
on"
”
else:print "Successfully ”
finally: print “This is
finally block” finally: print “This is
finally blcok”
 ASSERT STATEMENT
 Assertion is an expression is tested, and if the result comes
up false, an exception is raised.
 Programmers often place assertions at the start of a function
to check for valid input, and after a function call to check for
valid output.
 assert Statement: The assert statement is useful to ensure
that a given condition is True. If it is not true, it raises
AssertionError.
 ASSERT STATEMENT
Syntax: assert condition, message
 Example:
try:
x=int(input(“Enter a number between 5 and 10::”))
assert x>=5 and x<=10, “Your input is not correct”
print “Number entered::”,x
except AssertionError as obj:
print obj
USER-DEFINED EXCEPTIONS
 Generally,in Python errors and exceptions arises when the
code goes wrong which intends leads to stop suddenly.
 But by exception handling method, we can handle some of
the most frequent errors by using try-except statements.
 User can also create his/her own errors by defining an
exception class. These exception classes must be created or
derived directly or indirectly from the exception class.
USER-DEFINED EXCEPTIONS
class CustomError(Exception): ...
pass
try: ...
except CustomError: ...
Here, CustomError is a user-defined error which inherits from the Exception class.
# define Python user-defined exceptions
class InvalidAgeException(Exception):
pass
number = 18
try:
input_num = int(input("Enter a number: "))
if input_num < number:
raise InvalidAgeException
else:
print("Eligible to Vote")
except InvalidAgeException:
print("Exception occurred: Invalid Age")
 LOGGING THE EXCEPTION
 The file which stores the messages, especially of errors or
exceptions is called a log file and this technique is called
logging.
 Logging Error Level and their Predefined Numeric
Values Numeric Value Description
Level
CRITICA 50 Represents a very serious error that needs high
L attention.
ERROR 40 Represents a serious error

WARNIN 30 Represents a warning message

G
INFO 20 Represents a message with some important information

DEBUG 10 Represents a message with debugging information

NOTSET 0 Represents that the level is not set.

 LOGGING THE EXCEPTION
To releasing a log message, we need to import the logging module
 The main task of logging is to store the records events in a file. The

logging module provides the basicConfig(**kwarg), used to

configure the logging.
• level - The specified severity level is set by the root level.
• filename - It specifies a file.
• filemode - It opens a file in a specific mode. The default mode of the opening file is a,
which means we can append the content.
• format - The format defines the format of the log message.
import logging
logging.debug('The debug message is displaying')
logging.info('The info message is displaying')
logging.warning('The warning message is displaying')
logging.error('The error message is displaying')
logging.critical('The critical message is displaying')
FILES IN PYTHON
 FILE HANDLING
 Python provides the facility of working on Files. A
File is an external storage on hard disk from where
data can be stored and retrieved.
 Types of File :
1. Text Files : Text files store data in the form of
characters. For Ex: If we store “Ganesh”, it will
be stored as 6 characters.
2. Binary Files: Binary files store entire data in
the form of bytes i.e. group of 8 bits each. For
Ex: a character is stored as a byte.
 OPENING A FILE
Opening a File: Before working with Files you have
to open File. To open File, Python built in
function open() is used.
 Syntax: obj=open(filename , mode , buffer)

 filename: It is name of the file which you want to

access.
 mode: Mode depends operation to be performed

on File. Default access mode is read.

 Buffer: represents a temporary block of memory.

It is an optional integer used to the size of the

buffer for the file.
 OPENING A FILE
File Open Description
Mode
w To write data into file. If file already exists, new
data will be replace with old data.
r To read data from the file.
a To append data to the file.
w+ To write and read data of a file.
r+ To read and write data into a file
a+ To append and read data of a file.
x open file in exclusive creation mode. file
creation fails if file already exists.
 CLOSING A FILE
 Closing a File:Once you are finished with
operations on File you need to close. file.close()
method is used to close File.
 Syntax: fileobject. close()
 Writing to a File: write() is used to write string into
file.
 Syntax: fileobject. write(string str)
 Reading from File:read() is used to read data.
 Syntax: fileobject. read(value)
 here, value is the number of bytes to be read. In case, no
value is given it reads till end of file is reached.
 READ AND WRITE EXAMPLE
obj=open("abcd.txt","w")
obj.write("Welcome to the world of Python")
obj.close()
obj1=open("abcd.txt","r")
s=obj1.read()
print s
obj1.close()
obj2=open("abcd.txt","r")
s1=obj2.read(20)
print s1
obj2.close()
 KNOWING WHETHER A FILE EXISTS OR NOT
 The Operating system (os) module has a sub module
by the name “path” that contains a method isfile().
 this method can be used to know whether a file that

we are opening really exists or not.

 Example:

if os.path.isfile(fname):
f=open(fname, ‘r’)
else:
print “file does not exist”
sys.exit()
 WORKING WITH BINARY FILES
 Binary Files can be used to read or write text,images
or audio and video files.
 To perform any operation, attach b to file modes.

Ex: rb to read.
obj=open(“cat.jpg",“rb") #read mode
obj=open(“new.jpg",“wb") #write mode
#read bytes
bytes=f1.read()
f2.write(bytes)
#close files
f1.close()
 THE WITH STATEMENT
 The “with” statement can be used while opening a
file.
 The advantage of with statement is that it will take

care of closing a file which is opened by it.

 Hence, we need not close the file explicitly.
 It also handle the exception.
 Example:

with open(“sample.txt”,”w”) as f:
f.write(“Python is attractive”)
 PICKLE IN PYTHON
 Pickle is a process of converting a class object into
byte stream so that it can be stored into a file.
 This is also called object serialization.
 Pickling is done using the dump() method of
“pickle” module as : pickle.dump(object, file)
 Unpickle is a process whereby a byte stream is
converted back into class object. It means,
unpickling represents reading the class objects from
the file.
 Unpickling is also called deserialization.
 Unpickling is done using the load() method of
“pickle” module as : Object=pickle.load(file)
 PICKLE IN PYTHON EXAMPLE
 Pickle is a process of converting a class object into
byte stream so that it can be stored into a file.
 This is also called object serialization.
 Pickling is done using the dump() method of
“pickle” module as : pickle.dump(object, file)
 Unpickle is a process whereby a byte stream is
converted back into class object. It means,
unpickling represents reading the class objects from
the file.
 Unpickling is also called deserialization.
 Unpickling is done using the load() method of
“pickle” module as : Object=pickle.load(file)
 THE SEEK() AND TELL() METHODS
 To know the position of the file pointer, we can use
the tell() method.
 It returns the current position of the file pointer
from the beginning of the file.
 It is used in the form: n =f.tell()
 We want to move the file pointer to another
position, we can use the seek() method. This method
takes two arguments:
 f.seek(offset, fromwhere)
 offset – how many bytes to move.
 fromwhere- from which position to move. It can be
0(beginning) ,1 (current) or 2(end)
THE SEEK() AND TELL() METHODS
fi = open("text.txt", "r")
# the second parameter of the seek method is by default 0
fi.seek(30)
#the user is setting the reference point to thirtieth
position to the left from end
fi.seek (-70, 2)
# now, we will print the current position
print(fi.tell())
print(fi.readline())
fi.close()