Padmashri Dr.

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

PWP-22616,BD

Unit IV
Python Functions, Modules and Packages

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

4b Develop relevant user defined functions for the given problem using

Python code.

4c. Write Python module for the given problem.

4d. Write Python package for the given problem.

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

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

There are the following advantages of Python functions.
∙ By using functions, we can avoid rewriting same logic/code again and again in a
program.
∙ We can call python functions any number of times in a program and from any place
in a program.
∙ We can track a large python program easily when it is divided into multiple
functions.
∙ Reusability is the main achievement of python functions.
∙ However, Function calling is always overhead in a python program.

Creating a function
∙ In python, we can use def keyword to define the function.
∙ The syntax to define a function in python is given below.
def my_function():
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.

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

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

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
parameter and prints it.
∙ Example 1
#defining the function
def func (name):
print("Hi ",name);

#calling the function

func("Abc")
∙ Example 2
#python function to calculate the sum of two variables
#defining the function
def sum (a,b):
return a+b;

#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

∙ 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.

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

∙ 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

list1 = [10,30,40,50]

#calling the function

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

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

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

∙ Example 2 Passing Mutable Object (String)

#defining the function
def change_string (str):
str = str + " Hows you";
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

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

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

∙ 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
arguments is changed, then the python interpreter will show the error.
∙ Consider the following example.
#the argument name is the required argument to the function func
def func(name):
message = "Hi "+name;
return message;
name = input("Enter the name?")
print(func(name))
Output:
Enter the name?Ash
Hi Ash
∙ Example 2
#the function simple_interest accepts three arguments and returns the simple
interest accordingly
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

∙ 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

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

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
and definition. If the same match is found, the values of the arguments are copied in the
function definition.
∙ Consider the following example.

#function func is called with the name and message as the keyword arguments
def func(name,message):
print("printing the message with",name,"and ",message)
func(name = "Ash",message="hello") #name and message is copied with the
values John and hello respectively
Output:
printing the message with Ash and hello
∙ Example 2 providing the values in different order at the calling
#The function simple_interest(p, t, r) is called with the keyword arguments the
order of arguments doesn't matter in this case
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

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:

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

printing the message with Ash , hello ,and Pra

∙ The following example will cause an error due to an in-proper mix of keyword and required
arguments being passed in the function call.
def func(name1,message,name2):
print("printing the message with",name1,",",message,",and",name2)
func("Ash",message="hello","Pra")
Output:
SyntaxError: positional argument follows keyword argument

Default Arguments
∙ 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
the function call.
∙ 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

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.
def printme(*names):
print("type of passed argument is ",type(names))
print("printing the passed arguments...")

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

for name in names:

print(name)
printme("Ash","Pramod","sachin","rakesh")
Output:

type of passed argument is <class 'tuple'>

printing the passed arguments...
Ash
Pramod
sachin
rakesh

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():

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):
sum=0
for arg in args:
sum = sum +arg
print("The sum is",sum)
sum=0
calculate(10,20,30) #60 will be printed as the sum

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

print("Value of sum outside the function:",sum) # 0 will be printed

Output:

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

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.83095189484

value of a number print(x) 53 01

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

version of a number print(x)

enumer enumerate(iterabl Takes a collection x = ('apple', [(0,

ate () e, start) (e.g. a tuple) and 'banana', 'cherry') 'apple'),
returns it as an y = enumerate(x) (1,
enumerate object print(list(y)) 'banana'),
(2,
'cherry')]

input() input(prompt) Allowing user input print('Enter Enter your

your name:') x name: Abc
= input() Hello, Abc
print('Hello,
' + x)

int() int(value, base) Returns an integer x = int(3.5) 3

number
print(x)

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

representing the
Unicode of the print(x)
specified character

pow() pow(x, y) Returns the value of x = pow(4, 3) 64

x to the power of y
print(x)

Python Modules
∙ A python module can be defined as a python program file which contains a python code
9
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

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
that contains a code to print some message on the console.
∙ Let's create the module named as file.py.
#displayMsg prints a message to the name being passed.
def displayMsg(name)
print("Hi "+name);
∙ Here, we need to include this module into our main module to call the method displayMsg()
defined in the module named file.
∙ We need to load the module in our python code to use its functionality. ∙
Python provides two types of statements as defined below.
1. The import statement
2. The from-import statement
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

∙ 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:

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

Enter the name?Abc

Hi Abc
2. The from-import statement
∙ Instead of importing the whole module into the namespace, python provides the flexibility
to import only the specific attributes of a module. This can be done by using from import
statement. The syntax to use the from-import statement is given below. from < module-
name> import <name 1>, <name 2>..,<name n>
∙ Consider the following module named as calculation which contains three functions as
summation, multiplication, and divide.
∙ calculation.py:
#place the code in the calculation.py
def summation(a,b):
return a+b
def multiplication(a,b):
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()

∙ 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.

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

from <module> import *

Renaming a module
∙ Python provides us the flexibility to import some module with a specific name so that we
can use this name to use that module in our python source file.
∙ The syntax to rename a module is given below.
import <module-name> as <specific-name>
∙ Example
#the module calculation of previous example is imported in this example as cal.
import calculation as cal;
a = int(input("Enter a?"));
b = int(input("Enter b?"));
print("Sum = ",cal.summation(a,b))
∙ Output:
Enter a?10
Enter b?20
Sum = 30

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
package. This file can be left empty but we generally place the initialization code for that
package in this file.
∙ 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.

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

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.
fromGame.Levelimport start
∙ We can now call the function simply as follows.
start.select_difficulty(2)
∙ Yet another way of importing just the required function (or class or variable) form a module
within a package would be as follows.
fromGame.Level.start import select_difficulty
∙ Now we can directly call this function.
select_difficulty(2)
∙ Although easier, this method is not recommended. Using the full namespace avoids
confusion and prevents two same identifier names from colliding.
∙ While importing packages, Python looks in the list of directories defined in sys.path, similar
as for module search path.15
13