Python Modules, Packages and Libraries

CHAPTER 4
SELF LEARNING
PRESENTATION.
PDF Format
All images used in this presentation
are from the public domain

Friends,
Module 1 assigning to Aswin
Module 3 and 5 goes to Naveen
Module 4 to Abhishek, 2 to Sneha
and .., Abhijith will lead you.

I need this
code again
in another
program.

Modules, packages, and libraries are
all different ways to reuse a code.
Modules
Packages
libraries

A module is a file containing Python definitions and statements. The file name is the module name with the suffix .py appended.
Look at the board. There are
some functions, classes, constant
and some other statements.
Absolutely this is a module.
Module is a collection
of functions, classes,
constants and other
statements.

Write the code on the board
in a file and save it with a
name with .py suffix.
It becomes a module.

Yes2. I want to write
some more module
files.
Can you try your
own modules ?
Good. That is Package.

A group of modules saved in a
folder is called package.
I want a package contains
my own modules.
Collection of modules
saved in a folder, are
called package.

Library is a collection of packages.
Suppose we write more packages about
anything. It will become a library. In
general, the terms package and library
have the same meaning.

PYTHON has rich libraries.
,
.

The Python Standard Library contains
built-in data, functions, and many modules.
All are part of the Python installation.
Basic Contents of Standard Library.

Built-in
Data,
functions
+ more
Module to import
1. Math module
2. Cmath module
3. Random module
4. Statistics module
5. Urllib module
and

print ( "10 + 20 = ", 10 + 20 )
print ( "Cube of 2 is ", 2 ** 3 )
import math
print ("Square root of 25 is ", math.sqrt(25) )
print ("Cube of 2 is ", math.pow(2,3) )
print(), input(),
10 + 20 are basic operation.
No need to import anything.
sqrt () and pow () are defined in
Math module. So need to
import math modules.
We use the
Statement to import other
modules into our programs.

hex ( Integer Argument )
oct ( Integer Argument )
int ( string / float Argument )
round ( )
Examples of Built-in Function.
Accept an integer in any
system and returns its
octal equivalent as string.
>>> oct ( 10 )
OUTPUT : ‘0o12’
Accept an integer in any system and returns
its Hexadecimal equivalent as string.>>> hex ( 10 )
OUTPUT : ‘0xa’
The int() function returns
integer value of given value.
The given float number is rounded
to specified number of
decimal places.
>>> int ( 3.14 )
OUTPUT : 3
>>> round ( 3.65,0 )
OUTPUT : 4.0
In oct, 1, 2, 3, 4,
5, 6, 7, What
next ?

oct(),hex() and bin() Functions.
Don't worry. you just count 1 to 20 using
for a in range(1,21) And use hex() and oct()
functions. The computer will do everything for you.
Octal system has only 8 digits.
They are 0 to 7. after 7, write
10 for 8, 11 for 9, 12 for 10 etc.
Hexadecimal system has 16
digits. They are 0 to 9 and 'a'
for 10, 'b' for 11... 'f' for 15.
After 15, write 10 for 16, 11 for
17, 12 for 18 etc.

print ("Numbering System Table")
print("column 1: Decimal System, col2 : Octal, col3: Hex, col4: Binary")
for a in range(1,25):
print(a, oct(a), hex(a), bin(a) )
Numbering System Table
column 1 :Decimal System, col2 : Octal,
col3: Hex, col4: Binary
1 0o1 0x1 0b1
2 0o2 0x2 0b10
3 0o3 0x3 0b11
4 0o4 0x4 0b100
5 0o5 0x5 0b101
6 0o6 0x6 0b110
16 0o20 0x10 0b10000
17 0o21 0x11 0b10001
18 0o22 0x12 0b10010
19 0o23 0x13 0b10011
20 0o24 0x14 0b10100
21 0o25 0x15 0b10101
22 0o26 0x16 0b10110
23 0o27 0x17 0b10111
24 0o30 0x18 0b11000
oct() convert given value to octal system.
hex() convert given value to Hexadecimal system.
bin() convert given value to Binary system.
OUTPUT
CODE

int ( float/string Argument )
round (float , No of Decimals)
int () and round () Function.
The int() function returns integer value
(No decimal places) of given value. The given
value may be an integer, float or a string like “123”
The given float number is rounded to specified
number of decimal places. If the ignoring number is
above .5 ( >=.5) then the digit before it will be added by 1.
>>> int ( 3.14 )
OUTPUT : 3
>>> int (10/3)
OUTPUT : 3
>>> int( “123” )
OUTPUT : 123
>>> round ( 3.65 , 0 )
OUTPUT : 4.0

