Exception handling and function in python

Exception Handling in Python
A Python program terminates as soon
as it encounters an error. In Python, an
error can be a syntax error or an
exception
Dr.T.Maragatham
Kongu Engineering College,
Erode

Error – Syntax Error
• Syntax Error:
• Syntax errors occur when the parser detects an incorrect statement.
• Most syntax errors are typographical , incorrect indentation, or incorrect
arguments.
• Example:
• i=1
• while i<5
• print(i)
• i=i+1
• Shows:
• File "<string>", line 2
• while i<5 # : missing
• ^
• SyntaxError: invalid syntax

Error - Exception
• Exception: Even if a statement or expression is
syntactically in-correct, it may cause an error when an
attempt is made to execute it. Errors detected during
execution are called exceptions .
• Example:
• x=(10/0) or x=(10%0)
• print(x)
• Shows:
• Traceback (most recent call last):
• File "<string>", line 1, in <module>
• ZeroDivisionError: division by zero

• Exceptions come in different types, and the type
is printed as part of the message:
• the types in the example are ZeroDivisionError,
NameError and TypeError.
• The string printed as the exception type is the
name of the built-in name for the exception that
occurred.

The try block will generate an
exception, because x is not defined:
• try:
• print(x)
• except:
• print("An exception occurred")
• Since the try block raises an error, the except
block will be executed.
• Without the try block, the program will crash and
raise an error:

Many Exceptions
• You can define as many exception blocks as you want.
• Example
• Print one message if the try block raises a NameError and another
for other errors:
• #The try block will generate a NameError, because x is not defined:
• try:
• print(x)
• except NameError:
• print("Variable x is not defined")
• except:
• print("Something else went wrong")

Else
• You can use the else keyword to define a block of code to
be executed if no errors were raised:
• Example:
• #The try block does not raise any errors, so the else block is
executed:
• try:
• print("Hello")
• except:
• print("Something went wrong")
• else:
• print("Nothing went wrong")

Finally
• The finally block, if specified, will be executed regardless if
the try block raises an error or not.
• Example:
• #The finally block gets executed no matter if the try block
raises any errors or not:
• try:
• print(x)
• except:
• print("Something went wrong")
• finally:
• print("The 'try except' is finished")

• Here is an example of an incorrect use:
• d={}
• try:
• x = d[5]
• except LookupError:
• # WRONG ORDER
• print("Lookup error occurred")
• except KeyError:
• print("Invalid key used")

