9 Modules and Packages

9.1 Exercises

9.1.1 Exercise

Implement a matrix and functions to handle it. choose the data structure of your choice. The API (Application Programming Interface) to implement is the following:

We propose 2 implementations. These 2 implementations work with a list of lists as matrix modelling. But it is possible to implement it with a single list or a dict of list, …

The first implementation follow the api used explicit name for inner variables and good documentation.

"""
Implementation of simple matrix 
"""


def create(row_num, col_num, val=None):
	"""
	:param row_num: the number of rows
	:type row_num: int
	:param col_num: the number of columns
	:type col_num: int
	:param val: the default value to fill the matrix
	:type val: any (None by default)
	:return: matrix of rows_num x col_num
	:rtype: matrix
	"""
	matrix = []
	for i in range(col_num):
		col = [val] * row_num
		matrix.append(col)
	return matrix


def _check_index(matrix, row_no, col_no):
	"""
	check if row_no and col_no are in matrix bound
	
	:param matrix: the matrix to compute the size
	:type matrix: matrix
	:param rows_no: the index of row to check
	:type rows_no: int
	:param col_no: the index of column to check
	:type col_no: int
	:raise: IndexError if row_no or col_no are out of matrix bounds
	""" 
	row_max, col_max = size(matrix)
	if (row_no < 0 or row_no >= row_max) or (col_no < 0 or col_no >= col_max):
		raise IndexError("matrix index out of range")
	
	
def size(matrix):
	"""
	:param matrix: the matrix to compute the size
	:type matrix: matrix
	:return: the size of matrix (number of rows, number of cols)
	:rtype: typle of 2 int
	"""
	return len(matrix[0]), len(matrix)


def get_cell(matrix, row_no, col_no):
	"""
	:param matrix: the matrix 
	:type matrix: matrix
	:param rows_no: the row number
	:type rows_no: int
	:param col_no: the column number
	:type col_no: int
	:retrun: the content of cell corresponding to row_no x col_no
	:rtype: any
	"""
	_check_index(matrix, row_no, col_no)
	return matrix[col_no][row_no]


def set_cell(matrix, row_no, col_no, val):
	"""
	set the value val in cell specified by row_no x col_no
	
	:param matrix: the matrix to modify
	:type matrix: matrix
	:param row_no: the row number of cell to set
	:type rows_no: int
	:param col_no: the column number of cell to set
	:type col_no: int
	:param val: the value to set in cell 
	:type val: int
	"""
	_check_index(matrix, row_no, col_no)
	matrix[col_no][row_no] = val


def to_str(matrix):
	"""
	:param matrix: the matrix to compute the size
	:type matrix: matrix
	:return: a string representation of the matrix
	:rtype: str
	"""
	s = ""
	# by design all matrix cols have same size
	for row in zip(*matrix):
		cells = [str(cell) for cell in row]
		s += "\t".join(cells) + "\n"
	return s


def mult(matrix, val):
	"""
	:param matrix: the matrix
	:type matrix: matrix
	:param val: the value to mult the matrix with
	:type val: int
	:return: a new matrix corresponding the scalar product of matrix * val
	:rtype: matrix
	"""
	new_matrix = []
	for col in matrix:
		new_col = [cell * val for cell in col]
		new_matrix.append(new_col)
	return new_matrix


def mult_inplace(matrix, val):
	"""
	compute the scalar product of a matrix and a value
	do this operation in place

	:param matrix: the matrix
	:type matrix: matrix
	:param val: the value to mult the matrix with
	:type val: int
	"""
	for col in matrix:
		for row_nb, cell in enumerate(col):
			col[row_nb] = cell * val


def get_row(matrix, row_no):
	"""
	:param matrix: the matrix to compute the size
	:type matrix: matrix
	:param rows_no: row number
	:type rows_no: int
	:return: the row of matrix corresponding to row_no
	         a shallow copy of the row
	:rtype: list
	"""
	_check_index(matrix, row_no, 0)
	row_max, col_max = size(matrix)
	row = []
	for col_n in range(col_max):
		row.append(get_cell(matrix, row_no, col_n))
	return row
	
	
