Padmashri Dr.

Vitthalrao Vikhe Patil Institute Of Technology & Engineering (Polytechnic ), Pravaranagar

PWP-22616,CM

Unit IV
Python Functions, Modules and Packages

h
4a. Use the Python standard functions for the given problem.

ik
ha
4b Develop relevant user defined functions for the given problem using
Python code.
.S
4c. Write Python module for the given problem.
.A

4d. Write Python package for the given problem.

.A
of
Pr

1
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology & Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

Python Functions
 Functions are the most important aspect of an application. A function can be defined as
the organized block of reusable code which can be called whenever required.
 Python allows us to divide a large program into the basic building blocks known as
function. The function contains the set of programming statements enclosed by {}.
 A function can be called multiple times to provide reusability and modularity to the
python program.
 In other words, we can say that the collection of functions creates a program. The
function is also known as procedure or subroutine in other programming languages.
 Python provide us various inbuilt functions like range() or print(). Although, the user can
create its functions which can be called user-defined functions.

Advantage of Functions in Python

h
There are the following advantages of Python functions.

ik
 By using functions, we can avoid rewriting same logic/code again and again in a
program.

ha
 We can call python functions any number of times in a program and from any
place in a program.
.S
 We can track a large python program easily when it is divided into multiple
functions.
.A

 Reusability is the main achievement of python functions.

 However, Function calling is always overhead in a python program.
.A

Creating a function
 In python, we can use def keyword to define the function.
of

 The syntax to define a function in python is given below.

def my_function():
Pr

function-suite
return <expression>
 The function block is started with the colon (:) and all the same level block statements
remain at the same indentation.
 A function can accept any number of parameters that must be the same in the definition
and function calling.

Function calling
 In python, a function must be defined before the function calling otherwise the python
interpreter gives an error.
 Once the function is defined, we can call it from another function or the python prompt.
To call the function, use the function name followed by the parentheses.

2
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

 A simple function that prints the message "Hello Word" is given below.

def hello_world():
print("hello world")

hello_world()
Output:
hello world

Parameters in function
 The information into the functions can be passed as the parameters.
 The parameters are specified in the parentheses. We can give any number of parameters,
but we have to separate them with a comma.
 Consider the following example which contains a function that accepts a string as the

h
parameter and prints it.

ik
 Example 1

ha
#defining the function
def func (name):
.S
print("Hi ",name);

#calling the function

.A

func("Ash")
 Example 2
.A

#python function to calculate the sum of two variables

#defining the function
of

def sum (a,b):

return a+b;
Pr

#taking values from the user

a = int(input("Enter a: "))
b = int(input("Enter b: "))

#printing the sum of a and b

print("Sum = ",sum(a,b))
Output:
Enter a: 10
Enter b: 20
Sum = 30
Call by reference in Python

3
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

 In python, all the functions are called by reference, i.e., all the changes made to the
reference inside the function revert back to the original value referred by the reference.
 However, there is an exception in the case of mutable objects since the changes made to
the mutable objects like string do not revert to the original string rather, a new string
object is made, and therefore the two different objects are printed.
 Example 1 Passing Immutable Object (List)
#defining the function
def change_list(list1):
list1.append(20);
list1.append(30);
print("list inside function = ",list1)

#defining the list

h
list1 = [10,30,40,50]

ik
#calling the function

ha
change_list(list1);
print("list outside function = ",list1);
.S
Output:

list inside function = [10, 30, 40, 50, 20, 30]

.A

list outside function = [10, 30, 40, 50, 20, 30]

.A

 Example 2 Passing Mutable Object (String)

#defining the function
def change_string (str):
of

str = str + " Hows you";

Pr

print("printing the string inside function :",str);

string1 = "Hi I am there"

#calling the function

change_string(string1)

print("printing the string outside function :",string1)

Output:

printing the string inside function : Hi I am there Hows you

printing the string outside function : Hi I am there

4
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