• #The try block will raise an error when trying to write
to a read-only file:
• try:
• f = open("demofile.txt")
• f.write("Lorum Ipsum")
• except:
• print("Something went wrong when writing to the
file")
• finally:
• f.close()

• Raise an exception
• As a Python developer you can choose to throw an
exception if a condition occurs.
• To throw (or raise) an exception, use the raise keyword.
• Example
• Raise an error and stop the program if x is lower than
0:
• x = -1
if x < 0:
raise Exception("Sorry, no numbers below zero")

• raise SomeException: throws an exception (a
specific type of ball, like throwing only tennis
balls).
• except: catches all exceptions (regardless of
type).

The raise keyword is used to raise an exception.
You can define what kind of error to raise, and the text to print
to the user.
• Example
• Raise a TypeError if x is not an integer:
• x = "hello"
if not type(x) is int:
raise TypeError("Only integers are allowed")

Python Custom Exceptions
• Python has numerous built-in exceptions that
force your program to output an error when
something in the program goes wrong.
• However, sometimes you may need to create
your own custom exceptions that serve your
purpose.

Creating Custom Exceptions
• Users can define custom exceptions by
creating a new class.
• This exception class has to be derived, either
directly or indirectly, from the built-in
Exception class.
• Most of the built-in exceptions are also
derived from this class.

Throw an Exception using “raise”
• name="Malar"
• age = 15
• print(name)
• print(age)
• if int(age)>17:
• print("You can vote")
• else:
• print("You can't vote")
• raise ValueError("Vote when you tern 18 year old")

Throw a Custom Exception
• class Age_Restriction(ValueError):
• pass
• name="Malar"
• age = 15
• print(name)
• print(age)
• if int(age)>17:
• print("You can vote")
• else:
• print("You can't vote")
• raise Age_Restriction("Vote when you tern 18 year old")
•

class exceptionName(baseException):
pass
• One use of custom exceptions is to break out
of deeply nested loops.
• For example, if we have a table object that
holds records (rows),
• which hold fields (columns),
• which have multiple values (items),
• we could search for a particular value

• found = False
• for row, record in enumerate(table):
• for column, field in enumerate(record):
• for index, item in enumerate(field):
• if item == target:
• found = True
• break
• if found:
• break
• if found:
• break
• if found:
• print("found at ({0}, {1}, {2})".format(row, column, index))
• else:
• print("not found")

• from prettytable import PrettyTable
list1=[“Anu",”18",“98"]
list2=[“Siva",“19",“96"]
table=PrettyTable([‘Name',’Age‘,’Mark’])
for x in range(0,3):
table.add_row(list1[x],list2[x])
print(table)

• class FoundException(Exception):
• pass
• found = False
• try:
• for row, record in enumerate(table):
• for column, field in enumerate(record):
• for index, item in enumerate(field):
• if item == target:
• raise FoundException()
• except FoundException:
• print("found at ({0}, {1}, {2})".format(row, column, index))
• else:
• print("not found")

Functions
• A function is a block of code which only runs
when it is called.
• You can pass data, known as parameters, into
a function.
• A function can return data as a result.

• Creating a Function
• In Python a function is defined using
the def keyword:
• Calling a Function
• To call a function, use the function name
followed by parenthesis:
• Arguments
• Information can be passed into functions as
arguments.

• def my_function(fname):
• print(fname + " Priya")
• my_function(“Anu")
• my_function(“Guna")
• my_function(“Sasi")

• def my_function(fname, lname):
• print(fname + " " + lname)
• my_function(“Arun") # Error

Arbitrary Arguments, *args
• If you do not know how many arguments that
will be passed into your function,
• add a * before the parameter name in the
function definition.
• def my_function(*kids):
• print("The youngest child is " + kids[2])
• my_function(“Aradhana", “Diya", “Roshan")

Keyword Arguments
• You can also send arguments with
the key = value syntax.
• This way the order of the arguments does not
matter.
• def my_function(child3, child2, child1):
• print("The youngest child is " + child3)
• my_function(child1 = “Aradhana", child2 =
“Diya", child3 = “Roshan")

Default Parameter Value
• The following example shows how to use a default parameter
value.
• If we call the function without argument, it uses the default
value:
• def my_function(country = "Norway"):
• print("I am from " + country)
• my_function("Sweden")
• my_function("India")
• my_function()
• my_function("Brazil")

Passing a List as an Argument
• You can send any data types of argument to a
function (string, number, list, dictionary etc.),
and it will be treated as the same data type
inside the function.
• def my_function(food):
• for x in food:
• print(x)
• fruits = ["apple", "banana", "cherry"]
• my_function(fruits)

Return Values
• To let a function return a value, use
the return statement:
• def my_function(x):
• return 5 * x
• print(my_function(3))

The pass Statement
• function definitions cannot be empty, but if
you for some reason have
a function definition with no content, put in
the pass statement to avoid getting an error.
• def myfunction():
pass

Recursion
• Python also accepts function recursion, which
means a defined function can call itself.
• def tri_recursion(k):
• if(k > 0):
• result = k + tri_recursion(k - 1)
• else:
• result = 0
• return result
• print("nnRecursion Example Results")
• print(tri_recursion(6))

Pass by reference vs value
• All parameters (arguments) in the Python
language are passed by reference.
• It means if you change what a parameter
refers to within a function, the change also
reflects back in the calling function.

• def changeme( mylist ):
• #"This changes a passed list into this function"
• mylist.append([1,2,3,4])
• print("Values inside the function: ", mylist)
• return
• # Now you can call changeme function
• mylist = [10,20,30]
• changeme( mylist )
• print("Values outside the function: ", mylist)

• # Function definition is here
• def changeme( mylist ):
• mylist = [1,2,3,4]; # This would assign new
reference in mylist
• print "Values inside the function: ", mylist
• # Now you can call changeme function
• mylist = [10,20,30];
• changeme( mylist );
• print "Values outside the function: ", mylist

Scope of Variables
• The scope of a variable determines the
portion of the program where you can access
a particular identifier.
• There are two basic scopes of variables in
Python −
• Global variables
• Local variables

Global vs. Local variables
• Variables that are defined inside a function
body have a local scope, and those defined
outside have a global scope.
• local variables can be accessed only inside the
function in which they are declared, whereas
global variables can be accessed throughout
the program body by all functions.

• total = 0; # This is global variable.
• # Function definition is here
• def sum( arg1, arg2 ):
• # Add both the parameters and return them."
• total = arg1 + arg2; # Here total is local variable.
• print("Inside the function local total : ", total)
• return total
• # Now you can call sum function
• sum( 10, 20 )
• print("Outside the function global total : ", total)

Lambda Forms:
• In Python, small anonymous (unnamed)
functions can be created with lambda
keyword.
• A lambda function in python has the following
syntax.
• lambda arguments: expression
• Lambda functions can have any number of
arguments but only one expression.
• The expression is evaluated and returned

• double = lambda x: x * 2
• print(double(5))

• def average(x, y):
• return (x + y)/2
• print(average(4, 3))
• may also be defined using lambda
• print((lambda x, y: (x + y)/2)(4, 3))
• double = lambda x,y:((x+y /2))
• print(double(4,3))

Python Documentation Strings
• a string literal is used for
documenting a module, function, class, or m
ethod.
• You can access string literals by __doc__
(notice the double underscores)
• (e.g. my_function.__doc__)

Docstring Rules :
• String literal literals must be enclosed with a
triple quote. Docstring should be informative
• The first line may briefly describe the object's
purpose. The line should begin with a capital
letter and ends with a dot.
• If a documentation string is a muti-line string
then the second line should be blank followed
by any detailed explanation starting from the
third line.

• def avg_number(x, y):
• """Calculate and Print Average of two
Numbers.
•
• Created on 29/12/2012. python-docstring-
example.py
• """
• print("Average of ",x," and ",y, " is ",(x+y)/2)
• print(avg_number.__doc__)

Exception handling and function in python

Recommended

More Related Content

What's hot (20)

Similar to Exception handling and function in python (20)

Recently uploaded (20)

Exception handling and function in python