Modules and packages in Python

In order to use a module, just use the import statement. Let us take an example. Python comes with numerous modules, and a very useful one is the sys module (sys stands for "system"): it provides information on the context of the run and the environment of the Python interpreter. For instance, consider the following code:

#!/local/bin/python
import sys

print "arguments: ", sys.argv
	 

./modexa.py 1 a seq.fasta
	 

arguments:  ['./modexa.py', '1', 'a', 'seq.fasta']
	 

You may also select specific components from the module:

	      from sys import argv
	      print "arguments: ", argv
          

You build your own module by creating a Python file. For instance, if the file ValSeq.py contains the following code (adapted from the Biopython ValSeq module):

	# file Valseq.py

	valid_sequence_dict = { "P1": "complete protein", \
	 "F1": "protein fragment", "DL": "linear DNA", "DC": "circular DNA", \
	 "RL": "linear RNA", "RC":"circular RNA", "N3": "transfer RNA", \
	 "N1": "other"   }

	def find_valid_key(e):
	   for key,value in valid_sequence_dict.items():
              if value == e:
                  return key
	  

you can use it by loading it:

	import ValSeq
	  

	>>> print ValSeq.valid_sequence_dict['RL']
	linear RNA
	>>> ValSeq.find_valid_key("linear RNA")
        RL
	   

Modules are mainly stored in files that are searched:

Files may be:

	Exercise 14.1. Locating modules
	Sometimes, it is not enough to use pydoc or help. Looking at the source code can bring a better understanding, even if you should of course never use undocumented features. Browse the directory tree PYTHONHOME/site-packages/Bio/.

When importing a module, the interpreter creates a new namespace, in which the Python code of the module's file is run. The interpreter also defines a variable (such as sys, ValSeq, ...) that refers to this new namespace, by which the namespace becomes available to your program (Figure 14.2).

Figure 14.1. Module namespace

open

A module is loaded only once, i.e, a second import statement will neither re-execute the code inside the module (see Python reload statement in the reference guides), nor will it re-create the corresponding namespace.

When selecting specific definitions from a module:

	      >>> from ValSeq import find_valid_key
	      >>> find_valid_key("linear RNA")
	      RL
	    

Figure 14.2. Loading specific components

This can causes errors if the definition that is imported needs to access to other definitions of the module, e.g:

	      >>> print valid_sequence_dict['RL']
	      NameError: name 'valid_sequence_dict' is not defined
	      >>> print ValSeq.valid_sequence_dict['RL']
	      NameError: name 'ValSeq' is not defined
	    

You can also load "all" the components from a module, which makes them available directly into your code:

	    >>> from ValSeq import *
	    >>> find_valid_key("linear RNA")
	  

	    >>> from string import *
	  

	Caution
	Be aware of potential names collision: for instance, if you current namespace contains a definition of a variable called, say: count, it will be destroyed and overloaded by the string module's definition of the count function.

	Caution
	You can restrict the components being imported by an import * statement. The __all__ variable, also used for packages (Section 14.2), can explicitly list the components that should be directly accessible (see Exercise 14.4).

When the file of a module is run from the command line (instead for being imported):

	    % python ValSeq.py
	  

% python -i ValSeq.py
>>> ValSeq.find_valid_key("linear RNA")
NameError: name 'ValSeq' is not defined
>>> find_valid_key("linear RNA")
'DL'
	    

	    if __name__ == '__main__':
	       # statements that you want to be executed only when the
	       # module is executed from the command line
	       # (not when importing the code by an import statement)
               print find_valid_key("linear RNA")