Unit 4: Python Functions modules and Packages

C22616.d Develop functions for given problem.

Introduction
Functions, modules and packages are all constructs in Python programming that promote code
modularization. The modularization (modular programming) refers to the process of breaking a
large programming task into separate, smaller, more manageable subtasks or modules.

Function
Is a block of organized, reusable code that is used to perform a single, related action/operation
Python has excellent support for functions.
A function can be defined as the organized block of reusable code which can be called whenever
required. A function is a piece of code that performs a particular task.
A function is a block of code which only runs when it is called. Python gives us many built-in
functions like print() but we can also create our own functions called as user-defined functions.

Module
Python programming allows us to logically organize the python code. A module is a single
source code file, The module in Python have the .py file extension. The name of the module will
be the name of the file.
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.

Packages
Package allow us to create a hierarchical file directory structure of modules,For example, my
module.modl stands for a module mod1, in the package mymodule.
A Python package is a collection of modules which have a common purpose. In short, modules
are grouped together to forms packages.

Use Of Python Built-In Functions

Functions are the self-contained block of statements that act like a program that performs
specific task.
The Python interpreter has a number of functions that are always available for use. These
functions are called built-in functions. For example, print() function prints the given object to the
standard output device (screen) or to the text stream file.
Python built-in (library) functions can be used to perform specific tasks. Some of these functions
comes in category of mathematical functions and some are called type conversion functions and
so on.
Data Type Conversion Functions
Sometimes its necessary to perform conversions between the built-in types. To convert between
types we simply use the type name as a function,
In addition, several built-in functions are supplied to perform special kinds of conversions. All of
these functions return a new object representing the converted value.
Python defines type conversion functions to directly convert one data type to another.
 Unit 4: Python Functions modules and Packages
Data conversion in Python can happen in following two ways:
1. Either we tell the compiler to convert a data type to some other type explicitly, and/or
2. The compiler understands this by itself and does it for us.

1. Python Implicit Data Type Conversion:

Implicit conversion is when data type conversion takes place either during compilation or during run
time and is handled directly by Python.

Example: For implicit data type conversion. >>>a=10

>>>b=25.34
>>> sum=a+b
>>> print sum
35.34

In the above example, an int value a is added to float value b, and the result is automatically converted to
a float value sum without having to tell the compiler. This is the implicit data conversion.
In implicit data conversion the lowest priority data type always get converted to the highest priority data
type that is available in the source code.
data type conversion function with their description is given below

