© 2 0 1 5 Dr . W a lte r F . d e A z e v e d o Jr . 1 000000000001111111111111111111000000001 000000000111111111111111111111111000000 000000000111111111111111111111111000000 000000000011111111111111111111100000000 000000001111111111111111111111111000000 000011111111111111111111111111111000000 001111111111111111111111111111110000000 111111111111111111111111111110000000000 111111111111111111111111111110000000000 000011111111111111111111111111111110000 001111111111111111111111111111111111000 011111111111111111111111111111111111000 001111111111111111111111111111111111100 000000011111111111111111111111111111110 000000001111111111111111111111111111110 000000000001111111111111111111111111110 000000000000011111111111111111111111110 000000000000000111111111111111111111000 000000000000000000000000001111000000000 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000000000000000000000000000000 1
Resumo
Programa para leitura de arquivo de coordenadas atômicas no formato protein
data bank (PDB). Após a leitura do arquivo PDB, o programa identifica o número
das cisteínas que participam de ligações dissulfeto. O programa usa o critério da distância entre os átomos de enxofre (SG), presentes nas cisteínas. A distância interatômica deve estar entre 2,0 e 2,1 Å, para ser considerada uma ligação dissulfeto. Só são considerados átomos SG com fator de ocupação maior que 0,5, para evitar que em estruturas que apresentam mais de uma posição para os SG, esses sejam considerados mais de uma vez. Os resultados são mostrados na tela. Cada tarefa do programa será implementada numa função específica. As coordenadas atômicas serão armazenadas em arrays da biblioteca NumPy.
Determina as ligações dissulfeto (versão 4)
Programa: ssBondPDB4.py
def find_SG_atoms(my_PDB_in):
""" Function to find SG atoms""" import numpy as np ss_x = [] ss_y = [] ss_z = [] ss_res_number = [] ss_line = []
# Looping through atoms to identify SG atoms for line in my_PDB_in:
if line[0:6] == "ATOM " and line[13:15] == "SG" and (float(line[56:60]) > 0.50) : ss_x.append(float(line[30:38]))
ss_y.append(float(line[38:46])) ss_z.append(float(line[46:54])) ss_res_number.append(line[22:26]) ss_line.append(line)
# Converts lists to arrays x = np.array(ss_x)
y = np.array(ss_y) z = np.array(ss_z)
return x, y, z, ss_line # Returns lists 3
A modificação é simples, convertemos as listas ss_x, ss_y e ss_z para arrays com a função x = np.array(ss_x), como mostrado nas linhas em vermelho abaixo.
def find_SG_atoms(my_PDB_in):
""" Function to find SG atoms""" import numpy as np
length_of_list = len(my_PDB_in) # Gets the length of the list of atoms count_atoms = 0 # Sets initial value for count_atoms
# Sets up arrays for atomic coordinates of SG and number of residue x = np.zeros(length_of_list)
y = np.zeros(length_of_list) z = np.zeros(length_of_list) ss_res_number = []
ss_line = []
# Looping through atoms to identify SG atoms for line in my_PDB_in:
if line[0:6] == "ATOM " and line[13:15] == "SG" and (float(line[56:60]) > 0.50) : x[count_atoms] = float(line[30:38]) y[count_atoms] = float(line[38:46]) z[count_atoms] = float(line[46:54]) ss_res_number.append(line[22:26]) ss_line.append(line) count_atoms += 1
return x, y, z, ss_line # Returns lists 4
Uma alternativa é definirmos os arrays de zeros e atribuirmos todos os elementos do
Resumo
Programa que aplica uma matriz rotação e um vetor translação às coordenadas atômicas de um arquivo PDB de entrada. A matriz rotação e o vetor translação serão criados a partir de arrays da biblioteca NumPy. O programa lê informações sobre uma matriz rotação e um vetor translação via teclado. A rotação e translação serão aplicadas às coordenadas atômicas do arquivo PDB de entrada, gerando novas coordenadas atômicas que serão escritas num novo arquivo PDB de saída. Os nomes dos arquivos PDB de entrada e saída são fornecidos pelo usuário. Cada tarefa do programa será implementada numa função específica.
Rotação e translação de um arquivo PDB (versão
3)
Programa: movePDB3.py
def read_rot_matrix():
"""Function to read rotation matrix""" import numpy as np
# Sets initial matrix as a NumPy array
rot_matrix = np.array( [np.zeros(3),np.zeros(3),np.zeros(3) ] )
# Looping through to read elements of a number_of_rows X number_of_columns matrix print("\nType elements of the rotation matrix")
for i in range(3) : for j in range(3) :
print("Element [",i+1,"][",j+1,"] =>", end=" ")
rot_matrix[i,j] = float(input() )
return rot_matrix # Returns array with matrix 6
No programa movePDB3.py temos que modificar as funções read_rot_matrix() e
read_vector(). Definimos a matriz de rotação, usando-se a função da biblioteca NumPy
rot_matrix = np.array( [np.zeros(3),np.zeros(3),np.zeros(3) ] ), como mostrado no
código abaixo. O loop for lê cada elemento da matriz, com o comando rot_matrix[i,j] =
def read_vector():
"""Function to read a vector""" import numpy as np
# Sets initial vector as a NumPy array
vector = np.zeros(3)
# Looping through to read vector
print("\nType the coordinates for the vector")
for i in range(3):
print("Element [",i+1,"] =>", end=" ") vector[i] = float(input())
return vector # Returns array with vector 7
Na função read_vector() usamos a definição de um array com três elementos. Usamos a função da biblioteca NumPy np.zeros(3). O loop for lê cada elemento do vetor via teclado.
Resumo
Programa para calcular a concentração e a massa de proteína dissolvida num tampão, a partir da Lei de Beer-Lambert. Os dados de entrada são absorbância para o comprimento de onda de 280 nm, o volume da amostra (L) e os nomes dos arquivos FASTA e PDB. A quantidade de cada aminoácido será lida a partir do arquivo FASTA. A massa molecular, bem como o coeficiente de extinção molecular, serão calculados a partir da informação lida dos arquivos FASTA e PDB. As ligações dissulfeto são identificadas a partir das distâncias interatômicas dos SG das cisteínas. A distância interatômica deve estar entre 2,0 e 2,1 Å, para ser considerada uma ligação dissulfeto. O programa está dividido em funções específicas para as tarefas listadas. A abordagem usada para dosar amostras foi descrita em: Pace CN, Vajdos F, Fee L, Grimsley G, Gray T. How to measure and predict the molar absorption coefficient of a protein. Protein Sci. 1995; 4(11):2411-23.
Lei de Beer Lambert (versão 6)
Programa: beerLambert6.py
# Main program
# Calls function read_FASTA()
my_seq = read_FASTA()
# Calls function read_PDB() my_PDB = read_PDB()
# Calls read spectrum_info()
my_absorbance, my_volume = read_spectrum_info()
# Calls function edit_seq(my_seq)
my_seq = edit_seq(my_seq)
# Calls calculate_mol_weight(my_seq)
my_mol_weight = calculate_mol_weight(my_seq)
# Calls function find_SG_atoms(my_PDB)
s_x, s_y, s_z, ss_lines = find_SG_atoms(my_PDB) # Calls function find_SS_bonds(s_x,s_y,s_z,ss_lines) number_SS_bonds = find_SS_bonds(s_x,s_y,s_z,ss_lines)
# Calls calc_protein_conc(my_absorbance,my_volume,my_seq,my_mol_weight,number_SS_bonds)
calc_protein_conc(my_absorbance,my_volume,my_seq,my_mol_weight,number_SS_bonds)
9
No programa beerLambert6.py usamos as funções read_PDB(), find_SG_atoms(my_PDB) e find_SS_bonds(s_x,s_y,s_z,ss_lines), vistas nos programas
def read_FASTA():
"""Function to read FASTA file"""
print("Type information about protein sequence (FASTA file).")
# Calls function read_file_name()
input_file_name = read_file_name()
# Opens PDB file
my_fo = open(input_file_name,"r")
# Reads all of the lines in a file and returns them as elements in a list
seqIn = my_fo.readlines()
return seqIn # Returns sequence
10
A função read_FASTA() usa a função read_file_name() para leitura do nome do arquivo. O único cuidado adicional que tomamos, é que colocamos uma função print(), para deixar claro ao usuário que o nome do arquivo é para sequência FASTA. Depois abrimos o arquivo e lemos as linhas com o método readlnes(). As linhas são atribuídas à variável seqIn, que é retornada pela função.
def edit_seq(my_seq_in):
"""Function to edit a sequence and converts it to a string"""
# Removes the item at the given position in the list, and return it.
my_seq_in.pop(0) # Removes first element of the list (get rid of the first line)
# Transforms list in string
seq=''.join(my_seq_in)
# Removes all "/n" from the string seq
seq = seq.replace("\n","")
# Returns sequence as string return seq
11
Para a edição da sequência, temos a função edit_seq(my_seq_in), que tem como parâmetro a lista my_seq_in. O métodos .join() e .replace() preparam a sequência, convertendo para uma string sem espaços.
def read_spectrum_info():
"""Function to read sample volume and absorbance at 280 nm for protein sample""" # Reads input data
absorbance = float(input("\nType absorbance => "))
sampleVol = float(input("\nType sample volume (liter) => "))
return absorbance, sampleVol
12
A função read_spectrum_info() realiza a leitura, via teclado, das informações sobre a absorbância e volume da amostra. Esses valores são retornados pela função.
def calculate_mol_weight(seq_in):
"""Function to calculate protein molecular weight"""
# Sets initial molecular weight variable (molWeight) to zero molWeight = 0
# Sets aaMW dictionary
aaMW = {"A": 71.0779,"R": 156.1857,"N": 114.1026,"D": 115.0874, "C": 103.1429,"E": 129.114,"Q": 128.1292,"G": 57.0513,
"H": 137.1393,"I": 113.1576,"L": 113.1576,"K": 128.1723, "M": 131.1961,"F": 147.1739,"P": 97.1152,"S": 87.0773, "T": 101.1039,"W": 186.2099,"Y": 163.1733,"V": 99.1311} # Looping through to calculate molecular weight
for aa in seq_in:
molWeight += float(aaMW.get(aa))
molWeight = molWeight + 18.0148 # Sums water molecule
return molWeight 13
A função calculate_mol_weight(seq_in) tem como parâmetro a sequência, na forma de string. A função lê os aminoácidos e usa um dicionário com as massas moleculares (aaMW), para calcular a massa molecular da proteína. À soma das massas dos aminoácidos é adicionado 18,0148, para uma molécula de água. O valor é retornado pela função.
def calc_protein_conc(absorbance_in,volume_in,seq_in,my_mol_weight_in,number_SS_bonds_in): """Function to calculate protein concentration based on Beer Lambert's Law"""
nTrp = seq_in.count("W") nTyr = seq_in.count("Y")
epsilon= 5500*nTrp +1490*nTyr + 125*number_SS_bonds_in
if epsilon > 0:
sampleConc = absorbance_in/epsilon
protMass = sampleConc*my_mol_weight_in*volume_in
print("\nResults")
print("Molar extinction coefficient\t",epsilon,"M-1cm-1" ) print("Protein concentration \t\t%5.3e"% sampleConc," M" ) print("Protein mass \t\t\t%5.3e"%protMass," g" )
else:
print("Error! Molar extinction coefficient should be > 0!" )
14
A função calc_protein_conc(absorbance_in,volume_in,seq_in,my_mol_weight_in,
number_SS_bonds_in) tem como parâmetros as informações sobre absorbância,
volume, sequência, massa molecular e número de ligações dissulfeto. Os números de triptofanos e tirosinas são lidos a partir da informação atribuída à variável seq_in. Esses dados são usados para calcular o coeficiente de extinção molar (epsilon), a massa (protMass) e a concentração da proteína (sampleConc).
def find_SS_bonds(s_x_in,s_y_in,s_z_in,ss_lines_in): """Function to find SS bonds"""
# Assigns 0 to counter of SS bonds count_SS_bonds = 0
# Assigns len(s_x_in) to counter of SG count_SG = len(s_x_in)
# Looping through the SG atoms to identify SS bonds for i in range(count_SG):
for j in range(i+1,count_SG):
distance_SS = euclidian_distance(s_x_in[i],s_y_in[i],s_z_in[i],s_x_in[j],s_y_in[j],s_z_in[j]) if distance_SS < 2.1 and distance_SS > 2.0:
count_SS_bonds += 1
print(ss_lines_in[i][22:26],"\t\t",ss_lines_in[j][22:26],"\t\t%8.3f"%distance_SS) # Shows final result
print("\nTotal number of S-S bonds : ",count_SS_bonds) # Returns the number of SS bonds
return count_SS_bonds
15
A função find_SS_bonds(s_x_in,s_y_in,s_z_in,ss_lines_in) tem uma pequena modificação, com relação à versão anterior. O valor atribuído à variável do contador de ligações dissulfeto (count_SS_bonds) é retornado da função, como indicado na linha vemelha abaixo. O restante de função é mantida.
Abaixo temos o resultado de rodarmos o código para os arquivos 1kxy.fasta e
1kxy.pdb.
Type information about protein sequence (FASTA file). Type input file name => 1kxy.fasta
Type information about protein 3D structure (PDB file). Type input file name => 1kxy.pdb
Type absorbance => 0.175
Type sample volume (liter) => 0.001 6 127 2.017
30 115 2.028 64 80 2.025 76 94 2.033
Total number of S-S bonds : 4 Results
Molar extinction coefficient 37970 M-1cm-1 Protein concentration 4.609e-06 M
Resumo
Programa para calcular o fator de vibração (B-factor) para cada resíduo de um arquivo PDB. O programa gera um gráfico do B-factor médio de cada resíduo de aminoácido. No eixo x temos os números dos resíduos e no eixo y o valor médio para cada resíduo.
Gráfico de B-factor de um arquivo PDB (versão 1)
Programa: bfactor_plot1.py
18
Para o programa bfactor_plot1.py, teremos que ler o arquivo PDB e extrair informações sobre o número de resíduos (line[22:26]) e o fator de vibração térmica (line[61:65]).
ATOM 1 N MET A 1 101.710 112.330 93.759 1.00 48.54 N
Colunas de 1-6 para string com ATOM ou HETATM, é atribuída à variável line[0:6] Colunas de 7-11 para a ordem do átomo, é atribuída à variável line[6:11]
Colunas de 14-15 para o nome do átomo, é atribuída à variável line[13:15]
Colunas de 18-20 para o nome do aminoácido (ou ligante, ou HOH), é atribuída à variável line[17:20] Coluna 22 para o identificador da cadeia, é atribuída à variável line[21:22]
Colunas 23-26 para o número do resíduo, é atribuída à variável line[22:26]
Colunas 32-53 para as coordenadas atômicas, são atribuídas às variáveis line[30:38], line[38:46], line[46:54]
Colunas 57-60 para a ocupação, é atribuída à variável line[56:60]
# Main program
# Calls function to read PDB my_list_of_atoms = read_PDB()
# Calls function to calculate mean B-factor for each residue
my_res_numbers,my_bfactors = calculate_bfactors(my_list_of_atoms)
# Calls function to plot B-factor
plot_2_arrays(my_res_numbers,my_bfactors,"Residue Number","B-factor(A**2)") 19
Abaixo temos o programa principal. Como temos que ler as informações de um arquivo PDB, usaremos a função read_PDB(), já vista nos programas anteriores. A novidade está nas funções calculate_bfactors(my_list_of_atoms) e
plot_2_arrays(my_res_numbers,my_bfactors,"Residue Number","B-factor(A**2)"). A primeira calcula o fator de vibração térmica médio para cada resíduo de aminoácido e retorna dois arrays, onde temos os números dos resíduos e os respectivos valores médios dos B-factors para cada resíduo. A última função gera o gráfico desses dois
def calculate_bfactors(list_of_atoms_in):
"""Function to calculate average B-factor for each residue""" import numpy as np
# Calculates the number of atoms in the list_of_atoms_in count_atoms = len(list_of_atoms_in)
bfactor = np.zeros(count_atoms)
residues = np.zeros(count_atoms,int) bfactor_res = np.zeros(999)
# To have different number of residue for the first iteration former_res = -9999
new_res = -9998
# Sets count_res and count_atoms to zero count_res = 0
count_atoms = 0
20
A função calculate_bfactors(my_list_of_atoms) tem como parâmetro a lista de átomos. Como a função é longa, dividiremos em vários slides.
def calculate_bfactors(list_of_atoms_in):
"""Function to calculate average B-factor for each residue""" import numpy as np
# Calculates the number of atoms in the list_of_atoms_in
count_atoms = len(list_of_atoms_in)
bfactor = np.zeros(count_atoms)
residues = np.zeros(count_atoms,int) bfactor_res = np.zeros(999)
# To have different number of residue for the first iteration
former_res = -9999 new_res = -9998
# Sets count_res and count_atoms to zero
count_res = 0 count_atoms = 0
21
# Looping through list_of_atoms_in
for line in list_of_atoms_in: if former_res == new_res: bfactor_res[count_atoms] = float(line[61:65]) new_res = int(line[22:26]) count_atoms += 1 else: new_res = int(line[22:26]) former_res = new_res if count_res > 0: bfactor[count_res] = bfactor_res[0:count_atoms].mean() residues[count_res] = count_res count_res += 1 count_atoms = 0 else:
count_res = int(line[22:26]) # Allows to get first residue
# Returns arrays
return residues[0:count_res],bfactor[0:count_res]
22
Depois temos um loop for, para a leitura dos átomos. Dentro do loop verificamos se o número do resíduo muda, o que indica que temos um novo resíduo.
# Looping through list_of_atoms_in
for line in list_of_atoms_in: if former_res == new_res: bfactor_res[count_atoms] = float(line[61:65]) new_res = int(line[22:26]) count_atoms += 1 else: new_res = int(line[22:26]) former_res = new_res if count_res > 0: bfactor[count_res] = bfactor_res[0:count_atoms].mean() residues[count_res] = count_res count_res += 1 count_atoms = 0 else:
count_res = int(line[22:26]) # Allows to get first residue
# Returns arrays
return residues[0:count_res],bfactor[0:count_res]
23
Quando terminamos de ler um resíduo, calculamos a média dos B-factors. Usamos a função .mean(), aplicada ao array bfactor_res[0:count_res], para obter o valor médio
# Looping through list_of_atoms_in
for line in list_of_atoms_in: if former_res == new_res: bfactor_res[count_atoms] = float(line[61:65]) new_res = int(line[22:26]) count_atoms += 1 else: new_res = int(line[22:26]) former_res = new_res if count_res > 0: bfactor[count_res] = bfactor_res[0:count_atoms].mean() residues[count_res] = count_res count_res += 1 count_atoms = 0 else:
count_res = int(line[22:26]) # Allows to get first residue
# Returns arrays
return residues[0:count_res],bfactor[0:count_res]
24
Restringimos o array para a faixa bfactor_res[0:count_res], para considerarmos só a faixa de valores lidos. Caso contrário teríamos zeros para interferir na média.
# Looping through list_of_atoms_in
for line in list_of_atoms_in: if former_res == new_res: bfactor_res[count_atoms] = float(line[61:65]) new_res = int(line[22:26]) count_atoms += 1 else: new_res = int(line[22:26]) former_res = new_res if count_res > 0: bfactor[count_res] = bfactor_res[0:count_atoms].mean() residues[count_res] = count_res count_res += 1 count_atoms = 0 else:
count_res = int(line[22:26]) # Allows to get first residue
# Returns arrays
return residues[0:count_res],bfactor[0:count_res]
25
def plot_2_arrays(x,y,x_label_in,y_label_in):
"""Function to plot two one-dimensional arrays""" import matplotlib.pyplot as plt
# Generates plot
plt.plot(x,y)
plt.xlabel(x_label_in) # Adds axis label plt.ylabel(y_label_in) # Adds axis label
plt.grid(True) # Adds grid to the plot
# Shows plot
plt.show()
# Saves plot on png file
plt.savefig("bfactor.png") 26
A função plot_2_arrays(x,y,x_label_in,y_label_in) gera o gráfico dos dois arrays, indicados nos parâmetros. A função usa x_label_in e y_label_in para rótulos dos eixos.
def plot_2_arrays(x,y,x_label_in,y_label_in):
"""Function to plot two one-dimensional arrays""" import matplotlib.pyplot as plt
# Generates plot
plt.plot(x,y)
plt.xlabel(x_label_in) # Adds axis label plt.ylabel(y_label_in) # Adds axis label
plt.grid(True) # Adds grid to the plot
# Shows plot
plt.show()
# Saves plot on png file
plt.savefig("bfactor.png") 27
Abaixo temos o resultado de rodarmos o código para o arquivo 1kxy.pdb. Type input file name => 1kxy.pdb
Resumo
Programa para calcular o fator de vibração (B-factor) para cada resíduo de um arquivo PDB. O programa gera um gráfico do B-factor médio de cada resíduo de aminoácido. No eixo x temos os números dos resíduos e no eixo y o valor médio do B-factor para cada resíduo. Os dados dos valores de B-factor são mostrados na forma de três linhas. Uma para o B-factor de todos os átomos de cada resíduo, outro para o B-factor médio só para os átomos da cadeia principal de cada resíduo e o último para os B-factors médios dos átomos da cadeia lateral de cada resíduo. Só serão calculados os valores médios para a parte proteica do PDB, ou seja, hetero átomos ficam de fora do gráfico.
Gráfico de B-factor de um arquivo PDB (versão 2)
Programa: bfactor_plot2.py
Num arquivo PDB, a variável variável line[13:15] é usada para indicar o nome do átomo. Para cadeia principal, temos átomos indicados pelas strings “CA”, “C “,”O “ e ”N “. O restante dos átomos é da cadeia lateral. Lembre-se de considerar só a parte proteica, ou seja, line[0:6] tem que ser igual a “ATOM “.
ATOM 1 N ALA 001 -0.541 1.336 -2.425 ATOM 2 CA ALA 001 0.178 0.132 -2.236 ATOM 6 O ALA 001 1.116 0.235 -4.429 ATOM 3 C ALA 001 1.399 0.101 -3.155 ATOM 4 O ALA 001 2.606 -0.060 -2.668 ATOM 9 CB ALA 001 -0.751 -1.285 -2.203 30
Resumo
Programa que lê um arquivo FASTA e gera um gráfico de barras, indicando a quantidade de cada tipo de resíduo de aminoácido, encontrada na sequência lida. Ou seja, o eixo x indicará os vinte aminoácidos naturais com o código de uma letra. A altura das barras do gráfico, indica quanto de cada resíduo de aminoácido foi encontrado na sequência lida do arquivo de entrada FASTA. O programa gera o arquivo bar.png. O programa usa a função plt.bar(x,y), da biblioteca Matplotlib, para gerar o gráfico de barras. À variável x, é atribuída uma lista com vinte elementos do tipo string com o código de uma letra de cada aminoácido. À variável y, é atribuído um array da biblioteca NumPy com a quantidade de cada aminoácido, encontrado na sequência lida.
Gráfico de Barras de um arquivo FASTA
Programa: plot_bar_FASTA.py
# Main program
# Calls read_FASTA() my_seq = read_FASTA()
# Calls function edit_seq(my_seq) my_seq = edit_seq(my_seq)
# Calls count_res(my_seq)
my_res_count,list_aa = count_residues(my_seq)
# Calls plot_bar()
plot_bar(list_aa,my_res_count,"Amino acid","Number of Amino Acids")
32
O código do programa principal está mostrado abaixo. Usaremos as funções
read_FASTA() e edit_seq(), vistas anteriormente. As novidades estão nas funções count_res(my_seq) e plot_bar(list_aa,my_res_count,"Amino acid","Number of Amino Acids"). A primeira simplesmente conta os aminoácidos de cada tipo, retornando o
número de cada aminoácido na forma de um array, no caso abaixo, o array é atribuído à variável my_res_count. Além disso, a função retorna a lista com os códigos de uma letra dos aminoácidos, atribuído à variável list_aa.
def plot_bar(x,y,x_label_in,y_label_in): """Function to generate bar plot""" import numpy as np import matplotlib.pyplot as plt x1 = np.arange(20) # Generates plot plt.bar(x1,y) plt.xticks(x1+0.4,x)
plt.xlabel(x_label_in) # Adds axis label plt.ylabel(y_label_in) # Adds axis label # Shows plot
plt.show()
# Saves plot on png file
plt.savefig("bar.png") 33
A função plot_bar(x,y,x_label_in,y_label_in) usa a função plt.bar(x1,y) para gerar um gráfico de barras. O array y é um dos parâmetros da função e traz o número de aminoácidos de cada tipo. O eixo x é definido com o comando plt.xticks(x1+0.4,x). Ao
array x1 é atribuído uma lista de 20 números, de 0 a 19, que serão usados na definição
da faixa do eixo x. A variável x é um parâmetro da função, ao qual foi atribuída uma lista com os códigos de uma letra (strings) dos 20 aminoácidos naturais. O código da função está mostrado abaixo. Desenvolva a função count_residues(my_seq).
-BRESSERT, Eli. SciPy and NumPy. Sebastopol: O’Reilly Media, Inc., 2013. 56 p.
-DAWSON, Michael. Python Programming, for the absolute beginner. 3ed. Boston: Course Technology, 2010. 455 p.
-HETLAND, Magnus Lie. Python Algorithms. Mastering Basic Algorithms in the Python Language. Nova York: Springer Science+Business Media LLC, 2010. 316 p.
-IDRIS, Ivan. NumPy 1.5. An action-packed guide dor the easy-to-use, high performance, Python based free open source
NumPy mathematical library using real-world examples. Beginner’s Guide. Birmingham: Packt Publishing Ltd., 2011. 212 p.
-KIUSALAAS, Jaan. Numerical Methods in Engineering with Python. 2ed. Nova York: Cambridge University Press, 2010. 422 p.
-LANDAU, Rubin H. A First Course in Scientific Computing: Symbolic, Graphic, and Numeric Modeling Using Maple, Java,
Mathematica, and Fortran90. Princeton: Princeton University Press, 2005. 481p.
-LANDAU, Rubin H., PÁEZ, Manuel José, BORDEIANU, Cristian C. A Survey of Computational Physics. Introductory
Computational Physics. Princeton: Princeton University Press, 2008. 658 p.
-LUTZ, Mark. Programming Python. 4ed. Sebastopol: O’Reilly Media, Inc., 2010. 1584 p.
-MODEL, Mitchell L. Bioinformatics Programming Using Python. Sebastopol: O’Reilly Media, Inc., 2011. 1584 p. -TOSI, Sandro. Matplotlib for Python Developers. Birmingham: Packt Publishing Ltd., 2009. 293 p.
Última atualização: 26 de junho de 2015.
