functions modules and exceptions handlings.ppt

Python - Functions
• A function is a block of organized, reusable code that is used to
perform a single, related action. Functions provides better
modularity for your application and a high degree of code reusing.
• As you already know, Python gives you many built-in functions like
print() etc. but you can also create your own functions. These
functions are called user-defined functions.

Defining a Function
Here are simple rules to define a function in Python:
• Function blocks begin with the keyword def followed by the function
name and parentheses ( ( ) ).
• Any input parameters or arguments should be placed within these
parentheses. You can also define parameters inside these
parentheses.
• The first statement of a function can be an optional statement - the
documentation string of the function or docstring.
• The code block within every function starts with a colon (:) and is
indented.
• The statement return [expression] exits a function, optionally
passing back an expression to the caller. A return statement with no
arguments is the same as return None.
• Syntax:
• def functionname( parameters ):
• "function_docstring" function_suite return [expression]

• Syntax:
def functionname( parameters ):
"function_docstring"
function_suite
return [expression]
By default, parameters have a positional behavior, and you need
to inform them in the same order that they were defined.
• Example:
def printme( str ):
"This prints a passed string function"
print str
return

Calling a Function
• Following is the example to call printme() function:
def printme( str ): "This is a print function“
print str;
return;
printme("I'm first call to user defined function!");
printme("Again second call to the same function");
• This would produce following result:
I'm first call to user defined function!
Again second call to the same function

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. For
example:
def changeme( mylist ): "This changes a passed list“
mylist.append([1,2,3,4]);
print "Values inside the function: ", mylist
return
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist
• So this would produce following result:
Values inside the function: [10, 20, 30, [1, 2, 3, 4]]
Values outside the function: [10, 20, 30, [1, 2, 3, 4]]

There is one more example where argument is being passed by reference
but inside the function, but the reference is being over-written.
def changeme( mylist ): "This changes a passed list"
mylist = [1,2,3,4];
print "Values inside the function: ", mylist
return
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist
• The parameter mylist is local to the function changeme. Changing mylist
within the function does not affect mylist. The function accomplishes
nothing and finally this would produce following result:
Values inside the function: [1, 2, 3, 4]
Values outside the function: [10, 20, 30]

Function Arguments:
A function by using the following types of formal arguments::
– Required arguments
– Keyword arguments
– Default arguments
– Variable-length arguments
Required arguments:
• Required arguments are the arguments passed to a function in correct
positional order.
def printme( str ): "This prints a passed string"
print str;
return;
printme();
Traceback (most recent call last):
File "test.py", line 11, in <module> printme();
TypeError: printme() takes exactly 1 argument (0 given)

Keyword arguments:
• Keyword arguments are related to the function calls. When
you use keyword arguments in a function call, the caller
identifies the arguments by the parameter name.
• This allows you to skip arguments or place them out of order
because the Python interpreter is able to use the keywords
provided to match the values with parameters.
def printme( str ): "This prints a passed string"
print str;
return;
printme( str = "My string");
My string

Following example gives more clear picture. Note, here order of
the parameter does not matter:
def printinfo( name, age ): "Test function"
print "Name: ", name;
print "Age ", age;
return;
printinfo( age=50, name="miki" );
Name: miki Age 50

Default arguments:
• A default argument is an argument that assumes a default
value if a value is not provided in the function call for that
argument.
• Following example gives idea on default arguments, it would
print default age if it is not passed:
def printinfo( name, age = 35 ): “Test function"
print "Name: ", name;
print "Age ", age;
return;
printinfo( age=50, name="miki" );
printinfo( name="miki" );
Name: miki Age 50 Name: miki Age 35

Variable-length arguments:
• You may need to process a function for more arguments than
you specified while defining the function. These arguments
are called variable-length arguments and are not named in
the function definition, unlike required and default
arguments.
• The general syntax for a function with non-keyword variable
arguments is this:
def functionname([formal_args,] *var_args_tuple ):
"function_docstring"
function_suite
return [expression]

• An asterisk (*) is placed before the variable name that will
hold the values of all nonkeyword variable arguments. This
tuple remains empty if no additional arguments are specified
during the function call. For example:
def printinfo( arg1, *vartuple ):
"This is test"
print "Output is: "
print arg1
for var in vartuple:
print var
return;
printinfo( 10 );
printinfo( 70, 60, 50 );
Output is:
10
Output is:
70
60
50

The Anonymous Functions:
You can use the lambda keyword to create small anonymous functions.
These functions are called anonymous because they are not
declared in the standard manner by using the def keyword.
• Lambda forms can take any number of arguments but return just
one value in the form of an expression. They cannot contain
commands or multiple expressions.
• An anonymous function cannot be a direct call to print because
lambda requires an expression.
• Lambda functions have their own local namespace and cannot
access variables other than those in their parameter list and those
in the global namespace.
• Although it appears that lambda's are a one-line version of a
function, they are not equivalent to inline statements in C or C++,
whose purpose is by passing function stack allocation during
invocation for performance reasons.
• Syntax:
lambda [arg1 [,arg2,.....argn]]:expression