Types of arguments
There may be several types of arguments which can be passed at the time of function
calling.
1. Required arguments
2. Keyword arguments
3. Default arguments
4. Variable-length arguments
1. Required Arguments
 We can provide the arguments at the time of function calling.
 As far as the required arguments are concerned, these are the arguments which are
required to be passed at the time of function calling with the exact match of their
positions in the function call and function definition.
 If either of the arguments is not provided in the function call, or the position of the

h
arguments is changed, then the python interpreter will show the error.
 Consider the following example.

ik
#the argument name is the required argument to the function func

ha
def func(name):
message = "Hi "+name;
.S
return message;
name = input("Enter the name?")
print(func(name))
.A

Output:
Enter the name?Ash
.A

Hi Ash
 Example 2
of

#the function simple_interest accepts three arguments and returns the simple
interest accordingly
Pr

def simple_interest(p,t,r):
return (p*t*r)/100
p = float(input("Enter the principle amount? "))
r = float(input("Enter the rate of interest? "))
t = float(input("Enter the time in years? "))
print("Simple Interest: ",simple_interest(p,r,t))
Output:

Enter the principle amount? 10000

Enter the rate of interest? 5
Enter the time in years? 2
Simple Interest: 1000.0

5
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

 Example 3
#the function calculate returns the sum of two arguments a and b
def calculate(a,b):
return a+b
calculate(10) # this causes an error as we are missing a required arguments b.
Output:

TypeError: calculate() missing 1 required positional argument: 'b'

Keyword arguments

 Python allows us to call the function with the keyword arguments. This kind of function
call will enable us to pass the arguments in the random order.
 The name of the arguments is treated as the keywords and matched in the function calling

h
and definition. If the same match is found, the values of the arguments are copied in the
function definition.

ik
 Consider the following example.

ha
#function func is called with the name and message as the keyword arguments
.S
def func(name,message):
print("printing the message with",name,"and ",message)
func(name = "Ash",message="hello") #name and message is copied with the
.A

values John and hello respectively

Output:
.A

printing the message with Ash and hello

 Example 2 providing the values in different order at the calling
of

#The function simple_interest(p, t, r) is called with the keyword arguments the

order of arguments doesn't matter in this case
Pr

def simple_interest(p,t,r):
return (p*t*r)/100
print("Simple Interest: ",simple_interest(t=10,r=10,p=1900))
Output:
Simple Interest: 1900.0
 If we provide the different name of arguments at the time of function call, an error will be
thrown.
 Consider the following example.

#The function simple_interest(p, t, r) is called with the keyword arguments.

def simple_interest(p,t,r):
return (p*t*r)/100

6
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

print("Simple Interest: ",simple_interest(time=10,rate=10,principle=1900))

Output:
TypeError: simple_interest() got an unexpected keyword argument 'time'
 The python allows us to provide the mix of the required arguments and keyword
arguments at the time of function call. However, the required argument must not be given
after the keyword argument, i.e., once the keyword argument is encountered in the
function call, the following arguments must also be the keyword arguments.
 Consider the following example.
def func(name1,message,name2):
print("printing the message with",name1,",",message,",and",name2)
func("Ash",message="hello",name2="Pra") #the first argument is not the
keyword argument
Output:
printing the message with Ash , hello ,and Pra

h
 The following example will cause an error due to an in-proper mix of keyword and

ik
required arguments being passed in the function call.

ha
def func(name1,message,name2):
print("printing the message with",name1,",",message,",and",name2)
.S
func("Ash",message="hello","Pra")
Output:
SyntaxError: positional argument follows keyword argument
.A

Default Arguments
.A

 Python allows us to initialize the arguments at the function definition. If the value of any
of the argument is not provided at the time of function call, then that argument can be
initialized with the value given in the definition even if the argument is not specified at
of

the function call.

Pr

 Example 1
