ADVANCED PYTHON PROGRAMMING B.

TECH III-II CREC

UNIT – IV

UNIT – IV Syllabus: Functions - Defining Functions, Calling Functions, Passing

Arguments, Keyword Arguments, Default Arguments, Variable-length arguments,
Anonymous Functions, Fruitful Functions(Function Returning Values), Scope of the
Variables in a Function - Global and Local Variables. Modules: Creating modules,
import statement, from ..import statement, name spacing, Python packages,
Introduction to PIP, Installing Packages via PIP, Using Python Packages Error and
Exceptions: Difference between an error and Exception, Handling Exception, try
except block, Raising Exceptions, User Defined Exceptions
-------------------------------------------------------------------------------------------------------------

FUNCTIONS :
A function is a block of organized, reusable code that is used to perform
a single, related action. Functions provide better modularity for our application and
a high degree of code reusing.
Python supports both built-in functions such as print() and user-defined functions.

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

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.

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

1
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

Example
The following function takes a string as input parameter and prints it on standard
screen.
def printme( str ):
"This prints a passed string into this function"
print str
return
Calling a Function
Defining a function only gives it a name, specifies the parameters that are to be
included in the function and structures the blocks of code.
Once the basic structure of a function is finalized, you can execute it by calling it
from another function or directly from the Python prompt. Following is the example
to call printme() function:
#!/usr/bin/python
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print str;
return;
# Now you can call printme function
printme("I'm first call to user defined function!");
printme("Again second call to the same function");
When the above code is executed, it produces the following result:
I'm first call to user defined function!
Again second call to the same function

Passing arguments:
A function can be called in one of the two methods . which are
1. Pass by value
2. Pass by reference

Passing by Reference Versus Passing by Value:

In pass by value method if we change a parameter in the called function, the
change does not reflects back in the calling function
All parameters (arguments) in the Python language are passed by reference. It
means if we change what a parameter refers to within a function, the change also
reflects back in the calling function. For example:
#!/usr/bin/python
# Function definition is here
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 );

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

2
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

print "Values outside the function: ", mylist

Here, we are maintaining reference of the passed object and appending values in
the same object. So, this would produce the 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 and the
reference is being overwritten inside the called function.
#!/usr/bin/python
# Function definition is here
def changeme( mylist ):
#"This changes a passed list into this function"
mylist = [1,2,3,4]; # This would assig new reference in mylist
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
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 the following result:
Values inside the function: [1, 2, 3, 4]
Values outside the function: [10, 20, 30]
Example3:
>>> def func1(list):
... print list
... list = [47,11]
... print list
...
>>> fib = [0,1,1,2,3,5,8]
>>> func1(fib)
[0, 1, 1, 2, 3, 5, 8]
[47, 11]
>>> print fib
[0, 1, 1, 2, 3, 5, 8]
>>>
This changes drastically, if we include something in the list by using +=. To
show this, we have a different function func2() in the following example:
>>> def func2(list):
... print list
... list += [47,11]
... print list
...
>>> fib = [0,1,1,2,3,5,8]
>>> func2(fib)
[0, 1, 1, 2, 3, 5, 8]
[0, 1, 1, 2, 3, 5, 8, 47, 11]

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

3
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

>>> print fib

[0, 1, 1, 2, 3, 5, 8, 47, 11]
>>>
The user of the function can prevent this by passing a copy to the function.
In this case a shallow copy is sufficient:
>>> def func2(list):
... print list
... list += [47,11]
... print list
...
>>> fib = [0,1,1,2,3,5,8]
>>> func2(fib[:])
[0, 1, 1, 2, 3, 5, 8]
[0, 1, 1, 2, 3, 5, 8, 47, 11]
>>> print fib
[0, 1, 1, 2, 3, 5, 8]
>>>
Function Arguments:

We can call a function by using the following types of formal arguments:

1. Required arguments
2. Keyword arguments
3. Default arguments
4. Variable-length arguments

Required Arguments:
Required arguments are the arguments passed to a function in correct
positional order. Here, the number of arguments in the function call should
match exactly with the function definition.
For Example:
To call the function printme(), you definitely need to pass one argument,
otherwise it gives a syntax error as follows:
#!/usr/bin/python
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print str;
return;
# Now you can call printme function
printme();
When the above code is executed, it produces the following result:
Traceback (most recent call last):
File "test.py", line 11, in <module>
printme();
TypeError: printme() takes exactly 1 argument (0 given)

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