Example:
• Following is the example to show how lembda form of
function works:
sum = lambda arg1, arg2: arg1 + arg2;
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )
Value of total : 30
Value of total : 40

Scope of Variables:
• All variables in a program may not be accessible at all locations in
that program. This depends on where you have declared a variable.
• 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.
• This means that 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. When you
call a function, the variables declared inside it are brought into
scope.

• Example:
total = 0; # This is global variable.
def sum( arg1, arg2 ):
"Add both the parameters"
total = arg1 + arg2;
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
Inside the function local total : 30
Outside the function global total : 0

Type Conversions
• When you put an
integer and
floating point in
an expression the
integer is
implicitly
converted to a
float
• You can control
this with the built
in functions int()
and float()
>>> print float(99) / 100
0.99
>>> i = 42
>>> type(i)
<type 'int'>
>>> f = float(i)
>>> print f
42.0
>>> type(f)
<type 'float'>
>>> print 1 + 2 * float(3) / 4 - 5
-2.5
>>>

String
Conversions
• You can also
use int() and
float() to
convert between
strings and
integers
• You will get an
error if the
string does not
contain numeric
characters
>>> sval = '123'
>>> type(sval)
<type 'str'>
>>> print sval + 1
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int'
>>> ival = int(sval)
>>> type(ival)
<type 'int'>
>>> print ival + 1
124
>>> nsv = 'hello bob'
>>> niv = int(nsv)
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int()

Building our Own Functions
• We create a new function using the def
keyword followed by optional parameters
in parenthesis.
• We indent the body of the function
• This defines the function but does not
execute the body of the function
def print_lyrics():
print "I'm a lumberjack, and I'm okay.”
print 'I sleep all night and I work all day.'

x = 5
print 'Hello'
def print_lyrics():
print 'Yo'
x = x + 2
print x
Hello
Yo
7
print "I'm a lumberjack, and I'm okay."
print 'I sleep all night and I work all
day.'
print_lyrics():

Definitions and Uses
• Once we have defined a function, we can
call (or invoke) it as many times as we like
• This is the store and reuse pattern

x = 5
print 'Hello'
def print_lyrics():
print 'Yo'
print_lyrics()
x = x + 2
print x
Hello
Yo
I'm a lumberjack, and I'm okay.I
sleep all night and I work all day.
7

1. Write a Python function to find the Max of three
numbers.
2.Write a Python function to sum all the numbers in a list.
Sample List : (8, 2, 3, 0, 7)
3.Write a Python function to reverse a string.
4.Write a Python function that takes a list and returns a
new list with unique elements of the first list.

1)def maximum(a, b, c):
if (a >= b) and (a >= c):
largest = a
elif (b >= a) and (b >= c):
largest = b
else:
largest = c
return largest
# Driven code
a = 10
b = 14
c = 12
print(maximum(a, b, c))

2)def sum(numbers):
total = 0
for x in numbers:
total += x
return total
print(sum((8, 2, 3, 0, 7)))

3)def reverse(string):
string = string[::-1] #Using
Slicing
return string
s = "IloveIndia"
print ("The original string is :
",end="")
print (s)
print ("The reversed string(using
extended slice syntax) is : ",end="")
print (reverse(s))

4)def unique_list(l):
x = []
for a in l:
if a not in x:
x.append(a)
return x
print(unique_list([1,2,3,3,3,3,4,5]))

functions modules and exceptions handlings.ppt

• To display a list of all available modules, use the following command in
the Python console
>>> help(‘modules’)

OS MODULE
• mkdir( ) - A new directory corresponding to the path in the string argument of
the function will be created.
• getcwd( ) - current working directory
• rmdir( ) - removes the specified directory either with an absolute or relative
path. However, we can not remove the current working directory. Also, for a
directory to be removed, it should be empty.
• listdir( ) - returns the list of all files and directories in the specified directory.
If we don't specify any directory, then list of files and directories in the
current working directory will be returned.

SYS MODULE
• sys.argv - returns a list of command line arguments passed to a Python script.
The item at index 0 in this list is always the name of the script. The rest of the
arguments are stored at the subsequent indices.
• sys.maxsize - Returns the largest integer a variable can take.
• sys.path - This is an environment variable that is a search path for all Python
modules.
• sys.version - This attribute displays a string containing the version number of the
current Python interpreter.

PYTHON MODULES
Python has a way to put definitions in a file and use them in
a script or in an interactive instance of the interpreter. Such a
file is called a module; definitions from a module can
be imported into other modules or into the main module (the
collection of variables that you have access to in a script
executed at the top level and in calculator mode).

A module is a file containing Python
definitions and statements.
The file name is the module name
with the suffix .py appended.
Within a module, the module’s name
(as a string) is available as
the value of the global variable __name__.
For instance, use your favorite text editor to
create a file called fibo.py in the
current directory with the following contents:

Modules can import other modules.
It is customary but not required to
place all import statements at the
beginning of a module (or script, for that matter).
The imported module names are placed in the
importing module’s global symbol table.

