If you quit from the Python interpreter and enter it again, the definitions
you have made (functions and variables) are lost.
A D V E R T I S E M E N T
Therefore, if you want to
write a somewhat longer program, you are better off using a text editor to
prepare the input for the interpreter and running it with that file as input
instead. This is known as creating a script. As your program gets
longer, you may want to split it into several files for easier maintenance. You
may also want to use a handy function that you've written in several programs
without copying its definition into each program.
To support this, Python has a way to 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; definitions from a module can be imported
into other modules or into the main module (the collection of variables
that you have access to in a script executed at the top level and in calculator
A module is a file containing Python definitions and statements. The file
name is the module name with the suffix .py appended.
Within a module, the module's name (as a string) is available as the value of
the global variable __name__. For instance, use your favorite text
editor to create a file called fibo.py in the current
directory with the following contents:
# Fibonacci numbers module
def fib(n): # write Fibonacci series up to n
a, b = 0, 1
while b < n:
a, b = b, a+b
def fib2(n): # return Fibonacci series up to n
result = 
a, b = 0, 1
while b < n:
a, b = b, a+b
Now enter the Python interpreter and import this module with the following
>>> import fibo
This does not enter the names of the functions defined in fibo
directly in the current symbol table; it only enters the module name fibo
there. Using the module name you can access the functions:
A module can contain executable statements as well as function definitions.
These statements are intended to initialize the module. They are executed only
the first time the module is imported somewhere.
Each module has its own private symbol table, which is used as the global
symbol table by all functions defined in the module. Thus, the author of a
module can use global variables in the module without worrying about accidental
clashes with a user's global variables. On the other hand, if you know what you
are doing you can touch a module's global variables with the same notation used
to refer to its functions, modname.itemname.
Modules can import other modules. It is customary but not required to place
all import statements at the beginning of a module (or
script, for that matter). The imported module names are placed in the importing
module's global symbol table.
There is a variant of the import statement that
imports names from a module directly into the importing module's symbol table.
This imports all names except those beginning with an underscore (_).
Executing modules as scripts
When you run a Python module with
python fibo.py <arguments>
the code in the module will be executed, just as if you imported it, but with
the __name__ set to "__main__". That means that by
adding this code at the end of your module:
if __name__ == "__main__":
you can make the file usable as a script as well as an importable module,
because the code that parses the command line only runs if the module is
executed as the ``main'' file:
$ python fibo.py 50
1 1 2 3 5 8 13 21 34
If the module is imported, the code is not run:
>>> import fibo
This is often used either to provide a convenient user interface to a module,
or for testing purposes (running the module as a script executes a test suite).
The Module Search Path
When a module named
spam is imported, the interpreter searches for a file named
spam.py in the current directory, and then in the list
of directories specified by the environment variable
PYTHONPATH. This has the same
syntax as the shell variable PATH,
that is, a list of directory names. When
PYTHONPATH is not set, or when
the file is not found there, the search continues in an installation-dependent
default path; on Unix, this is usually
Actually, modules are searched in the list of directories given by the
variable sys.path which is initialized from the directory
containing the input script (or the current directory),
PYTHONPATH and the
installation-dependent default. This allows Python programs that know what
they're doing to modify or replace the module search path. Note that because the
directory containing the script being run is on the search path, it is important
that the script not have the same name as a standard module, or Python will
attempt to load the script as a module when that module is imported. This will
generally be an error. ``Standard Modules,'' for more information.
As an important speed-up of the start-up time for short programs that use a
lot of standard modules, if a file called spam.pyc
exists in the directory where spam.py is found, this
is assumed to contain an already-``byte-compiled'' version of the module
spam. The modification time of the version of
spam.py used to create spam.pyc
is recorded in spam.pyc, and the .pyc
file is ignored if these don't match.
Normally, you don't need to do anything to create the
spam.pyc file. Whenever spam.py is successfully
compiled, an attempt is made to write the compiled version to
spam.pyc. It is not an error if this attempt fails; if for any reason the
file is not written completely, the resulting spam.pyc
file will be recognized as invalid and thus ignored later. The contents of the
spam.pyc file are platform independent, so a Python
module directory can be shared by machines of different architectures.
Some tips for experts:
When the Python interpreter is invoked with the -O
flag, optimized code is generated and stored in .pyo
files. The optimizer currently doesn't help much; it only removes
assert statements. When -O
is used, all bytecode is optimized; .pyc files are
ignored and .py files are compiled to optimized bytecode.
Passing two -O flags to the Python interpreter
(-OO) will cause the bytecode compiler to perform
optimizations that could in some rare cases result in malfunctioning
programs. Currently only __doc__ strings are removed from the
bytecode, resulting in more compact .pyo files.
Since some programs may rely on having these available, you should only use
this option if you know what you're doing.
A program doesn't run any faster when it is read from a
.pyc or .pyo file than
when it is read from a .py file; the only thing
that's faster about .pyc or .pyo
files is the speed with which they are loaded.
When a script is run by giving its name on the command line, the
bytecode for the script is never written to a .pyc
or .pyo file. Thus, the startup time of a script
may be reduced by moving most of its code to a module and having a small
bootstrap script that imports that module. It is also possible to name a
.pyc or .pyo file
directly on the command line.
It is possible to have a file called spam.pyc
(or spam.pyo when -O is
used) without a file spam.py for the same module.
This can be used to distribute a library of Python code in a form that is
moderately hard to reverse engineer.
can create .pyc files (or .pyo
files when -O is used) for all modules in a
Python comes with a library of standard modules, described in a separate
Python Library Reference (``Library Reference'' hereafter). Some
modules are built into the interpreter; these provide access to operations that
are not part of the core of the language but are nevertheless built in, either
for efficiency or to provide access to operating system primitives such as
system calls. The set of such modules is a configuration option which also
depends on the underlying platform For example, the amoeba
module is only provided on systems that somehow support Amoeba primitives. One
particular module deserves some attention:
sys, which is
built into every Python interpreter. The variables sys.ps1 and
sys.ps2 define the strings used as primary and secondary prompts:
These two variables are only defined if the interpreter is in interactive
The variable sys.path is a list of strings that determines the
interpreter's search path for modules. It is initialized to a default path taken
from the environment variable
PYTHONPATH, or from a built-in default if
PYTHONPATH is not set. You can
modify it using standard list operations:
Packages are a way of structuring Python's module namespace by using ``dotted
module names''. For example, the module name A.B
designates a submodule named "B" in a package named "A".
Just like the use of modules saves the authors of different modules from having
to worry about each other's global variable names, the use of dotted module
names saves the authors of multi-module packages like NumPy or the Python
Imaging Library from having to worry about each other's module names.
Suppose you want to design a collection of modules (a ``package'') for the
uniform handling of sound files and sound data. There are many different sound
file formats (usually recognized by their extension, for example:
.au), so you may need to create and maintain a growing
collection of modules for the conversion between the various file formats. There
are also many different operations you might want to perform on sound data (such
as mixing, adding echo, applying an equalizer function, creating an artificial
stereo effect), so in addition you will be writing a never-ending stream of
modules to perform these operations. Here's a possible structure for your
package (expressed in terms of a hierarchical filesystem):
sound/ Top-level package
__init__.py Initialize the sound package
formats/ Subpackage for file format conversions
effects/ Subpackage for sound effects
filters/ Subpackage for filters
When importing the package, Python searches through the directories on
sys.path looking for the package subdirectory.
The __init__.py files are required to make Python
treat the directories as containing packages; this is done to prevent
directories with a common name, such as "string", from
unintentionally hiding valid modules that occur later on the module search path.
In the simplest case, __init__.py can just be an empty
file, but it can also execute initialization code for the package or set the
__all__ variable, described later.
Users of the package can import individual modules from the package, for
This loads the submodule sound.effects.echo. It must
be referenced with its full name.
Yet another variation is to import the desired function or variable directly:
from sound.effects.echo import echofilter
Again, this loads the submodule echo, but this makes
its function echofilter() directly available:
echofilter(input, output, delay=0.7, atten=4)
Note that when using from package import item,
the item can be either a submodule (or subpackage) of the package, or some other
name defined in the package, like a function, class or variable. The
import statement first tests whether the item is defined in the package;
if not, it assumes it is a module and attempts to load it. If it fails to find
it, an ImportError exception is raised.
Contrarily, when using syntax like import item.subitem.subsubitem,
each item except for the last must be a package; the last item can be a module
or a package but can't be a class or function or variable defined in the
Importing * From a Package
Now what happens when the user writes
from sound.effects import *? Ideally, one would hope that this
somehow goes out to the filesystem, finds which submodules are present in the
package, and imports them all. Unfortunately, this operation does not work very
well on Windows platforms, where the filesystem does not always have accurate
information about the case of a filename! On these platforms, there is no
guaranteed way to know whether a file ECHO.PY should
be imported as a module echo, Echo
or ECHO. (For example, Windows 95 has the annoying
practice of showing all file names with a capitalized first letter.) The DOS 8+3
filename restriction adds another interesting problem for long module names.
The only solution is for the package author to provide an explicit index of
the package. The import statement uses the following convention: if a package's
__init__.py code defines a list named __all__,
it is taken to be the list of module names that should be imported when
from package import * is encountered. It is up to the package
author to keep this list up-to-date when a new version of the package is
released. Package authors may also decide not to support it, if they don't see a
use for importing * from their package. For example, the file
sounds/effects/__init__.py could contain the following code:
__all__ = ["echo", "surround", "reverse"]
This would mean that from sound.effects import * would import
the three named submodules of the sound package.
If __all__ is not defined, the statement from
sound.effects import * does not import all submodules from the
package sound.effects into the current namespace; it
only ensures that the package sound.effects has been
imported (possibly running any initialization code in
__init__.py) and then imports whatever names are defined in the package.
This includes any names defined (and submodules explicitly loaded) by
__init__.py. It also includes any submodules of the
package that were explicitly loaded by previous import statements. Consider this
from sound.effects import *
In this example, the echo and surround modules are imported in the current
namespace because they are defined in the sound.effects
package when the from...import statement is executed. (This also
works when __all__ is defined.)
Note that in general the practice of importing * from a module
or package is frowned upon, since it often causes poorly readable code. However,
it is okay to use it to save typing in interactive sessions, and certain modules
are designed to export only names that follow certain patterns.
Remember, there is nothing wrong with using from Package import
specific_submodule! In fact, this is the recommended notation unless the
importing module needs to use submodules with the same name from different
The submodules often need to refer to each other. For example, the
surround module might use the echo
module. In fact, such references are so common that the
import statement first looks in the containing package before looking in
the standard module search path. Thus, the surround
module can simply use import echo or from echo import
echofilter. If the imported module is not found in the current package
(the package of which the current module is a submodule), the
import statement looks for a top-level module with the
When packages are structured into subpackages (as with the
sound package in the example), you can use absolute imports to refer to
submodules of siblings packages. For example, if the module
sound.filters.vocoder needs to use the echo module
in the sound.effects package, it can use from
sound.effects import echo.
Starting with Python 2.5, in addition to the implicit relative imports
described above, you can also write explicit relative imports with the
from module import name form of import statement. These explicit relative
imports use leading dots to indicate the current and parent packages involved in
the relative import. From the surround module for
example, you might use:
from . import echo
from .. import formats
from ..filters import equalizer
Note that both explicit and implicit relative imports are based on the name
of the current module. Since the name of the main module is always
"__main__", modules intended for use as the main module of a Python
application should always use absolute imports.
Packages support one more special attribute, __path__.
This is initialized to be a list containing the name of the directory holding
the package's __init__.py before the code in that file
is executed. This variable can be modified; doing so affects future searches for
modules and subpackages contained in the package.
While this feature is not often needed, it can be used to extend the set of
modules found in a package.