4
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

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
For Example:
#!/usr/bin/python
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print str;
return;
# Now you can call printme function
printme( str = "My string");
When the above code is executed, it produces the following result:
My string
example : the order of parameters does not matter.
#!/usr/bin/python
# Function definition is here
def printinfo( name, age ):
"This prints a passed info into this function"
print "Name: ", name;
print "Age ", age;
return;
# Now you can call printinfo function
printinfo( age=50, name="miki" );
When the above code is executed, it produces the following result:
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. The following, prints
default age if it is not passed:
#!/usr/bin/python
# Function definition is here
def printinfo( name, age = 35 ):
"This prints a passed info into this function"
print "Name: ", name;
print "Age ", age;
return;
# Now you can call printinfo function
printinfo( age=50, name="miki" );

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

5
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

printinfo( name="miki" );
When the above code is executed, it produces the following result:
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.
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 holds the values of all
nonkeyword variable arguments. This tuple remains empty if no additional
arguments are specified during the function call. Following is a simple
example:
#!/usr/bin/python
# Function definition is here
def printinfo( arg1, *vartuple ):
"This prints a variable passed arguments"
print "Output is: "
print arg1
for var in vartuple:
print var
return;
# Now you can call printinfo function
printinfo( 10 );
printinfo( 70, 60, 50 );
When the above code is executed, it produces the following result:
Output is:
10
Output is:
70
60
50

The Anonymous Functions:

These functions are called anonymous because they are not declared in the
standard manner by using the def keyword. You can use the lambda keyword to
create small anonymous functions.

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

6
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