Sr.
Function Description Example
No.
Converts x to an integer. base x=int('1100',base=2)=12
1 int(x [,base]) specifies the base if x is a string. x=int( '1234’,base=8)=668

Converts x to a long integer. base x=long('123'base=8)=83L

2 long(x [, base]) specifies the base if x is a string. x=long(‘11',base=16)=17L

Converts x to a floating x=float ('123.45 ')=123.45

3 float (x)
point number.
complex(real[,imag]
4 Creates a complex number. x=complex(1,2) = (1+2j)
)
Converts object x to a string x=str(10) = ‘10’
5 str(x)
representation.
Converts object x to x=repr(3) = 3
6 repr(x) an expression string.
Evaluates a string and returns x=eval( '1+2' ) = 3
7 eval(str)
an object.
Converts s to a tuple. x=tuple('123') =('1','2','3')
8 tuple(s)
x=tuple([123]) = (123,)
Converts s to a list. x=list(' 123') =['1','2','3' ]
9 list(s) x=list( [' 12' ] =[*12' ]
Converts s to a set. x=set (‘Python')={'y','t','o','P',
10 set(s)
'n','h’}
 Unit 4: Python Functions modules and Packages
Creates a dictionary. d must dict={ ‘id ' : '11 ' , ' name' : ' asha ' }
11 dict(d) be print (dirt)
a sequence of (key, value) tuples. { ' id ' : 11 ' ,' name ' : ' asha' }
12 chr(x) Converts an integer to a character. x=chr(65) = 'A'

Converts an integer to a Unicode x=unichr(65) =uA'

13 unichr(x)
character.

Formatting Numbers and Strings:

The format() function formats a specified value into a specified format.
Syntax: format(value, -Format)
Example: For string and number formation >» x=12.345
>>>format(x,".2f")
'12.35'
>>>
Parameter Values:

Sr. The Format we want to Format the Value

Form Into
Example
No at
.
1 < Left aligns the result (within the available >>> x=10.23456
space). >>> format(x,"<10.2-f")
'10.23
2 > Right aligns the result (within the available >>>x=10.23456
space). >>> format(x,">10.2f")
10.23'

Center aligns the result(within the available >>>x=10 . 23456

3 ,, space).
>>>format(x„"A10.2f")
‘10.23'
Use a sign to indicate if the result is positive or >>> x=123
negative. >>> format(x,'+") '+123'
4 + >»x=-123
>» format(x,"4") '-123'
Use a sign for negative values only. >>> x=123
5 - >>>format(x,"+")
>>>' -123'
i Use a comma as a thousand separator. >>> x=10000000
6 >» format(x,",")
'10,000,000'
 Unit 4: Python Functions modules and Packages
Use a underscore as a thousand separator. >>> x=100000
7 - >>>format(x,"_”)
'100_000 '
>>> x=10
8 b Binary format. >>>format(x,"b")
'1010'
>>> x=10
Converts the value into the corresponding
9 c >>> format (x, “c”)
unicode character.
‘\n’
>>> x=10
d
10 Decimal format. >>> format(x,"d")
‘10’
>>> x=10
11 e Scientific format, with a lower case e. >>>format(x,"e")
'1.000000e+01'
>>> x=10
12 E Scientific format, with an upper case E. >>>format(x,"E")
'1.000000E+01'
Fix point number format. >>> x=10
13. f >>> forma-t(x,f")
'10.000000'
g General format. >>>x.10
>>>format (x, "g" )
14
'10.
Octal format. >>>x=10
15 o >>> format ( x, "o" )
' 12 '
Hex format, lower case. >>> x-10
16 x >>> format (x, "x")
'a'
Hex format, upper case. >>> x=10
17 x >>> format(x,"X")
'A'
Percentage format. >>>x=100
18 % >>> format (x, "%")
' 10000.000000% '
String with width 10 in left justification. >>> x="hello"
19 >10s >>> format(x,">105")
hello '
String with width 10 in right justification. >>>x="hello"
20 <10s >>>format (x, "<10s")
'hello ‘

Built-In Mathematical Functions

 Unit 4: Python Functions modules and Packages
Function can be described as a piece of code that may or may not take some value(s) as
input, process it, and then finally may or may not return any value as output.
Python's math module is used to solve problems related to mathematical calculations.
Some functions are directly executed for math functions we need to import math module first.
In python, there are two types of pre-defined functions.

Built-In Functions (Mathematical):

These are the functions which don’t require any external code file/Modules! Library Files. These
are a part of the python core and are just built within the Python compiler hence there is no need
of importing these modules/libraries in our code.
Following table shows some of in built mathematical functions:

Sr
. Function
Description Example
N s
o.
1 min() Returns smallest value among supplied >>> min(20, 10, 30)
arguments. 10
2 max() Returns largest value among supplied > » max(20, 10, 30)
arguments. 30
3 pow( ) The pow() function returns the value of x to the power >>> pow( 2., 3) 8
of y (xy). If a third parameter is present, it returns x to >>> pow(2,3,2) 0
the power of y, modulus z.
4 round() The round() function returns a floating point number that >>> round (10.2345) 10
isa rounded version of the specified number, with the >>> round(5.76543)
specified number of decimals. The default number of decimals is 6
0, meaning that the function will return the >>>round(5.76543,2)
nearest integer. 5.77
5 abs() Absolute function, also known as Modulus (not to >>> abs( -5) 5
be confused with Modulo), returns the non-negative value >>> abs(5) 5
of the argument value.

2. Built-In Functions (Math Module):

The second type of functions require some external files(modules) in order to be used. The
process of using these external files in our code is called importing. So all we have to do is
import the file into our code and use the functions which are already written in that file.
Following table shows some of in built mathematical functions of Math Module
Sr. Functio
Description
No. ns Example
celi() This function returns the smallest > >> math. ceil(2.3)
Integral value greater than the number. 3
1
If number is already integer, same number is
returned.
 Unit 4: Python Functions modules and Packages
floor() This function returns the greatest integral >>> math.floor(2.3)
2 value smaller than the number. If number is 2
already integer, same number is returned.
cos() This function returns the cosine of >>>math.cos(3)
value -0.9899924966004454
3 passed as argument. The value passed in this >>>math.cos(-3)
function should be in radians. -0.9899924966004454
_ >>>math.cos(0) 1.0
cosh() Returns the hyperbolic cosine of x. >>> print(math.cosh(3))
4 10.067661995777765

copysign Return x with the sign of y. On a platform >>>math . copysign(10, -12)

5 () that supports signed zeros, copysign(1.0, - -10.o
0.0) returns -1,0.
exp( ) The method expo returns returns exponential >>> math . exp(1 )
6 ofx. 2.718281828459045 >»

fats ( ) This function will return an absolute or >>>math.fabs(10)

positive value. 10.0
7
>>> math.fabs(-20)
20.0
factorial( Returns the factorial of x, >>> math.factorial(5)
8 ) 120

fmod() This function returns x % y. >>> math.fmod(50,10) 0.0

>>>math.fmod(50,20) 10.0
9

This function is used to compute the natural >>>print(math.log(14) )

log(a,
10 logarithm (Base e) of a, 2.6390573296152584
(Base))
This function is used to compute >>> print(math.log2(14) )
the logarithm base 2 of a. Displays more 3.807354922057604
11 log2(a)
accurate result than logfa,2).

This function is used to compute the >>> print(math.1og10(14))

logarithm base 10 of a. Displays more 1.146128035678238
12 log10(a)
accurate result than log(a,10).

The method sqrto returns the square root of x >>> math.sqrt(100)

for x > 0. 10.0
13 sqrt() >>>math.sqrt(5)
2.23606797749979

14 trunc() This function returns the truncated integer of >>> math.trunc(3.354)

x. 3
 Unit 4: Python Functions modules and Packages

User Defined Function

Function in python is self contained program that performs some particular tasks.Once, a
function is created by the programmer for a specific task, this function can be called anytime to perform
that task.
Python gives us many built-in functions like print°, len() etc. but we can also create our own functions.
These functions are called user-defined functions.
User defined function are the self-contained block of statements created by users according to their
requirements.
A user-defined function is a block of related code statements that are organized to achieve a single
related action or task, A key objective of the concept of the user-defined function is to encourage
modularity and enable reusability of code.

Function Defination
Function definition is a block where the statements inside the function body are written. Functions allow
us to define a reusable block of code that can be used repeatedly in a program. Syntax;

def function_name(parametes):
"function_docstring"
function_statements
return [expression]

Defining Function:
• 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. We 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
• The basic syntax for a Python function definition is explained in Fig. 4.2.
 Unit 4: Python Functions modules and Packages
Function Calling
• The def statement only creates a function but does not call it. After the def has run, we can call (run)
the function by adding parentheses after the function's name. Example: For calling a function.

>>>def square(x): # function definition

print(x*x)

a=4
>>> square(a) # function call
16
>>>

Concept of Actual and Formal Parameters:

Actual Parameters:
• The parameters used in the function call are called actual parameters. These are the actual values that
are passed to the function, The actual parameters may be in the form of constant values or variables.
• The data types of actual parameters must match with the corresponding data types of formal
parameters (variables) in the function definition
They are used in the function call. They are actual values that are passed to the function definition
through the function call.
They can be constant values or variable names (such as local or global).

Formal Parameters:
• The parameters used in the header of function definition are called formal parameters of the function.
These parameters are used to receive values from the calling function.
They are used in the function header.
They are used to receive the values that are passed to the function through function call.
They are treated as local variables of a function in which they are used in the function header. Example:
For actual and formal parameters.

>>> def cube(x): # formal parameters

return x*x*x

>> result = cube(7) # actual parameters

>>> print(result)
27

Call by object reference

• Most programming languages have a formal mechanism for determining if a parameter receives a copy
of the argument (call by value) or a reference to the argument (call by name or call by reference) but
Python uses a mechanism, which is known as "Call-by-Object/Call by Object Reference/Call by
Sharing".

Example:
>>>def increment(n):
n=n+1
 Unit 4: Python Functions modules and Packages
>>> a=3
> >> increment(3)
>> print(a)
3
• when we pass a to increment(n) the function as local variable n referred to the same object.

• When control comes to n =n+1 as integer is immutable, by definition we are not able to modify the
object's value to 4 in place: we must create a new object with the value 4, We may visualize it like
below:

• All this time, the variable a continues to refer to the object with the value 3, since we did not change
the reference:

• We can still "modify" immutable objects by capturing the return of the function.

>>> def increment(n):

n=n+1
return n
>>> a=3
>>> a=increment(a)
>>> print(a)
4

Advantages of User-Defined Functions:

 Unit 4: Python Functions modules and Packages
1. User-defined functions help to decompose a large program into small segments which makes program
easy to understand, maintain and debug.
2. By using functions, we can avoid rewriting same logic/code again and again in a program.
3. We can call python functions any number of times in a program and from any place in a program.
4. We can track a large python program easily when it is divided into multiple functions.
5. Reusability is the main achievement of Python functions.
6. Functions in Python reduces the overall size of the program.

Function Arguments
• Many build in functions need arguments to be passed with them. Many build in functions require two
or more arguments. The value of the argument is always assigned to a variable known as parameter.
• There are four types of arguments using which can be called are

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

1. 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.
Example
For required arguments

>>>def display(str):
“this print a string”
Print(str)
Return
>>>display( “hello”)
hello

2. Keyword Arguments
With keyword arguments in python, we can change the order of passing the arguments without any
consequences.
Let’s take a function to divide two numbers, and return the quotient.

>>> def divide(a,b):

return a/b
>>> divide(3,2)
Output
1.5
We can call this function with arguments in any order, as long as we specify which value goes into what.

>>> divide(a=1,b=2.0)
Output
0.5
 Unit 4: Python Functions modules and Packages
>>> divide(b=2.0,a=1)
Output
0.5

3. Default Argument
Python Program arguments can have default values. We assign a default value to an argument using the
assignment operator in python(=).
When we call a function without a value for an argument, its default value (as mentioned) is used.
>>> def greeting(name=”user”):
print("Hello, {name}")

>>> greeting('Ayushi')
Output
Hello, Ayushi
When we call greeting() without an argument, the name takes on its default value- ‘User’.

>>> greeting()

Output

Hello, User

4.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 function_name([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 −

Example:

def printinfo( arg1, *vartuple ):

"This prints a variable passed arguments"
print ("Output is: ")
print (arg1)
for var in vartuple:
print var
 Unit 4: Python Functions modules and Packages
return;

printinfo( 70, 60,50,90)

Output is:
70
60
50
90

Return Statement
The return statement is used to exit a function. The return statement is used to return a value from
the function. A return statement with no arguments is the same as return None.

Example1:

def sum( arg1, arg2 ):

# Add both the parameters and return them."
total = arg1 + arg2
print "Inside the function : ", total
return total;

# 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

Fruitful functions are functions which returns value.

void functions are functions which do not returns value.

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
 Unit 4: Python Functions modules and Packages

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.

Following is a simple example −

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

total=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

BASIS FOR
LOCAL VARIABLE GLOBAL VARIABLE
COMPARISON
Declaration Variables are declared inside a Variables are declared outside any
function. function.
Scope Within a function, inside which Throughout the program.
they are declared.
Value Uninitialized local variable result Uninitialized global variable stores
in storage of the garbage value. zero by default.
 Unit 4: Python Functions modules and Packages
Access Accessed only by the statements, Accessed by any statement in the
inside a function in which they entire program.
are declared.
Data sharing Not provided Facilitated
Life Created when the function block Remain in existence for the entire time
is entered and destroyed upon your program is executing.
exit.
Storage Local variables are stored on the Stored on a fixed location decided by a
stack unless specified. compiler.
Parameter Necessarily required Not required for global variables.
passing
Changes in a Any modification implied in a The changes applied in the global
variable value local variable does not affect the variable of a function reflect the
other functions of the program. changes in the whole program.

Recursive function

Python also accepts function recursion, which means a defined function can call itself.
Recursion is a common mathematical and programming concept. It means that a function calls itself.
This has the benefit of meaning that you can loop through data to reach a result.
Example
Factorial of a number specifies a product of all integers from 1 to that number. It is defined by the
symbol explanation mark (!).
For example: The factorial of 5 is denoted as 5! = 1*2*3*4*5 = 120.

See this example:

def recur_factorial(n):
if n == 1:
return n
else:
return n*recur_factorial(n-1)
# take input from the user
num = int(input("Enter a number: "))
# check is the number is negative
if num < 0:
print("Sorry, factorial does not exist for negative numbers")
elif num == 0:
print("The factorial of 0 is 1")
else:
print("The factorial of",num,"is",recur_factorial(num))

Advantages of using recursion

 Unit 4: Python Functions modules and Packages
A complicated function can be split down into smaller sub-problems utilizing recursion.
Sequence creation is simpler through recursion than utilizing any nested iteration.
Recursive functions makes the code look simple and effective.

Disadvantages of using recursion

A lot of memory and time is taken through recursive calls which makes it expensive for use.
Recursive functions are challenging to debug.
The reasoning behind recursion can sometimes be tough to think through.
Syntax:
def func(): <--
|
| (recursive call)
|
func() ----

Example
To print the fibonacci series upto n_terms

A Fibonacci sequence is the integer sequence of 0, 1, 1, 2, 3, 5, 8....

Output:

def recursive_fibonacci(n):
if n <= 1:
return n
else:
return(recursive_fibonacci(n-1) + recursive_fibonacci(n-2))

n_terms = 10

# check if the number of terms is valid

if n_terms <= 0:
print("Invalid input ! Please input a positive value")
else:
print("Fibonacci series:")
for i in range(n_terms):
print(recursive_fibonacci(i))
Fibonacci series:
0
1
1
2
3
5
8
13
 Unit 4: Python Functions modules and Packages
21
34
Example: Programs to convert U.S. dollars to Indian rupees.
def dol_rup():
dollars = float(input(“Please enter dollars:”))
rupees = dollars * 70
print("Dollars: ",dollars)
print("Rupees: ",rupees)

def euro_rup():
euro= float(input("Please enter euro:"))
rupees = euro * 79.30
print("Euro: IT",euro)
print("Rupees: ",rupees)

def menu():
print("1: Doller to Rupees")
print("2: Euro to Rupees")
print("3: Exit")
choice=int(input("Enter your choice:"))
if choice==1:
dol_rup()
if choice==2:
euro_rup()
if choice==3:
print("Good bye!")
menu()
Output:
1: Doller to Rupees
2: Euro to Rupees
3: Exit Enter your choice:
1 Please enter dollars:75
Dollars: 75.0
Rupees: 525e.0

Modules
Modules are primarily the (.py) files which contain Python programming code defining functions, class,
variables, etc. with a suffix .py appended in its file name. A file containing .py python code is called a
module.
If we want to write a longer program, we can use file where we can do editing, correction. This is known
as creating a script. As the program gets longer, we may want to split it into several files for easier
maintenance.
We may also want to use a function that we have written in several programs without copying its
definition into each program.
In Python we can 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.
 Unit 4: Python Functions modules and Packages
Writing Module
Writing a module means simply creating a file which can contains python definitions and statements,
The file name is the module name with the extension ,py.
To include module in a file, use import statement.
Follow the following steps to create modules:
1. Create a first file as a python program with extension as .py. This is your module file where we
can write a function which perform some task.
2. Create a second file in the same directory called main file where we can import the module to
the top of the file and call the function.
3. Second file needs to be in the same directory so that Python knows where to find the module
since it's not a built-in module.

Example: For creating a module.

Type the following code and save it as pl.py.

def add(a, h) :
“This function adds two numbers and return the result"
result =a + b
return result
def sub(a, b)
“This function substract two numbers and return the result"
result =a - b
return result
def mul(a, b):
"This function multiply two numbers and return the result"
result = a * b
return result
def div(a, b):
“This function divide two numbers and return the result"
result - a / b
return result

Importing module
Import the definitions inside a module:

import p1
print("Addition=",pl.add(10,20))
print("Subtraction=”,pl.sub(10,20))
print("Multiplication-" ,p1.mul(10,20))
print("division=" ,p1.div(10,20))

Output:
Addition= 30
Subtraction= -10
Multiplication= 200
division- 0.5
 Unit 4: Python Functions modules and Packages
Importing module
Import statement is used to imports a specific module by using its name. Import statement creates a
reference to that module in the current namespace. After using import statement we can refer the things
defined in that module.
We can import the definitions inside a module to another module or the interactive interpreter in Python.
We use the import keyword to do this.
Create second file. Let p2.py in same directory where pl.py is created. Write following code in p2.py.
Import the definitions inside a module;

import p1
print(p1.add(10,20)
print(pl.sub(20,10)

Output:
30
10
Import the definitions using the interactive interpreter:
>>> import p1
>>>p1.add(10,20)
30
>>pl.sub(20,10)
10
>>>
Importing Objects From Module:
Import statement in python is similar to #include header_file in C/C++. Python modules can get access
to code from another module by importing the fileifunction using import. Python provides three
different ways to import modules.
1. From x import a.
Imports the module x, and creates references in the current namespace to all public objects defined by
that module. If we run this statement, we can simply use a plain name to refer to things defined in
module x.
We can access attribute / mehods directly without dot notation.
Example 1: Import inside a module (from x import a).
from p1 import add
print("Addition",add(10,20))
Output:
Addition= 30

Example 2: For import on interactive interpreter.

>> from math import pi
>>> pi
3.141592653589793
>> from math import sqrt
sqrt(144)
12.0
2. From x import a, b, c:
 Unit 4: Python Functions modules and Packages
Imports the module x and creates references in the current namespace to the given objects. Or we can
use a, b and c function in our program.

Example 1: Import inside a module (from x import a, b, c).

from pl import add, sub

print("Addition=",add(10,20))
print("Subtraction=" ,sub(10,20))
Output:
Addition 30
Subtraction= -10

Example 2 For import on interactive interpreter,

>>>from math import sqrt, cell, floor

>>>sqrt(144) 12.0
> >>ceil(2.6) 3
>>>floor(2.6)
2

3. From x import *:
We can use* (asterisk) operator to import everything from the module.
Example 1: Import inside a module (from x import 1)

from p1 import *
print("Addition=",add(10,20))
print("Subtraction=” ,sub(10,20))
print("Multiplication=" ,mul(10,20))
print("division=" ,div(10,20))

output
Addition= 30
Subtraction= -10
Multiplication= 200
division. 0.5

Example 2 For import on interactive interpreter.

>>from math import

>>> cos(60)
-0.9524129804151563
>>>sin(60)
-0.3048106211022167

Aliasing module
 Unit 4: Python Functions modules and Packages
It is possible to modify the names of modules and their functions within Python by using the as
keyword.
We can make alias because we have already used the same name for something else in the program
or we may want to shorten a longer name.

Syntax:import module as another_name

Example: Create a module to define two functions. One to print Fibonacci series and other for finding
whether the given number is palindrome or not.

Step 1; Create a new file pl.py and write the following code in it and save it.
def add (a,b):
"This function adds two numbers and return the result"
result = a + b
return result
def sub(a, b):
"This function subtract two numbers and return the result" result = a - b
return result

def mul(a, b):

“This function multiply two numbers and return the result"
result = a * b
return result
def div(a, b):
“This function divide two numbers and return the result"
result = a / b
return result

Step 2: Create new file p2.py to include the module. Add the following code and save it
import p1 as m
print("Addition=",m.add(10„20))
print("Subtraction=",m.sub(10,20))
print("Multiolication=",m.mul(10„20))
print("division=" ,m.div(10,20))

Step 3: Execute p2.py file.

Addition= 30
Subtraction=-10
Multiplication= 200
division- 0,5

Python Built in Modules

A module is a collection of Python objects such as functions, classes, and so on. Python interpreter is
bundled with a standard library consisting of large number of built-in modules,
Built-in modules are generally written in C and bundled with Python interpreter in precompiled
 Unit 4: Python Functions modules and Packages
form. A built-in module may be a Python script (with .py extension) containing useful utilities.
A module may contain one or more functions, classes, variables, constants, or any other Python
resources.
(I) Numeric and Mathematical Modules:
This module provides numeric and math-related functions and data types. Following are the modules
which are classified as numeric and mathematical modules
1. numbers (Numeric abstract base classes),
2. math (Mathematical functions).
3. cmath (Mathematical functions for complex numbers).
4. decimal (Decimal fixed point and floating point arithmetic).
5. fractions (Rational numbers).
6. random (Generate pseudo-random numbers).
7. statistics (Mathematical statistics functions).

The numbers module defines an abstract hierarchy of numeric types. The math and cmath modules
contain various mathematical functions for floating-point and complex numbers, The decimal. module
supports exact representations of decimal numbers, using arbitrary precision arithmetic

1. math and cmath Modules:

Python provides two mathematical modules namely math and cmath. The math module gives us access
to hyperbolic, trigonometric, and Logarithmic functions for real numbers and cmath module allows us to
work with mathematical functions for complex numbers.
Example 1: For math module.
>>> import math
>>> math.ceil(1.001)
2
>>> from math import
>>> ceil(1.001)
2
>>> floor(1.001)
1
>>>factorial(5)
120
>>> trunc(1.115)
1
>>> sin(90)
0,8939966636005579
>>>cos(60)
-0.9524129804151563
>>> exp(5)
148.4131591025766
>>>log(16)
2.772588722239781
>>>log(16,2)
4.0
>>> log(16,10)
1.2041199826559246
 Unit 4: Python Functions modules and Packages
>>> pow(144,0.5)
12.0
>>>sqrt(144)
12.0
>>>

The mathematical functions for complex numbers.

Example 2; For cmath module
>>> from cmath import *
>>>c=2+2j
>>> exp(c)
(-3.0749323201539359+6.71884969742825j)
>>>log(c,2)
(1.5000000000000002+1.1330900354567985j)
>>>sort(c)
(1.5537739740300374+0.6435942529055826j)

2. Decimal Module:
Decimal numbers are just the floating-point numbers with fixed decimal points. We can create decimals
from integers, strings, floats, or tuples.
A Decimal instance can represent any number exactly, round up or down, and apply a limit to the
number of significant digits,
Example :For decimal module,
>>> from decimal import Decimal
>>> Decimal(121)
Decimal('121')
>>> Decimal(0.05)
Docimal('0.05000000000000000277555756156289135105907917022705078125')
>>> Decimal(10.15)
Decimal('15')
>>> Decimal(‘0.012’)+Decimal('0.2')
Decimal(‘0.212’)
>>> Decimal(72)/Decimal(7)
Decimal(110.28571428571428571428571429')
>>> Decimal(2).sqrt()
Decimal(' 1.414213562373095048801688724')
3. Fractions Module:
A fraction is a number which represents a whole number being divided into multiple parts. P3rthon
fractions module allows us to manage fractions in our Python programs.
Example: For fractions module.
>>> import fractions
>>> for num, decimal in [(3, 2), (2, 5), (30, 4)]:
fract = fractions.Fraction(num, decimal)
print(fract)
3/2
2/5
15/2
 Unit 4: Python Functions modules and Packages
It is also possible to convert a decimal into a Fractional number. Let's look at a code snippet
>>> import fractions
>>> for deci in[‘0.6’,’2.5’,’2.3’,’4e-1’]
fract = fractions.Fraction(deci)
print(fract)
Output:
3/5
5/2
23/10
215

4.Random Module:
Sometimes, we want the computer to pick a random number in a given range, pick a random
element from a list etc.
The random module provides functions to perform these types of operations. This function is not
accessible directly, so we need to import random module and then we need to call this function using
random static object.
Example: For random module.
>>> import random
>>>print(random,random()) # It generate a random number in the range (0.0, 1.0)
0.27958069234907935
>>>print( randorn.randint(10,20)) # It generate a random integer between x andy inclusive 13

5. Statistics Module:
Statistics module provides access to different statistics functions. Example includes mean (average
value), median (middle value), mode most often value), standard deviation (spread of values).

Example: For statistics module.

>>> import statistics
>>> statistics.mean([2,5,6,9]) #average
5.5
>>> import statistics
>>> statistics.median([1,2,3,8,9]) # central value
3
>>> statistics.median([1,2,3,7,8,9])
5.0
>>> import statistics
>» statistics.mode([2,5,3,2,8,3,9,4,2,5,6]) # repeated value
2
>>>import statistics
>>>statistics.stdev([1,1.5,2,2.5,3,3.5,4,4.5,5])
1.3693063937629153

(II) Functional Programming Modules:

These modules provide functions and classes that support a functional programming style and general
operations on callables.
Following are modules which comes under functional programming modules.
 Unit 4: Python Functions modules and Packages
1. itertools (functions creating iterators for efficient looping).
2. functools (higher-order functions and operations on callable objects).
3. operator (standard operators as functions).

1. itertools Module:
Python programming itertools module provide us various ways to manipulate the sequence while we are
traversing it.Python itertools chain() function just accepts multiple iterable and return a single sequence
as if all iteams belongs to that sequence.
Example: for itertools with chain()
>>> from itertools import
> >>for value in chain([1,3, 2,51, 3.3], ['C++', 'Python', 'Java']):
print(value)
Output
1,3
2.51
3.3
C++
Python
Java
• Python itertools cycle() function iterate through a sequence upto infinite. This works just like a circular
Linked List.
Example: For intools module with cycles°.
>>> from itertools import *
>>> for item in cycle([1C++1,1Python',']ava']):
index=index+1
if index==10:
break
print(item)

output:
C++
Python
Java
C++
Python
Java
C++
Python
Java
>>>
2. functools Module:
Python functools module provides us various tools which allows and encourages us to write reusable
code.Python functools partial() functions are used to replicate existing functions with some arguments
already passed in. It also crests new version of the function in a well-documented manner.
Suppose we have a function called multiplier which just multiplies two numbers. Its definition looks
like:
 Unit 4: Python Functions modules and Packages
def multiplier(x,y):
return x * y

Now, if we want to make some dedicated functions to double or triple a number then we will have to
define new functions as:
def multiplier(x, y):
return x * y
def doubleIt(x):
return multiplier(x, 2)

def tripleIt(x):
return multiplier(x, 3)
But what happens when we need 1000 such functions? Here, we can use partial functions:

from functools import partial

def multiplier(x, y):
return x * y
double partial(multiplier, 51=2)
triple - partial(multiplier, y-3)
print('Double of 2 is’, format(double(5)))
print('Triple of 5 is ‘,format(triple(5)))

Output
Double of 5 is 10
Triple of 5 is 15
Operator Module:
The operator module supplies functions that are equivalent to Python's operators. These functions are
handy in cases where callables must be stored, passed as arguments, or returned as function results.
Functions supplied by the operator module are listed in following table:

Sr.
Function Signature/Syntax Behaves Like
No.
1 abs abs(a) abs(a)
2 add add(a,b) a+b
3 and_ and_(a,b) a&b
4 div div(a,b) a/b
5 eq eq(a,b) a==b
6 gt gt(a,b) a>b
invert,
7 invert(a),inv(a) ~a
inv
8 le le(a,b) a<=b
9 lshift lshift(a,b) a<<b
10 It lt(a,b) A<b
11 mod mod(a,b) A%b
 Unit 4: Python Functions modules and Packages
12 mul mul(a,b) a*b
13 ne ne(a,b) a! =b
14 neg neg(a) -a
15 not_ not (a) not a
16 or or_(a,b) alb
17 pos pos(a) +a
18 repeat repeat(a,b) a*b
19 rshift rshift(a,b) a>b
20 xor_ xor(a,b) A^b

Namespace and Scoping

A namespace is a system to have a unique name for each and every object in Python. An object might
be a variable or a method. Python itself maintains a namespace in the form of a Python dictionary.
Python interpreter understands what exact method or variable one is trying to point to in the code,
depending upon the namespace. So, the division of the word itself gives little more information: Name
(which means name, an unique identifier) + Space(which talks something related to scope). Here, a
name might be of any Python method or variable and space depends upon the location from where is
trying to access a variable or a method.
A namespace in python is a collection of names. So, a namespace is essentially a mapping of names to
corresponding objects.
At any instant, different python namespaces can coexist completely isolated- the isolation ensures that
there are no name collisions/problem.
A scope refers to a region of a program where a namespace can be directly accessed, i.e. without using a
namespace prefix.
Scoping in Python revolves around the concept of namespaces. Namespaces are basically dictionaries
containing the names and values of the objects within a given scope.
Types of Namespaces:
When a user creates a module, a global namespace gets created, later creation of local functions creates
the local namespace. The built-in namespace encompasses global namespace and global namespace
encompasses local namespace.

1. Local Namespace: This namespace covers the local names inside a function. Python creates this
namespace for every function called in a program. It remains active until the function returns.
 Unit 4: Python Functions modules and Packages
Global Namespace: This namespace covers the names from various imported modules used in a
project. Python creates this namespace for every module included in the program. It will last until the
program ends.
Built-in Namespace: This namespace covers the built-in functions and built-in exception names.
Python creates it as the interpreter starts and keeps it until we exit.
Namespaces help us uniquely identify all the names inside a program. According to Python's
documentation "a scope is a textual region of a Python program, where a namespace is directly
accessible." Directly accessible means that when we are looking for an unqualified reference to a name
Python tries to find it in the namespace.
Scopes are determined statically, but actually, during runtime, they are used dynamically. This means
that by inspecting the source code, we can tell what the scope of an object is, but this does not prevent
the software from altering that during runtime.

Python Variable Scoping:

Scope is the portion of the program from where a namespace can be accessed directly without
any prefix. Namespaces are a logical way to organize variable names when a variable inside a
function (a local variable) shares the same name as a variable outside of the function (a global variable).
Local variables contained within a function (either in the script or within an imported module) and
global variables can share a name as long as they do not share a namespace.

At any given moment, there are at least following three nested scopes:

 Scope of the current function which has local names.

 Scope of the module which has global names.
 Outermost scope which has built-in names.

When a reference is made inside a function, the name is searched in the local namespace, then in the
global namespace and finally in the built-in namespace.
If there is a function inside another function, a new scope is nested inside the local scope. Python has
two scopes.
Local Scope Variable: All those variables which are assigned inside a function known as local scope
Variable
Global Scope Variable: All those variables which are outside the function termed as global variable.

Example: For global scope and local scope.

global var = 30 # global scope
def scope():
local_var = 40 # local scope
print(global_var)
print(local var)
scope()
print(global_var)
Output:
30
40
3
PYTHON PACKAGES
 Unit 4: Python Functions modules and Packages
Suppose we have developed a very large application that includes many modules. As the number
of modules grows, it becomes difficult to keep track of them all as they have similar names or
functionality.
It is necessary to group and organize them by some mean which can be achieved by packages.
Introduction
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.
Packages allow for a hierarchical structuring of the module name space using dot notation. Packages are
a way of structuring many packages and modules which help in a well-organized hierarchy of data set,
making the directories and modules easy to access.
A package is a collection of Python modules, i.e., a package is a directory of Python modules containing
an additional _ _init_ _.py file (For example: Phone/_ _init_ _.py).

Writing Python Packages

Creating packages is quite easy ,since it makes use of the operating system inherent hierarchical
file structure shown in figure.
Here thereis a dictionary named mypkg that contains two modules p1.py and py.py the contents of
this modules are

P1.py
Def m1():
print("first module")

p2.py

def m2():
print("second modulo")

Here mypkg a folder /directory which consist of pl.py and p2.py. We can refer these
two modules with dot notation (mypkg.pl, mypkg.p2) and import them with the one of the following
syntaxes:

Syntax 1: import <module_name>[, <module_name> ...]

Example:

>>> import mypkg.pl,mypkg.p2

>>> mypkg.pl.m1()
first module
>>> p1.m1()

Syntax 2: from <module_name> import <name(s)>

 Unit 4: Python Functions modules and Packages
Example:

>>> from mypkg.pl import ml

>>> m1()
first module
>>>

Standards packages

NumPy and SciPy are the standards packages used by Python programming.
NumPy enriches the programming language Python with powerful data structures, implementing multi-
dimensional arrays and matrices.
SciPy (Scientific Python) is often mentioned in the same breath with NumPy. SciPy needs Numpy, as it
is based on the data structures of Numpy and furthermore its basic creation and manipulation functions.
It extends the capabilities of NumPy with further useful functions for minimization, regression, Fourier-
transformation and many others,
Both NumPy and SciPy are not part of a basic Python installation. They have to be installed after the
Python installation. NumPy has to be installed before installing SciPy.

Math
Some of the most popular mathematical functions are defined in the math module. These include
trigonometric functions, representation functions, logarithmic functions and angle conversion
functions.Two mathematical constants are also defined in math module.Pie (x) is a well-known
mathematical constant, which is defined as the ratio of the circumference to the diameter of a circle and
its value is
3.141592653589793.

>>> import math

>> >math.pi
3,141592553589793

Another well-known mathematical constant defined in the math module is e_ It is called either’s
number and it is a base of the natural logarithm. Its value is 2318281828459045.
>>> import math
>> math. e
2.718281828459e45

NumPy
NumPy is the fundamental package for scientific computing with Python.
NumPy stands for "Numerical Python". It provides a high-performance multidimensional array object,
and tools for working with these arrays.
An array is a table of elements (usually numbers), all of the same type, indexed by a tuple of positive
integers and represented by a single variable.
NumPy's array class is called ndarray. It is also known by the alias array.
In NumPy arrays, the individual data items are called elements.
 Unit 4: Python Functions modules and Packages
All elements of an array should be of the same type. Arrays can be made up of any number of
dimensions.
In NumPy, dimensions are called axes. Each dimension of an array has a length which is the total
number of elements in that direction.
The size of an array is the total number of elements contained in an array in the entire dimension.
The size of NumPy arrays are fixed; once created it cannot be changed again.
Numpy arrays are great alternatives to Python Lists.
Some of the key advantages of Numpy arrays are that they are fast, easy to work with, and give users the
opportunity to perform calculations across entire arrays.

Fig. 4.6 shows the axes (or dimensions) and lengths of two example arrays;
a) is a one-dimensional array and
(b) is a two-dimensional array.
A one dimensional array has one axis indicated by Axis-O, That axis has five elements in it, so we say it
has length of five.
A two dimensional array is made up of rows and columns. All rows are indicated by Axis-0 and all
columns are indicated by axis-1. If Axis-O in two dimensional array has three elements, so its length it
three and Axis-1 has six elements, so its length is six,

Execute Following command to install numpy in window, Linux and MAC OS:

python -m pip install numpy

To use NumPy you need to import Numpy:

import numpy as np # alias np

Using NumPy, a developer can perform the following operations:

Mathematical and logical operations on arrays.
Fourier transforms and routines for shape manipulation.
3, Operations related to linear algebra.
NumPy has in-built functions for linear algebra and random number generation.
Array Object: NumPy's main object is the homogeneous multidimensional array, It is a table of
elements (usually numbers), all of the same type, indexed by a tuple of positive integers,In NumPy
 Unit 4: Python Functions modules and Packages
dimensions are called axes. The number of axes is rank, NumPy's array class is called ndarray. It is also
known by the alias array.

Basic attributes of the ndarray class as follow:

Sr. No. Attributes Description
1 shape A tuple that specifies the number of elements for each dimension of the array.
2 size The total number elements in the array.
3 ndim Determines the dimension an array.
4 nbytes Number of bytes used to store the data.
5 dtype Determine data type of elements stored in array

Example:
For NumPy with array object.
>>> import numpy as np
>>a=np.array([1,2,3]) # one dimensional array
>>> print(a)
[1 2 3]
>>>arr=np.array([1,2,3],[4,5,6]]) # two dimensional array print(arr)
([1 2 3]
[4 5 6] ]
>>> type(arr)

<c lass 'numpy.ndarray'›

print('No. of dimension: ", arr.ndim)
No. of dimension: 2
>>> print("Shape of array: ", arr.shape)
shape of array: (2, 3)
>> >print("size of array: ", arr.size)
size of array: 6
>>> print("Type of elements in array: ", arr.dtype) Type of elements in array: int32
>>> print("No of bytes:", arr.nbytes)
No of bytes: 24

Basic Array operations

In NumPy, arrays allow a wide range of operations which can be performed on a particular array
or a combination of Arrays.
These operations include some basic mathematical operation as well as Unary and Binary operations. In
case of +=, —=,*. operators, the existing array is modified.

Unary Operators: Many unary operations are provided as a method of ndarray class. This includes
sum, min, max, etc. These functions can also be applied row-wise or column-wise by setting an axis
parameter.
Binary Operators: These operations apply on array elementwise and a new array is created. You can
use all basic arithmetic operators like +, - etc, In case of +=,==, = operators, the existing array is
modified.
 Unit 4: Python Functions modules and Packages
Example: For basic array operators.
>>>arr1=np.array([1,2,3,4,5])
>> arr2,=np.array([2,3,4,5,6])
>>> print(arrl)
[1 2 3 4 5]

>>> print("add 1 in each element:",arr1+1)

add 1 in each element: [2 3 4 5 6]
>>>print("subtract 1 from each element: ", arrl-1)
subtract 1 from each element: [0 1 2 3 4]
>>> print("multiply 10 with each element in array: "„arr1*10)
multiply 10 with each element in array: [10 20 30 40 50]
>>> print("sum of all array elements: "„arri.sum())
sum of all array elements: 15 print("array sum-:", arrl+arr2)
array sum=: [ 3 5 7 9 1]
>>>print("Largest element in array: ",arrl.max())
Largest element in array: 5

Example

>>>arr=np.array([(1,2,3],[4,5,6]])
>>>a=arr.reshape(3,2)
>>> a
Array ( [ [1, 2],
[3, 4],
[5, 67])

slicing of Array:
Slicing is basically extracting particular set of elements from an array. Consider an array ([(1,2,3,4),
(5,6,7,8)1).
Here, the array (1,2,3,4) is at index 0 and (3,4,5,6) is at index 1 of the python numpy array, We need a
particular element (say 3) out of a given array.
Let us consider the below example:
import numpy as np
>>> a=np.array([(1,2,3,4),(5,6,7,8)])
>>> print(4,2])
3
Let us consider the below example:
>>> import numpy as rip
>>> a=np.array([(1,2,3,4),(5,6,7,8)])
>>> print(a[0,2])
3
Now we need the 2nd element from the zero and first index of the array.
The code will be as follows:
import numpy as rip
a=rip.array([(1,2, 3,4), (5, 6,7,8)] )
print(a[9:2])
 Unit 4: Python Functions modules and Packages
[3 7]
Here, colon represents all the rows, including zero.

Scipy package

scipy is a library that uses NumPy for more mathematical functions,

SciPy uses NumPy arrays as the basic data structure, and comes with modules for various commonly
used tasks fn scientific programming, including linear algebra, integration (calculus), ordinary
differential equation solving, and signal processing.
Following command execute to install SciPy in Window, Linux and MAC OS.:

python -el pip install sd.py

StiPy is organized into sub packages covering different scientific computing domains. These are
summarized in the following table:

Sr. No. Subpackage Description

1 cluster Clustering algorithms.
2 constants Physical and mathematical constants.
3 fftpack Fast Fourier Transform routines.
4 integrate Integration and ordinary differential equation solvers.
5. interpolate Interpolation and smoothing splines.
6.
Sci.Py has many modules, classes, and functions available to
io
read data from and write data to a variety of file formats.
7. linalg Linear algebra.
8 ndimage N-dimensional image processing.
9 odr Orthogonal distance regression.
1. optimize Optimization and root-finding routines.
2. signal Signal processing.
3. sparse Sparse matrices and associated routines.
4. spatial Spatial data structures and algorithms.
5. special Special functions.
6. stats Statistical distributions and functions.

Example 1: Using linalg sub package of Scipy.

>>> import numpy as np
>>> from scipy import linalg
>>> a = op_array([[1.,2.],[3., 4.]])
>>>linalg.inv(a) #find inverse of array
>>>array([[-2. , 1] , [ 1.5, -0.5]])
 Unit 4: Python Functions modules and Packages
Example 2: Using linalg sub package of SciPy,
>>> import numpy as np
>>> from scipy import linalg
>>> a = np.array([[1,2,3], [4,5,6], [7,809]])
>>> linalg.det(a) # find determinant of array
0.0

Example 3: Using special sub package of SciPy.

>>>from scipy.special import cbrt
>>> cb=cbrt([81,64]) find cube root
>>> cb
array([4.32674872,4. ])

4) Matplotlib
Matplotlib.pyplot is a plotting library used for 2D graphics in python programming language. It can
be used in python scripts, shell, web application servers and other graphical user interface toolkits.
There are various plots which can be created using python matplotlib like bar graph, histogram, scatter
plot, area plot, pie plot.

Following command execute to

install matplotlib

in Window, Linux and MAC OS

from matplotlib import pyplot as pit #OR import matplotlib.pyplot as plt

Example: For line plot.

>>> from matplotlib import pyplot as plt

>>> x=(214,8110)
>> y=[218,812]
plt.plot(x,y)
[<matplotlib.lines.Line2d object at 0x02E69870>]
>> plt.show()

Output:

Bar Graph:
 Unit 4: Python Functions modules and Packages
A bar graph uses bars to compare data among different categories, It is well suited when you want to
measure the changes over a period of time_ It can be represented horizontally or vertically

Example: For bar graph.

from matplotlib import pyplot as plt
>>>x=[2,4,8,19]
>>>y=[218,8,2]
>>> plt.xlabel('X-Axis')
Text(0.5, 0, 'X-Axis')
>>> plt.ylabel('Y-Axis')
Text(0,0.5,’Y-Axis’)
>>> plt.title(Graph)
Text(O.5, 1.0, 'Graph')
>>>plt.bar(x,y,label=Graph”,color=’r’,width=0.5)
>>>plt.show()

Pandas
Pandas is an open-source Python Library providing high-performance data manipulation and analysis
tool using its powerful data structures.

It is built on the Numpy package and its key data structure is called the DataFrame, DataFrames allow
you to store and manipulate tabular data in rows of observations and Colums of variables.

installing Pandas

pip install pandas

Data structures supported by Pandas:

Pandas deals with the following three data structures:
Sr.
Date Structure Dimensions Description
Pro.
3.D labeled homogeneous array, size
1. Series 1
immutable
2. Data Frames 2 General 2D labeled, size-mutable
tabular structure with potentially
heterogeneously typed columns.

3. Panel 3 General SD labeled, size-mutable array.

 Unit 4: Python Functions modules and Packages
Series:
Series is a one-dimensional array Like structure with homogeneous data.

The series is a one dimensional array which is Labeled and it is capable of holding array of any type
like Integer, Float,String and Python Objects.

for example, the following series is a collection of integers10, 22, 30. 41...The syntax is as follows!
pandas.Series(data, index, dtype, copy)
It takes four arguments:
1.data: It is the array that needs to be passed as to convert it into a series, This can he Python lists.
numpy Array or a Python Dictionary or Constants.
2.Index This holds the index values for each element passed in data. If it is not specified, default is

numpy.arange(length_of_data).

3.Dtype: It is the datatype of the data passed in the method.

4.copy: It takes a Boolean value specifying whether or not to copy the data if not specified, default is
False

Here data is only mandatory argument of series,

Example 1: Using Series data structure of Panda

>>> import pandas as pd

>>>import numpy as np
>>>arr =np. array([2. 4, 6, 8, 10, 20])
>>> si = pd_Series(arr)
>>>print(si)

Output:
0 2
1 4
2 6
3 8
4 10
5 20
dtypa: int32

Example 21. Using Series data structure of panda

>>> import pandas as pd
>>> data=[10,20,30,40,50]
>>>index=['a',’b’,’c’,’d’,’e’]
>>>si=pd.Series(data,indcx)
>>>si

a 10
 Unit 4: Python Functions modules and Packages
b 2i
c 30
d 40
e 50
Dtype:int64
>>>

User Defined Packages

We organize a large number of files in different folders and subfolders based on some criteria.
so that we can find and manage them easily.
In the same way, a package in Python takes the concept of the modular approach to next logical level.
As you know if, a module can contain multiple objects,such as classes, functions. etc.
A package can contain one or more relevant modules.
Physically, a package is actually a folder containing one or more module files. Let's create a packa.ge
named myPkg, using the following steps:

step 1: Create folder PlyPkg on "local drive. Create modules Message.py and Mathematics.py with
following code:
Message.py
def SayHello(name);
print("hello”, name)
return

Mathematics.py

def sum(x,y):
return x+y

def average(x,y);
return (x+y)/2

def power(x,y):
return x**y

Step 2: Create an empty _ _init_ _.py file in the MyPkg folder.

The package folder contains a special file called _ _init_ _.py, which stores the package's content.
It serves two purposes:
1. The Python Interpreter recognizes a folder as the package lilt contains
2. _ _Init_ _.py 2- _ _.py exposes specified resources from its modules to be imported.

An empty _ _nit_ .py file makes all functions from above modules available when this package is
imported. Note that _ _init_ _.py is essential for the folder to be recognized by Python as a package. We
can optionally define functions from individual modules to be made available.

Step 3: Create p1.py file in MyPkg folder and write following code:

from Mypkg import Mathematics

 Unit 4: Python Functions modules and Packages
from MyPkg import Message
greet. SayHello("rudra”)
x=function5.power(3,2)
print (“power(3,2)”,x)

output
hello rudra
power(3,2):9

Using _ _init_ ,py File:

The __init_ _.py file is normally kept empty.However, it can also be used to choose specific functions
from modules in the package folder and make them available for import. Modify _ _init_ _.py as below:
init__py
from .Mathematics import average, power
from .Message import SayHello

The specified functions can now be imported in the interpreter session or another executable script.
Create test.py in the MyPkg folder and write following code:

test.py
from MyPkg import power, average, SayHello
SayHello()
x.power(3,2)
print("power(3,2) “’x)

Note that functions power and SayHello() are imported from the package and not from their respective
modules, as done earlier. The output of above script is:

Hello world