# Python program to
# demonstrate date class
# import the date class
from datetime import date
# initializing constructor
# and passing arguments in the
# format year, month, date
my_date = date(1996, 12, 11)
print("Date passed as argument is", my_date)
# Uncommenting my_date = date(1996, 12, 39)
# will raise an ValueError as it is
# outside range
# uncommenting my_date = date('1996', 12, 11)
# will raise a TypeError as a string is
# passed instead of integer

Current date
To return the current local date today() function of date class is used.
today() function comes with several attributes (year, month and day). These
can be printed individually.
# Python program to
# print current date
from datetime import date
# calling the today
# function of date class
today = date.today()
print("Today's date is", today)
# Printing date's components
print("Date components", today.year, today.month, today.day)

Time class
Time object represents local time, independent of any
day.
Constructor Syntax:
class datetime.time(hour=0, minute=0, second=0, microsecond=0,
tzinfo=None, *, fold=0)
All the arguments are optional. tzinfo can be None otherwise all the attributes
must be integer in the following range –
•0 <= hour < 24
•0 <= minute < 60
•0 <= second < 60
•0 <= microsecond < 1000000
•fold in [0, 1]

# Python program to
# demonstrate time class
from datetime import time
# calling the constructor
my_time = time(13, 24, 56)
print("Entered time", my_time)
# calling constructor with 1
# argument
my_time = time(minute = 12)
print("nTime with one argument", my_time)
# Calling constructor with
# 0 argument
my_time = time()
print("nTime without argument", my_time)
# Uncommenting time(hour = 26)
# will rase an ValueError as
# it is out of range
# uncommenting time(hour ='23')
# will raise TypeError as
# string is passed instead of int

from datetime import time
Time = time(11, 34, 56)
print("hour =", Time.hour)
print("minute =", Time.minute)
print("second =", Time.second)
print("microsecond =", Time.microsecond)
Output:
hour = 11
minute = 34
second = 56
microsecond = 0

# Python program to
# demonstrate datetime object
from datetime import datetime
# Initializing constructor
a = datetime(1999, 12, 12)
print(a)
# Initializing constructor
# with time parameters as well
a = datetime(1999, 12, 12, 12, 12, 12, 342380)
print(a)

# Timedelta function demonstration
from datetime import datetime, timedelta
# Using current time
ini_time_for_now = datetime.now()
# printing initial_date
print ("initial_date", str(ini_time_for_now))
# Calculating future dates
# for two years
future_date_after_2yrs = ini_time_for_now + timedelta(days = 730)
future_date_after_2days = ini_time_for_now + timedelta(days = 2)
# printing calculated future_dates
print('future_date_after_2yrs:', str(future_date_after_2yrs))
print('future_date_after_2days:', str(future_date_after_2days))

# Timedelta function demonstration
from datetime import datetime, timedelta
# Using current time
ini_time_for_now = datetime.now()
# printing initial_date
print ("initial_date", str(ini_time_for_now))
# Some another datetime
new_final_time = ini_time_for_now +
timedelta(days = 2)
# printing new final_date
print ("new_final_time", str(new_final_time))
# printing calculated past_dates
print('Time difference:', str(new_final_time -
ini_time_for_now))

Python
• Exceptions Exception Handling Try and
Except Nested try Block
• Handling Multiple Exceptions in single
Except Block Raising Exception
• Finally Block
• User Defined Exceptions

Exception
⚫ When writing a program, we, more often than
not, will encounter errors.
⚫ Error caused by not following the proper
structure (syntax) of the language is called
syntax error or parsing error
⚫ Errors can also occur at runtime and these are
called exceptions.
⚫ They occur, for example, when a file we try to
open does not exist (FileNotFoundError),
dividing a number by zero (ZeroDivisionError)
⚫ Whenever these type of runtime error occur,
Python creates an exception object. If not
handled properly, it prints a traceback to that
error along with some details about why that
error occurred.

Exception Handling
⚫To handle exceptions, and to call code
when an exception occurs, we can use
a try/except statement.
⚫The try block contains code that might
throw an exception.
⚫If that exception occurs, the code in
the try block stops being executed,
and the code in the except block is
executed.
⚫If no error occurs, the code in the
except
block doesn't execute.

⚫A try statement can have
multiple different except
blocks to handle different
exceptions.

⚫Multiple exceptions can also be put
into a single except block using
parentheses, to have the except
block handle all of them.

Raising Exception from Except
Block

finally
⚫To ensure some code runs no
matter what errors occur, you can
use a finally statement.
⚫The finally statement is placed at
the bottom of a try/except
statement.
⚫Code within a finally statement
always runs after execution of the
code in the try, and possibly in the
except, blocks.

⚫Code in a finally statement even
runs if an uncaught exception
occurs in one of the preceding
blocks.

Raising Exception
⚫Raising exception is similar to
throwing exception in C++/Java.
⚫You can raise exceptions by using
the raise statement

functions modules and exceptions handlings.ppt

Recommended

More Related Content

Similar to functions modules and exceptions handlings.ppt (20)

More from Rajasekhar364622 (19)

Recently uploaded (20)

functions modules and exceptions handlings.ppt