2015 Dr. Walter F. de Azevedo Jr.

Transcrição

1 2015 Dr. Walter F. de Azevedo Jr

2 Programa: ssbondpdb4.py Determina as ligações dissulfeto (versão 4) Programa: ssbondpdb4.py 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 2 coordenadas atômicas serão armazenadas em arrays da biblioteca NumPy.

3 Programa: ssbondpdb4.py 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 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

4 Programa: ssbondpdb5.py Uma alternativa é definirmos os arrays de zeros e atribuirmos todos os elementos do array no loop for, como mostrado abaixo. O tamanho do array e obtido com o len(). 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

5 Programa: movepdb3.py Rotação e translação de um arquivo PDB (versão 3) Programa: movepdb3.py 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. 5

6 Programa: movepdb3.py 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] = float(input() ). 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

7 Programa: movepdb3.py 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. 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

8 Programa: beerlambert6.py Lei de Beer Lambert (versão 6) Programa: beerlambert6.py 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):

9 Programa: beerlambert6.py 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 anteriores. As novas funções estão indicadas em vermelho abaixo. # 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

10 Programa: beerlambert6.py 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 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

11 Programa: beerlambert6.py 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 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

12 Programa: beerlambert6.py 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 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

13 Programa: beerlambert6.py 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 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": ,"R": ,"N": ,"D": , "C": ,"E": ,"Q": ,"G": , "H": ,"I": ,"L": ,"K": , "M": ,"F": ,"P": ,"S": , "T": ,"W": ,"Y": ,"V": } # Looping through to calculate molecular weight for aa in seq_in: molweight += float(aamw.get(aa)) molweight = molweight # Sums water molecule return molweight 13

14 Programa: beerlambert6.py 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 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

15 Programa: beerlambert6.py 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. 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

16 Programa: beerlambert6.py 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 => Type sample volume (liter) => Total number of S-S bonds : 4 Results Molar extinction coefficient M-1cm-1 Protein concentration 4.609e-06 M Protein mass 6.596e-05 g 16

17 Programa: bfactor_plot1.py Gráfico de B-factor de um arquivo PDB (versão 1) Programa: bfactor_plot1.py 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. 17

18 Programa: bfactor_plot1.py 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]). Colunas para o fator de vibração térmica, é atribuída à variável line[61:65] ATOM 1 N MET A N Colunas para a ocupação, é atribuída à variável line[56:60] Colunas para as coordenadas atômicas, são atribuídas às variáveis line[30:38], line[38:46], line[46:54] Colunas para o número do resíduo, é atribuída à variável line[22:26] Coluna 22 para o identificador da cadeia, é atribuída à variável line[21:22] Colunas de para o nome do aminoácido (ou ligante, ou HOH), é atribuída à variável line[17:20] Colunas de para o nome do átomo, é atribuída à variável line[13:15] Colunas de 7-11 para a ordem do átomo, é atribuída à variável line[6:11] Colunas de 1-6 para string com ATOM ou HETATM, é atribuída à variável line[0:6] 18

19 Programa: bfactor_plot1.py 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 arrays. Nos próximos slides veremos as funções. # 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

20 Programa: bfactor_plot1.py 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 = new_res = # Sets count_res and count_atoms to zero count_res = 0 count_atoms = 0 20

21 Programa: bfactor_plot1.py Inicialmente criamos arrays e contadores de átomos e resíduos, como indicado abaixo. 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 = new_res = # Sets count_res and count_atoms to zero count_res = 0 count_atoms = 0 21

22 Programa: bfactor_plot1.py 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: else: bfactor_res[count_atoms] = float(line[61:65]) new_res = int(line[22:26]) count_atoms += 1 new_res = int(line[22:26]) former_res = new_res if count_res > 0: else: bfactor[count_res] = bfactor_res[0:count_atoms].mean() residues[count_res] = count_res count_res += 1 count_atoms = 0 count_res = int(line[22:26]) # Allows to get first residue # Returns arrays return residues[0:count_res],bfactor[0:count_res] 22