Join the words “lion”, “tiger” and
“leopard” together.
Replace all "a" in “Mavelikkara” with "A".
Split the line 'India is my motherland'
into separate words.
“anil” + “kumar” = “anil kumar”,
“anil” * 3 = “anilanilanil”. These are
the basic operations of a string.

string.split() function splits a string into a list.
>>> x = "All knowledge is within us.“
>>>
We get the list ['All', 'knowledge', 'is', 'within', 'us.']
Wrong use Right use
Prefix

>>> x = "Mathew,Krishna,David,Ram"
>>> x.split( “,” )
We get the list ['Mathew', 'Krishna', 'David', 'Ram']
Cut when
you see “n“.
>>> x = "MathewnKrishnanDavidnRam"
>>> x.split( “n” )
We get the list ['Mathew', 'Krishna', 'David', 'Ram']
>>> x = "MAVELIKARA"
>>> x.split("A")
We get the list ['M', 'VELIK', 'R', '']
"MAVELIKARA" Is it
Fun?

string.join() joins a set of string into a single string.
Delimit string.join ( collection of string )
“,”. join ( [‘Item1’, ‘Item2’, ‘Item3’] )
‘Item1’
‘Item1,Item2’
1
2
3
Item1,Item2,Item3End
>>> a = ['Matthew', 'Krishna', 'David','Ram']
>>> ",".join(a) OUTPUT : 'Matthew,Krishna,David,Ram'

Do it in Python.
>>> a = ['Trissur','Ernakulam','Kottayam', 'Mavelikara' ]
>>>> "->".join(a)
'Trissur->Ernakulam->Kottayam->Mavelikara'

Can you change
zebra to cobra?
replace () Function. replace () Function.
function replaces a phrase with
another phrase.
string.replace(what, with, count )
What to replace?
Replace with what?
How many replacement is
needed.(optional)
>>> ‘zebra’.replace(‘ze’,’co’)
cobra zebra becomes cobra
>>> ‘cobra’.replace(‘co’,’ze’)
zebra cobra becomes zebra

Modules such as math, cmath, random, statistics, urllib are
not an integral part of Python Interpreter. But they are
part of the Python installation. If we need them,
import them into our program and use them.
We use "Import” statement to import
Other modules into our programs.
It has many forms. We will learn in detail later.
Syntax is import < module Name >
E.g. import math
import random

Python does a series of actions when you import module,
They are
The code of importing modules is interprets
and executed.
Defined functions and variables in the
module are now available.
A new namespace is setup for importing modules.

A namespace is a dictionary that contains the names and definitions
of defined functions and variables. Names are like keys and
definitions are values. It will avoid ambiguity between 2 names.
I teach 2 Abhijit. one is in class XI-B and
other is in class XII-A. How can I write
theirname without ambiguity.
class XI-B.Abhijit class XII-A.Abhijit

Are not Ashwin in 12.B?
Your Reg. No 675323.
No Sir, Check
the list of 12.A

Who is കുഴിക്കാലായിൽ
അബ്രഹാാം(K M Abraham)
He is a member of
കുഴിക്കാലായിൽ
family.
An object (variable, functions
etc.) defined in a namespace is
associated with that
namespace. This way, the
same identifier can be defined
in multiple namespaces.
>>> math.
Output : 5
>>> math.pi
Output :3.141592653589793
Google K.M. Abraham.
Name of
Namespace
Object in that
Namespace

math
math and cmath modules covers many mathematical
functions.
and .
More than 45 functions and 5 constants are defined in it.
The use of these functions can be understood by their
name itself.
2. Place (Namespace) before function name.
1. import math
X = sqrt(25)
Name of
Namespace
Object in that
Namespace

>>> locals()
{'__name__': '__main__', '__doc__': None, '__package__': None,
'__loader__': <class '_frozen_importlib.BuiltinImporter'>,
'__spec__': None, '__annotations__': {}, '__builtins__': <module
'builtins' (built-in)>}
>>> import math
>>> locals()
{'__name__': '__main__', '__doc__': None, '__package__': None,
'__loader__': <class '_frozen_importlib.BuiltinImporter'>,
'__spec__': None, '__annotations__': {}, '__builtins__': <module
'builtins' (built-in)>, 'math': <module 'math' (built-in)>}
>>>

>>> help(math)
Traceback (most recent call last): File "<pyshell#1>", line 1, in <module>
help(math)
NameError: name 'math' is not defined
>>> import math
>>> help (math)
Help on built-in module math:
NAME
math
DESCRIPTION
This module provides access to the mathematical functions
defined by the C standard.