def printme(name,age=35):
print("My name is",name,"and age is",age)
printme(name = "Ash") #the variable age is not passed into the function however
the default value of age is considered in the function
Output:
My name is Ash and age is 35
 Example 2
def printme(name,age=35):
print("My name is",name,"and age is",age)
printme(name = "Ash") #the variable age is not passed into the function however
the default value of age is considered in the function

7
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

printme(age = 35,name="Pra") #the value of age is overwritten here, 10 will be

printed as age
Output:
My name is Ash and age is 35
My name is Pra and age is 35

Variable length Arguments

 In the large projects, sometimes we may not know the number of arguments to be passed
in advance. In such cases, Python provides us the flexibility to provide the comma
separated values which are internally treated as tuples at the function call.
 However, at the function definition, we have to define the variable with * (star) as
*<variable - name >.
 Consider the following example.

h
def printme(*names):
print("type of passed argument is ",type(names))

ik
print("printing the passed arguments...")

ha
for name in names:
print(name)
.S
printme("Ash","Pramod","sachin","rakesh")
Output:
.A

type of passed argument is <class 'tuple'>

printing the passed arguments...
.A

Ash
Pramod
sachin
of

rakesh
Pr

Scope of variables
 The scopes of the variables depend upon the location where the variable is being
declared. The variable declared in one part of the program may not be accessible to the
other parts.
 In python, the variables are defined with the two types of scopes.
i. Global variables
ii. Local variables
 The variable defined outside any function is known to have a global scope whereas the
variable defined inside a function is known to have a local scope.
 Consider the following example.
def print_message():

8
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

message = "hello !! I am going to print a message." # the variable message is

local to the function itself
print(message)
print_message()
print(message) # this will cause an error since a local variable cannot be
accessible here.
Output:

hello !! I am going to print a message.

File "/root/PycharmProjects/PythonTest/Test1.py", line 5, in
print(message)
NameError: name 'message' is not defined
 Example 2
def calculate(*args):

h
sum=0

ik
for arg in args:

ha
sum = sum +arg
print("The sum is",sum)
.S
sum=0
calculate(10,20,30) #60 will be printed as the sum
print("Value of sum outside the function:",sum) # 0 will be printed
.A

Output:
.A

The sum is 60
Value of sum outside the function: 0
of
Pr

9
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

Python Built in Functions

 Python has a set of built-in functions.
Function Syntax Description Example Output
abs() abs(n) Returns the absolute x = abs(3+5j) 5.8309518948453
value of a number print(x) 01

bin() bin(n) Returns the binary x = bin(36) 0b100100

version of a number print(x)
enumerate enumerate(iterable, Takes a collection x = ('apple', 'banana', [(0, 'apple'),
() start) (e.g. a tuple) and 'cherry') (1, 'banana'),
returns it as an y = enumerate(x) (2, 'cherry')]
enumerate object print(list(y))