23 Programa: bfactor_plot1.py 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: else: bfactor_res[count_atoms] = float(line[61:65]) new_res = int(line[22:26]) count_atoms += 1 new_res = int(line[22:26]) former_res = new_res if count_res > 0: else: bfactor[count_res] = bfactor_res[0:count_atoms].mean() residues[count_res] = count_res count_res += 1 count_atoms = 0 count_res = int(line[22:26]) # Allows to get first residue # Returns arrays return residues[0:count_res],bfactor[0:count_res] 23

24 Programa: bfactor_plot1.py 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: else: bfactor_res[count_atoms] = float(line[61:65]) new_res = int(line[22:26]) count_atoms += 1 new_res = int(line[22:26]) former_res = new_res if count_res > 0: else: bfactor[count_res] = bfactor_res[0:count_atoms].mean() residues[count_res] = count_res count_res += 1 count_atoms = 0 count_res = int(line[22:26]) # Allows to get first residue # Returns arrays return residues[0:count_res],bfactor[0:count_res] 24

25 Programa: bfactor_plot1.py Por último, a função retorna os arrays residues[0:count_res],bfactor[0:count_res]. # 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

26 Programa: bfactor_plot1.py 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) plt.ylabel(y_label_in) plt.grid(true) # Adds axis label # Adds axis label # Adds grid to the plot # Shows plot plt.show() # Saves plot on png file plt.savefig("bfactor.png") 26

27 Programa: bfactor_plot1.py O gráfico é salvo no arquivo bfactor.png, como indicado na última linha. 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) plt.ylabel(y_label_in) plt.grid(true) # Adds axis label # Adds axis label # Adds grid to the plot # Shows plot plt.show() # Saves plot on png file plt.savefig("bfactor.png") 27

28 Programa: beerlambert6.py Abaixo temos o resultado de rodarmos o código para o arquivo 1kxy.pdb. Type input file name => 1kxy.pdb 28

29 Programa: bfactor_plot2.py Gráfico de B-factor de um arquivo PDB (versão 2) Programa: bfactor_plot2.py 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. 29

30 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 9 CB ALA ATOM 4 O ALA ATOM 3 C ALA ATOM 6 O ALA ATOM 2 CA ALA ATOM 1 N ALA

31 Programa: histo_fasta.py Gráfico de Barras de um arquivo FASTA Programa: plot_bar_fasta.py 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. 31

32 Programa: plot_bar_fasta.py 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. # 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

33 Programa: plot_bar_fasta.py 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). 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) plt.ylabel(y_label_in) # Adds axis label # Adds axis label # Shows plot plt.show() # Saves plot on png file plt.savefig("bar.png") 33

34 Referências -BRESSERT, Eli. SciPy and NumPy. Sebastopol: O Reilly Media, Inc., p. -DAWSON, Michael. Python Programming, for the absolute beginner. 3ed. Boston: Course Technology, p. -HETLAND, Magnus Lie. Python Algorithms. Mastering Basic Algorithms in the Python Language. Nova York: Springer Science+Business Media LLC, 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., p. -KIUSALAAS, Jaan. Numerical Methods in Engineering with Python. 2ed. Nova York: Cambridge University Press, 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, p. -LANDAU, Rubin H., PÁEZ, Manuel José, BORDEIANU, Cristian C. A Survey of Computational Physics. Introductory Computational Physics. Princeton: Princeton University Press, p. -LUTZ, Mark. Programming Python. 4ed. Sebastopol: O Reilly Media, Inc., p. -MODEL, Mitchell L. Bioinformatics Programming Using Python. Sebastopol: O Reilly Media, Inc., p. -TOSI, Sandro. Matplotlib for Python Developers. Birmingham: Packt Publishing Ltd., p. Última atualização: 26 de junho de