FUNCTIONS.import math
The value without –ve / +ve symbol is called
absolute value. Both functions give absolute value, while fabs () always give a float
value, but abs () gives either float or int depending on the argument.
>>> abs(-5.5) >>> abs(5)
Output : 5.5 5
>>> math.fabs(5) >>> math.fabs(5.5)
Output : 5.0 5.5
Returns factorial value
of given Integer. Error will occur if you enter a -ve or a float value.
>>> >>> math.factorial(-5)
Output : 120 >>> math.factorial(5.5)
Wrong useRight use
Abs() is built-in
function.

fmod function returns the
remainder when x is divided by y. Both x and y must be a
number otherwise error will occur.
What is the remainder when
10.32 is divided by 3? >>> import math
>>> math.fmod(10.32,3)
1.32
What is the remainder when
11.5 is dividedby 2.5?
𝟏𝟎.𝟑𝟐
𝟑
= 3 × 3 = 9
𝑟𝑒𝑚𝑎𝑖𝑛𝑖𝑛𝑔 1.32
>>> import math
>>> math.fmod(11.5,2.5)
1.5

modf () separates fractional
and integer parts from a floating point number. The result
will be a tuple. using multiple assignment, you can assign
these 2 values in 2 variables.
Can you separate the fraction and
the integer parts of pi value?
>>> import math
>>> math.modf(math.pi)
(0.14159265358979312, 3.0)
>>> a , b = math.modf(math.pi)
a= 0.14159265358979312, b = 3
Fractional part Integer part
Tuple data type

Statistics module provides 23 statistical functions. Some of
them are discussed here.
Before using them. And call with “statistics.” prefix.
mean() calculate
Arithmetic mean (average) of data.
>>> import statistics
>>> statistics.mean( [1,2,3,4,5] )
Output : 3
>>> statistics.mean( [1,2,3,4,5,6] )
Output : 3.5
Sum of Values
Count of Values
Mean is
calculated as

The middle value of a sorted list of numbers is called
median. If the number of values is odd, it will return the
middle value. If the number is even, the median is the
midpoint of middle two values.
>>> import statistics
>>> a = [10,20,25,30,40]
>>> statistics.median(a)
Output : 25
a = [10, 20, 25,30, 40, 50]
>>> statistics.median(a)
Output : 27.5
Here ,number of values is 5, an odd
No, So returns the middle value
Here ,number of values is 6, an even
No, So returns the average of
middle two values.
If the number of elements is
an oddnumber thenlook
up else looks down.