def set_row(matrix, row_no, val):
	"""
	set all cells of row row_no with val
	
	:param matrix: the matrix to modify
	:type matrix: matrix
	:param row_no: the row number
	:type row_no: int
	:param val: the value to put in cells
	:type val: any
	"""
	_check_index(matrix, row_no, 0)
	row_max, col_max = size(matrix)
	for col_n in range(col_max):
		set_cell(matrix, row_no, col_n, val)


def get_col(matrix, col_no):
	"""
	:param matrix: the matrix get row
	:type matrix: matrix
	:param col_no: the column number
	:type col_no: int
	:return: the column corresponding to col_no of matrix
	         a shallow copy of the col
	:rtype: list
	"""
	_check_index(matrix, 0, col_no)
	col = matrix[col_no][:]
	return col
	
	
def set_col(matrix, col_no, val):
	"""
	set all cells of col col_no with val
	
	:param matrix: the matrix to compute the size
	:type matrix: matrix
	:param col_no: the column number
	:type col_no: int
	:param val: the value to put in cells
	:type val: any
	"""
	_check_index(matrix, 0, col_no)
	for row_n in range(matrix):
		set_cell(matrix, row_n, col_no, val)


def replace_col(matrix, col_no, col):
	"""
	replace column col_no with col
	
	:param matrix: the matrix to compute the size
	:type matrix: matrix
	:param col_no: the column number to replace
	:type col_no: int
	:param col: the list of values to use as replacement of column 
	:type col: list
	"""
	row_max, col_max = size(matrix)
	if len(col) != col_max:
		raise RuntimeError("the size of col {0} does not fit to matrix size {1}x{2}".format(len(col),
																						row_max,
																						col_max))
	_check_index(matrix, 0, col_no)
	matrix[col_no] = col


def replace_row(matrix, row_no, row):
	"""
	replace row row_no with row
	
	:param matrix: the matrix to compute the size
	:type matrix: matrix
	:param row_no: the column number
	:type row_no: int
	:param row: the list of value to use as replacement of row 
	:type row: list
	"""
	row_max, col_max = size(matrix)
	if len(row) != row_max:
		raise RuntimeError("the size of row {0} does not fit to matrix size {1}x{2}".format(len(row),
																							row_max,
																							col_max))
	_check_index(matrix, row_no, 0)
	for col_no, value in enumerate(row):
		set_cell(matrix, row_no, col_no, value)


if __name__ == '__main__':
	m = create(5, 3)
	print(m)
	set_cell(m, 0, 0, 1)
	set_cell(m, 0, 2, 2)
	set_cell(m, 4, 0, 12)
	set_cell(m, 4, 2, 15)
	print(to_str(m))
	print("get row 0",  get_row(m, 0))
	print("get col 0", get_col(m, 0))

	m2 = create(3, 2, 4)
	mult_inplace(m2, 2)
	print(to_str(m2))

matrix.py .

But the problem with this implementation is, if we decide to change the inner model for a dixt of list for instance. We must reimplements most of the functions.

In the following implementation we have only 4 functions that handle directly the lists. All other functions manipulate the matrix through these 4 functions. So if we change the inner model we will have to modifiy only these functions. This implementation will be more maintainable.

But this implementation use one letter names for inner variables and is poorly documented which not help to maintain or develop with this.

The Best solution should be the second implementation but with the name of variables and documentation as in the firsr implementation.

# matrix is implemented by list of list
def matrix_maker(ligne, col, val=None):
	m = []
	for i in range(ligne):
		c = [val] * col
		m.append(c)
	return m

#---- functions that depends on the matrix srtructure 

def matrix_size(m):
	return len(m), len(m[0])

def matrix_get(matrix, i, j):
	_check_matindex(matrix, i, j)
	return matrix[i][j]

def matrix_set(matrix, i, j, val):
	_check_matindex(matrix,i,j)
	matrix[i][j] = val

def to_str(m):
	m_str = []
	for row in m:
		m_str.append('\t'.join([str(cell) for cell in row]))
	m_str = '\n'.join(m_str)
	return m_str



#---- independant regarding matrix structure  
def _check_matindex(matrix,i,j):
	imax, jmax = matrix_size(matrix)
	if (i < 0 or i >= imax) or (j < 0 or j >= jmax):
		raise IndexError("matrix index out of range")


