What are Modules?
 Modules are files containing Python definitions
and statements (ex. name.py)
 A module’s definitions can be imported into
other modules by using “import name”
 The module’s name is available as a global
variable value
 To access a module’s functions, type
“name.function()”
Modules…
 A module allows you to logically organize your
Python code. Grouping related code into a
module makes the code easier to understand and
use.
 A module is a Python object with arbitrarily
named attributes that you can bind and
reference.
Program using Module
 The Python code for a module named
printfunction normally resides in a file
named printfunction.py.
 Here's an example of a simple module,
printfunction.py
def print_func( param ):
print ("Hello : ", param)
return
More on Modules
 Modules can contain executable statements along with
function definitions
 Each module has its own private symbol table used as
the global symbol table by all functions in the module
 Modules can import other modules
 Each module is imported once per interpreter session
 reload(name)
 Can import names from a module into the importing
module’s symbol table
 from mod import m1, m2 (or *)
 m1()
From…import statement
 Python's from statement lets you import specific
attributes from a module into the current namespace.
The from...import has the following syntax:
from modname import name1[,name2[,….nameN]]
For example, to import the function fibonacci from the
module fib, use the following statement
from fib import Fibonacci
This statement does not import the entire module fib
into the current namespace; it just introduces the item
fibonacci from the module fib into the global symbol
table of the importing module.
From …import * Statement
 It is also possible to import all names from a
module into the current namespace by using the
following import statement
 from modname import *
Executing Modules
 python name.py <arguments>
 Runs code as if it was imported
 Setting _name_ == “_main_” the file can be used as
a script and an importable module
The Module Search Path
 The interpreter searches for a file named
name.py
 Current directory given by variable sys.path
 List of directories specified by PYTHONPATH
 Default path (in UNIX - .:/usr/local/lib/python)
 Script being run should not have the same name
as a standard module or an error will occur
when the module is imported
“Compiled” Python Files
 If files mod.pyc and mod.py are in the same directory,
there is a byte-compiled version of the module mod
 The modification time of the version of mod.py used
to create mod.pyc is stored in mod.pyc
 Normally, the user does not need to do anything to
create the .pyc file
 A compiled .py file is written to the .pyc
 No error for failed attempt, .pyc is recognized as invalid
 Contents of the .pyc can be shared by different
machines
Standard Modules
 Python comes with a library of standard modules described
in the Python Library Reference
 Some are built into interpreter
 >>> import sys
>>> sys.s1
‘>>> ‘
>>> sys.s1 = ‘c> ‘
c> print ‘Hello’
Hello
c>
 sys.path determines the interpreters’s search path for
modules, with the default path taken from PYTHONPATH
 Can be modified with append() (ex.
Sys.path.append(‘SOMEPATH’)
The dir() Function
 Used to find the names a module defines and returns
a sorted list of strings
 >>> import mod
>>> dir(mod)
[‘_name_’, ‘m1’, ‘m2’]
 Without arguments, it lists the names currently
defined (variables, modules, functions, etc)
 Does not list names of built-in functions and
variables
 Use _bulltin_to view all built-in functions and variables
Packages
 “dotted module names” (ex. a.b)
 Submodule b in package a
 Saves authors of multi-module packages from worrying
about each other’s module names
 Python searches through sys.path directories for the
package subdirectory
 Users of the package can import individual modules from
the package
 Ways to import submodules
 import sound.effects.echo
 from sound.effects import echo
 Submodules must be referenced by full name
 An ImportError exception is raised when the package
cannot be found
Importing * From a Package
 * does not import all submodules from a package
 Ensures that the package has been imported,
only importing the names of the submodules
defined in the package
 import sound.effects.echo
import sound.effects.surround
from sound.effects import *
Intra-package References
 Submodules can refer to each other
 Surround might use echo module
 import echo also loads surround module
 import statement first looks in the containing package
before looking in the standard module search path
 Absolute imports refer to submodules of sibling
packages
 sound.filters.vocoder uses echo module
from sound.effects import echo
 Can write explicit relative imports
 from . import echo
 from .. import formats
 from ..filters import equalizer
Packages in Multiple
Directories
 _path_ is a list containing the name of the
directory holding the package’s _init_.py
 Changing this variable can affect futute searches
for modules and subpackages in the package
 Can be used to extend the set of modules in a
package
 Not often needed
Sources
 http://docs.python.org/tutorial/modules.html