1. 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.
2. An anonymous function cannot be a direct call to print because lambda requires
an expression.
3. Lambda functions have their own local namespace and cannot access variables
other than those in their parameter list and those in the global namespace.
4. 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 :
The syntax of lambda functions contains only a single statement, which is as
follows:
lambda [arg1 [,arg2,.....argn]]:expression
Following is the example to show how lambda form of function works:
#!/usr/bin/python
# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;
# Now you can call sum as a function
print "Value of total : ", sum( 10, 20
print "Value of total : ", sum( 20, 20 )
When the above code is executed, it produces the following result:
Value of total : 30
Value of total : 40

Fruitful Functions /The return Statement :

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.
The examples return a value from a function as follows:
#!/usr/bin/python
# Function definition is here
def sum( arg1, arg2 ):
# Add both the parameters and return them."
total = arg1 + arg2
print "Inside the function : ", total
return total;
# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total
When the above code is executed, it produces the following result:
Inside the function : 30
Outside the function : 30

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

7
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

Scope of Variables in a function:

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:
1. Global variables
2. 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.
For example:
#!/usr/bin/python
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
When the above code is executed, it produces the following result:
Inside the function local total : 30
Outside the function global total : 0

MODULES :
Modules in Python are simply Python files with the .py extension, which implement a set
of functions. Modules are imported from other modules using the import command.

To import a module, we use the import command. The first time a module is loaded

into a running Python script, it is initialized by executing the code in the module once. If
another module in your code imports the same module again, it will not be loaded twice
but once only - so local variables inside the module act as a "singleton" - they are
initialized only once.

If we want to import the module urllib, which enables us to create read data from
URLs, we simply import the module:

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

8
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

# import the library

import urllib
# use it
urllib.urlopen(...)

Exploring built-in modules:

Two very important functions come in handy when exploring modules in Python -
the dir and help functions.

We can look for which functions are implemented in each module by using
the dir function:
>>> import urllib
>>> dir(urllib)
['ContentTooShortError', 'FancyURLopener', 'MAXFTPCACHE', 'URLopener',
'__all__', '__builtins__', '__doc__', '__file__', '__name__',
'__package__', '__version__', '_ftperrors', '_get_proxies',
'_get_proxy_settings', '_have_ssl', '_hexdig', '_hextochr',
'_hostprog', '_is_unicode', '_localhost', '_noheaders', '_nportprog',
'_passwdprog', '_portprog', '_queryprog', '_safe_map',
'_safe_quoters', '_tagprog', '_thishost', '_typeprog', '_urlopener',
'_userprog', '_valueprog', 'addbase', 'addclosehook', 'addinfo',
'addinfourl', 'always_safe', 'basejoin', 'c', 'ftpcache', 'ftperrors',
'ftpwrapper', 'getproxies', 'getproxies_environment',
'getproxies_macosx_sysconf', 'i', 'localhost', 'main', 'noheaders',
'os', 'pathname2url', 'proxy_bypass', 'proxy_bypass_environment',
'proxy_bypass_macosx_sysconf', 'quote', 'quote_plus', 'reporthook',
'socket', 'splitattr', 'splithost', 'splitnport', 'splitpasswd',
'splitport', 'splitquery', 'splittag', 'splittype', 'splituser',
'splitvalue', 'ssl', 'string', 'sys', 'test', 'test1', 'thishost',
'time', 'toBytes', 'unquote', 'unquote_plus', 'unwrap',
'url2pathname', 'urlcleanup', 'urlencode', 'urlopen', 'urlretrieve']

When we find the function in the module we want to use, we can read about it more
using the help function, inside the Python interpreter:
help(urllib.urlopen)

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

9
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

Creating modules: Writing Python modules is very simple. To create a module of your

own, simply create a new .py file with the module name, and then import it using the

Python file name (without the .py extension) using the  import command.
A module allows us to logically organize our Python code. Grouping related code
into a module makes the code easier to understand and use. A module is a Python
object with arbitrarily named attributes that you can bind and reference.
Simply, a module is a file consisting of Python code. A module can define functions,
classes and variables. A module can also include runnable code.
Example:
The Python code for a module named aname normally resides in a file named
aname.py. Here is an example of a simple module, support.py
def print_func( par ):
print "Hello : ", par
return

The import Statement:

You can use any Python source file as a module by executing an import statement
in some other Python source file. The import has the following syntax:
import module1[, module2[,... moduleN]

When the interpreter encounters an import statement, it imports the module if the
module is present in the search path. A search path is a list of directories that the
interpreter searches before importing a module. For example, to import the module
hello.py, you need to put the following command at the top of the script:
#!/usr/bin/python
# Import module support
import support
# Now you can call defined function that module as follows
support.print_func("Zara")
When the above code is executed, it produces the following result:
Hello : Zara
A module is loaded only once, regardless of the number of times it is imported. This
prevents the module execution from happening over and over again if multiple
imports occur.

The from...import Statement:

Python's from statement lets you import specific attributes from a module into the
current namespace. The from...import has the following syntax:
from modname import name1[, name2[, ... nameN]]
For example, to import the function fibonacci from the module fib, use the following
statement:
from fib import fibonacci

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

10
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

This statement does not import the entire module fib into the current namespace; it
just introduces the item fibonacci from the module fib into the global symbol table
of the importing module.

The from...import * Statement:

It is also possible to import all names from a module into the current namespace by
using the following import statement:
from modname import *
This provides an easy way to import all the items from a module into the current
namespace; however, this statement should be used sparingly.

Locating Modules:
When you import a module, the Python interpreter searches for the module in the
following sequences:
1. The current directory.
2. If the module isn't found, Python then searches each directory in the shell
variable PYTHONPATH.
3.If all else fails, Python checks the default path. On UNIX, this default path is
normally /usr/local/lib/python/.

The module search path is stored in the system module sys as the sys.path
variable. The sys.path variable contains the current directory, PYTHONPATH, and
the installation-dependent default.

ThePYTHONPATHVariable:L
The PYTHONPATH is an environment variable, consisting of a list of directories. The
syntax of PYTHONPATH is the same as that of the shell variable PATH.
Here is a typical PYTHONPATH from a Windows system:
set PYTHONPATH=c:\python20\lib;
And here is a typical PYTHONPATH from a UNIX system:
set PYTHONPATH=/usr/local/lib/python

Namespaces and Scoping:

Variables are names (identifiers) that map to objects. A namespace is a dictionary
of variable names (keys) and their corresponding objects (values).
A Python statement can access variables in a local namespace and in the global
namespace. If a local and a global variable have the same name, the local variable
shadows the global variable.
Each function has its own local namespace. Class methods follow the same scoping
rule as ordinary functions.
Python makes educated guesses on whether variables are local or global. It
assumes that any variable assigned a value in a function is local.
Therefore, in order to assign a value to a global variable within a function, you must
first use the global statement.
The statement global VarName tells Python that VarName is a global variable.
Python stops searching the local namespace for the variable.

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

11
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

For example, we define a variable Money in the global namespace. Within the
functionMoney, we assign Money a value, therefore Python assumes Money as a
local variable. However, we accessed the value of the local variable Money before
setting it, so an UnboundLocalError is the result. Uncommenting the global
statement fixes the problem.
#!/usr/bin/python
Money = 2000
def AddMoney():
# Uncomment the following line to fix the code:
# global Money
Money = Money + 1
print Money
AddMoney()
print Money

The dir( ) Function:

The dir() built-in function returns a sorted list of strings containing the names
defined by a module.
The list contains the names of all the modules, variables and functions that are
defined in a module. Following is a simple example:
#!/usr/bin/python
# Import built-in module math
import math
content = dir(math)
print content;
When the above code is executed, it produces the following result:
['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan',
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp',
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',
'sqrt', 'tan', 'tanh']
Here, the special string variable __name__ is the module's name, and __file__ is
the filename from which the module was loaded.

The globals( )and locals() Functions:

The globals() and locals() functions can be used to return the names in the global
and local namespaces depending on the location from where they are called.
1. If locals() is called from within a function, it will return all the names that can be
accessed locally from that function.
2. If globals() is called from within a function, it will return all the names that can
be accessed globally from that function.

The return type of both these functions is dictionary. Therefore, names can be
extracted using the keys() function.

The reload() Function:

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

12
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

When the module is imported into a script, the code in the top-level portion of a
module is executed only once.
Therefore, if you want to reexecute the top-level code in a module, you can use the
reload()function. The reload() function imports a previously imported module again.
The syntax of the reload() function is this:
reload(module_name)
Here, module_name is the name of the module you want to reload and not the
string containing the module name. For example, to reload hello module, do the
following:
reload(hello)

Packages in Python

Creating packages:
Packages are namespaces which contain multiple packages and modules themselves.
They are simply directories, but Each package in Python is a directory
which MUST contain a special file called __init__.py. This file can be empty, and it
indicates that the directory it contains is a Python package, so it can be imported the
same way a module can be imported.

If we create a directory called foo, which marks the package name, we can then create
a module inside that package called  bar. We also must not forget to add
the __init__.py file inside the foo directory.

To use the module bar, we can import it in two ways:

import foo.bar or from foo import bar

In the first method, we must use the foo prefix whenever we access the module bar. In
the second method, we don't, because we import the module to our module's
namespace.

The __init__.py file can also decide which modules the package exports as the API,
while keeping other modules internal, by overriding the __all__ variable, like so:
__init__.py:
__all__ = ["bar"]

Here we need to print an alphabetically sorted list of all functions in the re module,

which contain the word find.
import re

# Your code goes here

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

13
ADVANCED PYTHON PROGRAMMING B.TECH III-II CREC

Output: ['findall', 'finditer']

Using Python Packages :

A package is a hierarchical file directory structure that defines a single Python
application environment that consists of modules and subpackages and sub-
subpackages, and so on.
Consider a file Pots.py available in Phone directory. This file has following line of
source code:
#!/usr/bin/python
def Pots():
print "I'm Pots Phone"
Similar way, we have another two files having different functions with the same
name as above:
1. Phone/Isdn.py file having function Isdn()
2. Phone/G3.py file having function G3()

Now, create one more file __init__.py in Phone directory:

Phone/__init__.py

To make all of your functions available when you've imported Phone, you need to
put explicit import statements in __init__.py as follows:
from Pots import Pots
from Isdn import Isdn
from G3 import G3
After you add these lines to __init__.py, you have all of these classes available
when you import the Phone package.
#!/usr/bin/python
# Now import your Phone Package.
import Phone
Phone.Pots()
Phone.Isdn()
Phone.G3()
When the above code is executed, it produces the following result:
I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone
The above example contains a single functions in each file, but we can keep
multiple functions in our files. we can also define different Python classes in those
files and then you can create our packages out of those classes.

G. SESHADRI SEKHAR, Asst.Professor, Dept. of CSE

14