def matrix_get_line(matrix, i):
	_check_matindex(matrix,i,0)
	im, jm = matrix_size(matrix)
	line = []
	for n in range(jm):
		line.append(matrix_get(matrix, i, n))
	return line


def matrix_set_line(matrix, i, val):
	_check_matindex(matrix,i,0)
	im, jm = matrix_size(matrix)
	for n in range(jm):
		matrix_set(matrix, i, n, val)


def matrix_get_col(matrix, j):
	_check_matindex(matrix,0,j)
	im, jm = matrix_size(matrix)
	col = []
	for n in range(im):
		col.append(matrix_get(matrix, n, j))
	return col


def matrix_set_col(matrix, j, val):
	_check_matindex(matrix,0,j)
	im, jm = matrix_size(matrix)
	for n in range(im):
		matrix_set(matrix, n, j, val)
	

if __name__ == '__main__':
	m = matrix_maker(5, 3)
	matrix_set(m,0, 0, 1)
	matrix_set(m,0, 2, 2)
	matrix_set(m,4, 0, 12)
	matrix_set(m,4, 2, 15)
	print(to_str(m))
	print("get line 0",  matrix_get_line(m, 0))
	print("get col 0", matrix_get_col(m, 0))

matrix2.py .

9.1.2 Exercise

Write a program that calculates the similarity of 2 RNA sequences.

• To compute the simalirity you need to parse a file containing the similarity matrix. Hint: use the module containing the functions that handle a matrix from previous chapter. put this matrix.py file in a directory named “my_python_lib” in your home or Desktop and import it in your current program (the similarity script must be placed elsewhere).

• The similarity of the 2 sequences is the sum of base similarities. so you have to compare the first base of two sequences and use the matrix to get the similarity from the similarity table, on so on for all bases then sum these similarities.

import sys
import os.path

sys.path.insert(0, os.path.join(expanduser('~'), "my_python_lib"))

import matrix


def parse_similarity_file(path):
    """
    parse file containing RNA similarity matrix and return a matrix
    """
    sim_matrix = matrix.create(4, 4)
    with open(path, 'r') as sim_file:
        #skip first line
        next(sim_file)
        for row_no, line in enumerate(sim_file):
            line = line.strip()
            fields = line.split()
            values = [float(val) for val in fields[1:]]
            matrix.replace_row(sim_matrix, row_no, values)
    return sim_matrix


def get_similarity(b1, b2, sim_matrix):
    """
    :param b1: the first base must be in ('A', 'G', 'C', 'U')
    :type b1: string
    :param b2: the first base must be in ('A', 'G', 'C', 'U')
    :type b2: string
    :param sim_matrix: a similarity matrix
    :type sim_matrix: matrix
    :return: the similarity between b1 and b2
    :rtype: float
    """
    bases = {'A':0 , 'G':1, 'C':2, 'U':3}
    b1 = b1.upper()
    b2 = b2.upper()
    if not b1 in bases:
        raise KeyError("unknown base b1: " + str(b1))
    if not b2 in bases:
        raise KeyError("unknown base b2: " + str(b2))
    return matrix.get_cell(sim_matrix, bases[b1], bases[b2])
                      
                           
def compute_similarity(seq1, seq2, sim_matrix):
    """
    compute a similarity score between 2 RNA sequence of same lenght
    :param seq1: first sequence to compare
    :type seq1: string
    :param seq2: second sequence to compare
    :type seq2: string
    :param sim_matrix: the similarity between b1 and b2
    :type sim_matrix: matrix
    :return: the similarity score between seq1 and seq2
    :rtype: float
    """
    similarities = []
    for b1, b2 in zip(seq1, seq2):
        sim = get_similarity(b1, b2, sim_matrix)
        similarities.append(sim)
    return sum(similarities)
       
            
if __name__ == '__main__':
    seq1 = 'AGCAUCUA'
    seq2 = 'ACCGUUCU'
    sim_matrix = parse_similarity_file("similarity_matrix")
    print matrix.to_str(sim_matrix)
    similarity = compute_similarity(seq1, seq2, sim_matrix)
    print similarity
            

similarity.py .