h
input() input(prompt) Allowing user input print('Enter Enter your name:

ik
your name:') Asharf
x = input() Hello, Asharf

ha
print('Hello,
' + x)
int() int(value, base) Returns an integer x = int(3.5) 3
.S
number
print(x)
ord(character)
.A

ord() Convert an integer x = ord("h") 104

representing the
Unicode of the print(x)
.A

specified character
pow() pow(x, y) Returns the value of x x = pow(4, 3) 64
to the power of y
of

print(x)
Pr

10
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

Python Modules
 A python module can be defined as a python program file which contains a python code
including python functions, class, or variables.
 In other words, we can say that our python code file saved with the extension (.py) is
treated as the module. We may have a runnable code inside the python module.
 Modules in Python provides us the flexibility to organize the code in a logical way.
 To use the functionality of one module into another, we must have to import the specific
module.
 Example
 In this example, we will create a module named as file.py which contains a function func

h
that contains a code to print some message on the console.

ik
 Let's create the module named as file.py.

ha
#displayMsg prints a message to the name being passed.
def displayMsg(name)
.S
print("Hi "+name);
 Here, we need to include this module into our main module to call the method
.A

displayMsg() defined in the module named file.


.A

We need to load the module in our python code to use its functionality.
 Python provides two types of statements as defined below.
of

1. The import statement

2. The from-import statement
Pr

1. The import statement

 The import statement is used to import all the functionality of one module into another.
Here, we must notice that we can use the functionality of any python source file by
importing that file as the module into another python source file.
 We can import multiple modules with a single import statement, but a module is loaded
once regardless of the number of times, it has been imported into our file.
 The syntax to use the import statement is given below.
import module1,module2,........ module n

11
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

 Hence, if we need to call the function displayMsg() defined in the file file.py, we have to
import that file as a module into our module as shown in the example below.
 Example:
import file;
name = input("Enter the name?")
file.displayMsg(name)
 Output:
Enter the name?Asharf
Hi Asharf
2. The from-import statement

h
 Instead of importing the whole module into the namespace, python provides the

ik
flexibility to import only the specific attributes of a module. This can be done by using

ha
from import statement. The syntax to use the from-import statement is given below.
from < module-name> import <name 1>, <name 2>..,<name n>
.S
 Consider the following module named as calculation which contains three functions as
summation, multiplication, and divide.
.A

 calculation.py:
#place the code in the calculation.py
.A

def summation(a,b):
return a+b
of

def multiplication(a,b):
Pr

return a*b;
def divide(a,b):
return a/b;
 Main.py:
from calculation import summation
#it will import only the summation() from calculation.py
a = int(input("Enter the first number"))
b = int(input("Enter the second number"))
print("Sum = ",summation(a,b)) #we do not need to specify the module name while
accessing summation()

12
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

 Output:
Enter the first number10
Enter the second number20
Sum = 30
 The from...import statement is always better to use if we know the attributes to be
imported from the module in advance. It doesn't let our code to be heavier. We can also
import all the attributes from a module by using *.
 Consider the following syntax.
from <module> import *
Renaming a module


h
Python provides us the flexibility to import some module with a specific name so that we

ik
can use this name to use that module in our python source file.

ha
 The syntax to rename a module is given below.
import <module-name> as <specific-name>
.S
 Example
#the module calculation of previous example is imported in this example as cal.
.A

import calculation as cal;

a = int(input("Enter a?"));
.A

b = int(input("Enter b?"));
print("Sum = ",cal.summation(a,b))
of

 Output:
Pr

Enter a?10
Enter b?20
Sum = 30

13
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

Python Package
 As our application program grows larger in size with a lot of modules, we place similar
modules in one package and different modules in different packages.
Writing packages
 Packages are namespaces which contain multiple packages and modules themselves.
They are simply directories, but with a twist.
 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.
 A directory must contain a file named __init__.py in order for Python to consider it as a

h
package. This file can be left empty but we generally place the initialization code for that

ik
package in this file.

ha
 Here is an example. Suppose we are developing a game, one possible organization of
packages and modules could be as shown in the figure below.
.S
.A
.A
of
Pr

14
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,CM

Importing module from a package

 We can import modules from packages using the dot (.) operator.
 For example, if want to import the start module in the above example, it is done as
follows.
import Game.Level.start
 Now if this module contains a function named select_difficulty(), we must use the full
name to reference it.
Game.Level.start.select_difficulty(2)
 If this construct seems lengthy, we can import the module without the package prefix as
follows.

h
fromGame.Levelimport start

ik
 We can now call the function simply as follows.

ha
start.select_difficulty(2)
 Yet another way of importing just the required function (or class or variable) form a
.S
module within a package would be as follows.
fromGame.Level.start import select_difficulty
.A

 Now we can directly call this function.

select_difficulty(2)
.A

 Although easier, this method is not recommended. Using the full namespace avoids
confusion and prevents two same identifier names from colliding.
of

 While importing packages, Python looks in the list of directories defined in sys.path,
Pr

similar as for module search path.

15