Python: Modules and Packages

Modules and Packages
Damian Gordon

• As we create more and more classes we need a way to
organise them in such a way to make then available and easy
to find.
• Modules in Python are simply files, if you have two files in the
same folder we can load a class from one module for use in the
other module.

• So, for example, if we are building an e-Commerce system, and
we create a single file (module) that contains all the classes
and methods related to accessing the database, then as long as
all the other necessary modules (product, customer, inventory
classes) are in the same folder, those modules can use the
database module to access the database.

• So if we put our Point class in a file (module) called:
– Pointdocstrings.py
• We can create another file (module) to include that class, by
doing the following:
import Pointdocstrings
p1 = Pointdocstrings.Point()

# PROGRAM Calling-Point-Docstrings:
import Pointdocstrings
p1.move(2,2)
p2.move(6,5)
print("CALLING: P1-x, P1-y is: ", p1.x, p1.y)
print("CALLING: Distance from P1 to P2 is:", p1.calc_distance(p2))
# END.

• When we bring Pointdocstrings into the calling
program, we say that Pointdocstrings is now part of the
calling program’s namespace (which is the list of methods and
classes available to the current program).

• If we just want to being one specific class in from a file
(module) we simple say:
from Pointdocstrings import Point
And we can declare instances as follows:
p1 = Point()

from Pointdocstrings import Point
p1 = Point()
p2 = Point()
p1.move(2,2)
p2.move(6,5)
# END.

• If we already have a class called Point in the existing
namespace, then we can use the as clause:
from Pointdocstrings import Point as Pt
And we can declare instances as follows:
p1 = Pt()

from Pointdocstrings import Point as Pt
p1 = Pt()
p2 = Pt()
p1.move(2,2)
p2.move(6,5)
# END.

• If we want to import more than one class we do:
from Pointdocstrings import Point, Line
But we should avoid doing this:
from Pointdocstrings import *

• As projects get larger and larger it becomes more and more
difficult to organise all of the modules (Python files) in a single
folder.
• To help with this issue, Python allows you to organise your
modules into sub-folders (called Packages). The name of the
package is the name of the folder.

• To achieve this we place a file called _ _init_ _.py in each
sub-folder we wish to be included in the project.
parent_directory/
main.py
Drawing/
_ _init_ _.py
point-call.py
point-docstrings.py
Maths/
_ _init_ _.py
Theorem.py

• To achieve this we place a file called _ _init_ _.py in each
sub-folder we wish to be included in the project.
parent_directory/
main.py
Drawing/
_ _init_ _.py
point-call.py
point-docstrings.py
Maths/
_ _init_ _.py
Theorem.py
_ _init_ _.py

• For the moment we are going to assume that the special files,
the _ _init_ _.py is empty.
• We can import packages in two ways, using Absolute Imports
and Relative Imports.

Modules and Packages:
Absolute Imports
• An absolute import is an IMPORT where you fully specify the
location of the classes being imported.

Absolute Imports
• We can do this in a number of ways:
import Drawing.point-call
P1 = point-call.Point()
from Drawing.point-call import Point
P1 = Point()
from Drawing import point-call

Absolute Imports
• We can do this in a number of ways:
import Drawing.point-call
from Drawing.point-call import Point
P1 = Point()
from Drawing import point-call
PACKAGE MODULE
PACKAGE MODULE CLASS
PACKAGE MODULE

Relative Imports
• Relative Imports specific the location of the classes to be
imported relative to the current package.

Relative Imports
• Relative Imports specific the location of the classes to be
imported relative to the current package.
The current directory
(package)
.
The previous directory
(package)
..

Relative Imports

Relative Imports
If Point-call.py
wants to call
Point-docstrings.py,
you can say:
from
.Point-docstrings.py
import
Point

Relative Imports
If Theorem.py
wants to call
Point-docstrings.py,
you can say:
from
..Point-docstrings.py
import
Point

Using the __init__.py
• If we wish to import code directly from a package as opposed
to a module, we can use the _ _init_ _.py.
• So lets say we want to get the Point() class from the
module Point-docstrings.py.
• From the main directory we’d have to say:
import Drawing.Point-docstrings.Point()

• If add the following code to the _ _init_ _.py in the
Drawing package:
from .Point-docstrings import Point()
• From the main directory now we can say:
import Drawing.Point()
• Instead of:
import Drawing.Point-docstrings.Point()

• And if we want to import this class into any new module, all we
have to say is:
from Drawing import Point()

• And if we want to import this class into any new module, all we
have to say is:
from Drawing import Point()
• It’s almost as if the _ _init_ _.py file converts the
Drawing package into a module!

Organizing Module Contents
• Inside a module we can specify variables, classes or methods.
• We can use modules to store global states without any
namespace conflicts.
• As well as classes, we can share global objects across a whole
system.

• If we think about an e-Commerce system again, which
connects to a database. There should be one Database class,
and one instance of a database object.
• Let’s look at the case where there are several local copies of
the database object.

• The Database module could look like:
class Database:
# The database implementation
pass
# End Database.
database1 = Database()
database.py

• And then any module could call the database as follow:
from ecommerce.database import database1

• There is potentially a problem with the previous
implementation, as soon of database.py is imported, the
database object is instantiated, if this does connect to a
database, it will cause a slight delay while the connection is
being made.
• If multiple connections are being made (multiple imports), this
will slow down the process.

• We could re-write as follows:
class Database:
# The database implementation
pass
# End Database.
database1 = None
def initialize_database():
global database1
# End initialize_database.
database.py

• Now that the variable database1 is global, all other modules
can access it.
• This prevents the system from instantiating a new database
object every time database.py is called.

• If we want to differentiate between when a module is being
called from another module, or is being called directly from the
command prompt (script), we can use the _ _main_ _
variable.
• We can do the following:

class UsefulClass:
“““This class might be useful to other modules”””
pass
# End UserfulClass.
def main():
global database1
# End main.
If _ _name_ _ == “_ _main_ _”:
main()
# Endif;
useful.py

• Up until now we have assumed that classes contain methods
and attributes, but in Python, we can have a class inside a
method.
• As follows:

def format_string(string, formatter=None):
'''Format a string using the formatter object, which is
expected to have a format() method that accepts a string.'''
class DefaultFormatter:
'''Format a string in title case.''‘
def format(self, string):
return str(string).title()
# End format.
# End Class.
Continued 

if not formatter:
formatter = DefaultFormatter()
# Endif;
return formatter.format(string)
# End format_string
hello_string = "hello world, how are you today?"
print(" input: " + hello_string)
print("output: " + format_string(hello_string))
 Continued

if not formatter:
formatter = DefaultFormatter()
# Endif;
return formatter.format(string)
# End format_string
hello_string = "hello world, how are you today?"
print(" input: " + hello_string)
print("output: " + format_string(hello_string))
input: hello world, how are you today?
output: Hello World, How Are You Today?
 Continued

• The format_string method accepts a string and optional
formatter object, which by default is set to None, so if the
method is called with no formatter, it will be treated as None.
• If no formatter is supplied, it creates a formatter of its own as a
local class and instantiates it. Since it is created inside the
scope of the function, this class cannot be accessed from
anywhere outside of that function.

Python: Modules and Packages

More Related Content

What's hot

Viewers also liked

Similar to Python: Modules and Packages

More from Damian T. Gordon

Recently uploaded

In this document

Python: Modules and Packages