It must be a unique items, multiple items cannot be
considered as modes. Eg. MODE of [1,2,3,2,1,2] is 2 because
‘2’ occures 3 times while MODE of [1,2,3,2,1,2,1] causes
ERROR because values 1 and 2 are repeated 3 times each.
Output : 2
>>> statistics.mode(“MAVELIKARA")
Output : ‘A'
Modeof "HIPPOPOTAMUS“ is P.
No mode for KANGAROO

import random FUNCTIONS.
Have you used an OTP number? Sure it shall be a
random number. It has many uses in science, statistics,
cryptography, gaming, gambling and other fields.
When you throw a dice, it will generate a
randomnumber between 1-6.

If you need a 3 digit otp number, pick a
random number between 100 and 999.

The webbrowser module
is used to display web pages
through Python program. Import this module and call
webbrowser.open(URL)
import webbrowser
url = "https://www.facebook.com/"
webbrowser.open(url)
webbrowser.open("https://mail.google.com/")
webbrowser.open(“https://www.youtube.com/”)
opens mail
opens youtube

>>> import webbrowser
>>> webbrowser.open("https://www.slideshare.net/venugopalavarmaraja/")
.
Give any address (URL)here.
OUTPUT OF 2 LINE CODE

urllib is a package for working with URLs. It
contains several modules. Most important one is
'request'. So import urllib.request when working
with URLs. Some of them mentioning below..
Urllib.request.urlopen()
Open a website denoted by URL for reading. It will return
a file like object called QUrl. It is used for calling following
functions.
QUrl.read()
returns html or source code of the given url opened via
Urlopen().
QUrl.getcode()
Returns the http status code like 1xx,2xx ... 5xx. 2xx(200)
denotes success and others have their meaning.
QUrl.headers () Stores metadata about the opened url
QUrl.info () Returns some information as stored by headers.
QUrl.geturl ()
Returns the url string.

import urllib.request
import webbrowser
u = "https://www.slideshare.net/venugopalavarmaraja/"
weburl = urllib.request.urlopen(u)
html = weburl.read()
code = weburl.getcode()
url = weburl.geturl()
hd = weburl.headers
inf = weburl.info()
print("The URL is ", url)
print("HTTP status code = ", code )
print("Header returned ", hd )
print("The info() returned ", inf )
print("Now opening the url",url )
webbrowser.open_new(url)
Creating QUrl object(HTTP Request
Object)
Calling Functions with QUrl Object
Printing Data
Opening Website

So far we have learned What are modules,
packages, and libraries? And familiarized
with Standard Library. Libraries like Numpy,
Scipy, Tkinter, Matplotlib are not part of
Python Standard Libraries. So they
want to download and install. We
do It when we study 8th chapter.
Now we are going to learn

A module is a Python
file that contains a
collection of
functions, classes,
constants, and other
statements.

This is the file I wrote and saved.
File name is MYMOD.py.
What to do next.
Creating Module

I opened another program file
and imported MYMOD (.py).
The functions written in the
module are working well.
Example

Python does a series of actions when you import module,
They are
and executed.
Module functions and variables are available
now, but use module name as their prefix.

is a dictionary that contains the names
and definitions of defined functions and variables. Names
are like keys and definitions are values. It will avoid
ambiguity between 2 names.
I teach 2 Abhijit. one is in class XI-B and other
is in class XII-A. Howcan I write their name
without ambiguity.
class XI-B.Abhijit class XII-A.Abhijit

The CONVERSION.pymodule contains
2 functions. They convert, lengthin feet
and inches to meters and centimeters
and vice versa
Import module
The screenshot on the left
shows the module we
created.
The screenshot below shows
how to import and use that
module.
Example 2

Example 3
Now creating another module
named MY_MATH.py. It contains 2
functions, fact(x) and add_up_to(x).
Import into a
new program.

Structure of a Module
DocString (Documentation String)
Functions
Constants/Variables
Classes
Objects
Other Statements

def fibi(a, b, n) :
print ("Fibonacci Series is ", end="")
for x in range(n):
print (a+b, end=", ")
a, b = b, a+b

def fibo(a, b, n) :
'''fibi () takes 3 arguments and generate Fibonacci series
„a‟ and „b‟ are previous 2 elements. N is the number of
elements we want.'''
print (" Fibonacci Series is ", end="")
for x in range(n):
print (a+b, end=", ")
a, b = b, a+b
All

Calling help of fibo function.
The documentation string is shown.
Is it interesting? Details about the
author, version and license can be
given in the 'Dockstring'.

Write this code in a
Python file and save.
Goto Python Shell and call help()

>>> import MYMOD
>>> help(MYMOD)
Help on module MYMOD:
NAME
MYMOD
DESCRIPTION
This Module contains 4 functions.
1. add(a,b) -> Receives 2 Nos and return a + b.
2. sub(a,b) -> Receives 2 Nos and return a - b.
3. add(a,b) -> Receives 2 Nos and return a + b.
4. sub(a,b) -> Receives 2 Nos and return a - b.
FUNCTIONS
add(a, b)
add(a,b) in MYMOD module accepts 2 Nos and return a + b
div(a, b)
div(a,b) in MYMOD module accepts 2 Nos and return "a / b
mul(a, b)
mul(a,b) in MYMOD module accepts 2 Nos and return "a * b
sub(a, b)
sub(a,b) in MYMOD module accepts 2 Nos and return a - b
FILE
c:usersaug 19...programspythonpython37-32mymod.py
Calling help()
Help () function gives
documentation about functions,
classes, modules.

„‟‟ This module contains each function (), class, and data. „‟‟
months = ["Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec"]
class Student :
''' Just an example of Python class'''
pass
def String_Date (d, m, y) :
''' Receives d, m, y as integers and return String Form '''
if d==1 or d==21 or d==31 :
…………
return words + months[m-1] + ", " + str(y)
Documentation Sting of Class.
Function’s Documentation Sting.

Impot Module &Calling help
Documentation string of Function.
Name of Module
Documentation Sting of Module.
Classes defined in the Module.
Documentation Sting of Class.
Functions defined in the Module.
Data / Constatnts / Variable / Objects
Path of Module File

The package is a way to organize
modules and other resources in a neat
and tidy manner.
Module_01.py
Module_02.py
__init__.py
Package
Import modules
from them and
use as you need.

Create Module_01.py
Create Module_02.py
Create __init__.py

Step 1.
Create Module_01.py
Create Module_02.py
Create __init__.py

Getting Current Working
Directory(folder)
Creating Folfer.

Step 2.
import os
os.mkdir(“MY_PACKAGE”)
Create Module_01.py
Create Module_02.py
Create __init__.py
Create Modules. Let us try the
previous module /
file MYMOD.py.

Add other Modules
and __init__.py files
MY
Package
Creating MYMOD.py
SAVE IN
MY_PACKAGE
>>> import os
>>> os.mkdir(“my_package”)

Add other Modules
and __init__.py files
MY
Package
MYMOD.py
Creating
CONVERSION.py.py
SAVE IN
MY_PACKAGE
>>> import os
>>> os.mkdir

MYMOD.py
CONVESION.py
Create __init__.py
MY
Package
Creating MY_MATH.py
SAVE IN
MY_PACKAGE

"Underscore underscore init
underscore underscore dot py"
__init__.py
How is it
pronounced? Double
Underscore
”Dunder” means Double Underscore.
two leading and two trailing underscores

__init__.py file marks folders
(directories) as Python package.
This will execute automatically
when the package is imported.
The __init__.py file initialize the
Package as its name implies.
Etc..

Step 3.
import os
os.mkdir(“MY_PACKAGE”)
MYMOD.py
CONVERSION.py
Creating
__init__.py
Create __init__.py
MY_MATH.py

Step 3.
MYMOD.py
CONVERSION.py
Creating
__init__.py
Create __init__.py
MY_MATH.py

Step 3. Empty/Missing __init__.py

Step 3.
CONVERSION.py
Creating
__init__.py
MYMOD.py
Create __init__.py
MY_MATH.py

Share with others.
Import into current project & use
Use later in another project.

Python does a series of actions when you import package,
Python runs the initialization file __init__.py.
The modules in the package will be imported.
Defined functions of module are now available.
Creates unique namespace for each module within
the namespace of the package.

We have already learned about “ import ” statement at the
beginning of this chapter. With this statement, the module can be
imported as whole, but only the selected objects within the module
can't be imported.
The entire Math module
can be imported.
‘Pi' is an object
defined in the math module. Partial
import is not possible with the "Import"
statement.


But it is not a
standardstyle.
Multiple Modules can be imported with one import
statement.
import my_package.MYMOD,my_package.MY_MATH

from module import component is another way
for importing modules or packages. Selected
components can be imported using this statement,
but it is not possible with the import statement.
pi (pi = 3.1415) is a constant defined in math
module. You can’t import partial components.
Output : 3.14…
Only the required objects are imported. These are imported into the
local namespace so no "namespace dot" notation is required.


Only the required objects are imported. These are imported into the
local namespace so no "namespace dot" notation is required.
It is not
possible with
“import”
Statement.
required objects are imported

Python internally does a series of actions, when we use
and executed.
Only the imported(selected) functions
and objects are available.
Does not setup a namespace for the importing
modules.

.
And use this nickname(alias) instead of real name.
The clause is used to
rename importing objects.
urllib! How I
pronounce it.
Don't worry. Rename it
as ulib while
importing it.

The clause is used to rename
importing objects.
python will
support unicode
malayalam.

The file name will not change, but will
get a nickname. Look at the red square.

The wild card(character) is a
letter (asterisk *) used in the
sense of “all functions and
objects”.
The whole math module is imported into a
new namespace. So objects are safe and
no chance for redefining objects.
All objects in the math module will be
imported into the local namespace (local
scope). So there is a chance to redefine
many of the imported items.

The base of natural logarithm "e" (Euler's No) is defined in
math. There is a chance to redefine its value by accident.

The "Import" statement loads a module into its
own namespace, so you must enter the module
name and dot before their components.
The "from… import" statement loads the module
components into the current namespace so you
can use it without mentioning the module name.

No crowds. The
module components
are kept in a separate
box.

Previously created package “my_package” contains
3 modules. MYMOD, MY_MATH & CONVERSION
How Import Works
Create namespace for the package and
create other 3 namespaces under it for each
modules (MYMOD, MY_MATH & CONVERSION).
Each objects goes to corresponding
module’s namespaces and were safe at
there. created Inside it and the objects of the
module were kept in them. Therefore these
namespaces should be given before the
object names.

How from … import Works
Exclude the namespace for my_package and create
namespace only for other 3 modules. Therefore statements
can be minimized when using module objects (components).
Output : 3

This initiative will make sense if you
find this presentation useful.
If you find any mistakes please
comment.
Namasthe

Python Modules, Packages and Libraries

More Related Content

What's hot

Similar to Python Modules, Packages and Libraries

More from Venugopalavarma Raja

Recently uploaded

Python Modules, Packages and Libraries