linguagem de programação python - azevedolab.net · até o momento vimos dados do tipo...

©2

01

6 D

r. W

alte

r F.

de

Aze

ve

do

Jr.

1

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000111111111100000000000000000000000000001111110000000000110000000000000110000001111100000000111110000000000001000011001111111111111111000000000000010001110110001111111000000000000000000011111111111111111111111110000000001111111111111111111111111111110000000000111111111111111111111111110000000000000000111111111111111111111000000000000000000111111111111111110000000000000000000000111111111111111111110000000000000000001111101111111111111111000000000000000001111100111111111111111000000000000000000000111111111111110011100000000000000000000001111111110111111100000000000000000000001110000011101100000000000000000000000000000011111001100000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

azevedolab.net

2

Estrutura de Dados em Python

www.python.org

Até o momento vimos dados do tipo sequência, que são strings e números, bem como

listas, que são formas de colocarmos um conjunto de dados e relacioná-los com sua

posição numa lista, por exemplo, à variável my_list foi atribuída uma lista com o código

de três letras para os aminoácidos, como segue:

Assim, se quisermos mostrar todo o conteúdo atribuído à variável my_list, basta

usarmos um loop for e colocarmos uma função print(), como mostrado abaixo.

A execução do código mostrará um aminoácido por linha, o arquivo showAA1.py tem o

código do programa.

my_list =["ALA","ARG","ASN","ASP","CYS","GLU","GLN","GLY","HIS","ILE",

"LEU","LYS","MET","PHE","PRO","SER","THR","TRP","TYR","VAL"]

for aa in my_list:

print(aa)

3


www.python.org

Outra estrutura de dados disponível em Python é chamada dicionário. Funciona com

se fosse um dicionário comum, onde temos associada a um verbete uma definição.

Assim, na definição de um dicionário em Python, teremos pares, onde para uma

chave colocada à esquerda, teremos um valor à direita. Vejamos um exemplo, o

dicionário my_dict tem o código de uma letra para os aminoácidos (chaves) e, à cada

chave, foi atribuída uma string com o código de três letras (valor), como indicado

abaixo:

Cada definição do dicionário é chamada de item, assim temos 20 itens em my_dict.

Para chamarmos uma definição do dicionário, podemos usar a chave para recuperar o

valor, como segue:

A função print(my_dict[“A”]) mostrará o valor atribuído à string “A”, ou seja, “ALA”.

my_dict ={"A": "ALA","R": "ARG","N": "ASN","D": "ASP",

"C": "CYS","E": "GLU","Q": "GLN","G": "GLY",

"H": "HIS","I": "ILE","L": "LEU","K": "LYS",

"M": "MET","F": "PHE","P": "PRO","S": "SER",

"T": "THR","W": "TRP","Y": "TYR","V": "VAL“

}

print(my_dict[“A”])

4


www.python.org

Vejamos o programa showAA2.py, que mostra os valores associados às chaves que

trazem os códigos de uma letra.

No código temos a lista my_list com os aminoácidos, com o código de uma letra. No

dicionário, temos associado à cada código de uma letra o valor com a string com três

letras. O loop for mostra para cada chave lida da lista my_list, o valor associado. O

resultado é que temos os códigos de três letras para cada aminoácido mostrado na

tela. Veja que na formação de qualquer dicionário, sempre temos um elemento à

esquerda, chamado de chave, separado por dois pontos (:), associado a um valor, que

pode ser um número, string ou lista.

# Program to demonstrate the use of dictionaries in Python

# Dictionary for amino acid

my_dict ={"A": "ALA","R": "ARG","N": "ASN","D": "ASP",

"C": "CYS","E": "GLU","Q": "GLN","G": "GLY",

"H": "HIS","I": "ILE","L": "LEU","K": "LYS",

"M": "MET","F": "PHE","P": "PRO","S": "SER",

"T": "THR","W": "TRP","Y": "TYR","V": "VAL"}

# List of amino acids (one-letter code)

my_list =["A","R","N","D","C","E","Q","G","H","I",

"L","K","M","F","P","S","T","W","Y","V"]

# Loop for to show the three-letter codes for amino acids

for aa in my_list:

print(my_dict[aa])

5


www.python.org

Dicionários, como as listas, são de uso comum em programas desenvolvidos para

bioinformática. Veremos um programa para calcular a massa molecular de uma

proteína, a partir da leitura da sua sequência de aminoácidos, armazenada num

arquivo FASTA. O programa fará uso do seguinte dicionário.

Veja, na definição de um dicionário em Python, podemos deixar todos os itens numa

linha somente, ou pularmos linhas, como no exemplo acima. Fica a critério do

programador.

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

}

Resumo

Programa para calcular a massa molecular de proteínas, a partir da sequência

lida de um arquivo no formato FASTA. O usuário fornecerá o nome do arquivo

FASTA. O programa calcula a massa molecular, a partir da informação sobre a

estrutura primária da proteína. Será usado um dicionário, para armazenar a

informação sobre a massa molecular de cada aminoácido.

Massa molecular de proteínas (versão 1)

Programa: proteinMW1.py

6


www.python.org

# Program to calculate the molecular weight of a protein using the information stored

# in a FASTA file

mw = 0

# Source for residue molecular weights: http://www.matrixscience.com/help/aa_help.html (Accessed

# on May 8th 2014)

# To calculate the mass of a neutral peptide or protein, sum the residue masses plus the masses

# of the terminating

# groups (e.g. H at the N-terminus and OH at the C-terminus).

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

}

7

Definimos um dicionário com a massa molecular de cada aminoácido (valor),

associada a cada código de uma letra do aminoácido (chave)


www.python.org

Dicionário com a massa molecular

# Reads input file name

fastaIn = input("\nGive the input file name => ")

fh = open(fastaIn,'r') # Opens input file

seqIn = fh.readlines() # Reads all of the lines in a file and returns them as elements in a list

fh.close() # Closes input file

# Removes the item at the given position in the list, and return it.

seqIn.pop(0) # Removes first element of the list (get rid of the first line)

# Transforms list in string, so we will not get error with .replace()

seq=''.join(seqIn)

# Removes all "/n" from the string seq

seq = seq.replace("\n","")

for aa in seq:

mw += float(aaMW[aa])

mw = mw + 18.0148 # Sums water molecule

print("\nThe protein weighs",mw," Daltons")

8

Depois da leitura da sequência, como visto em programas anteriores, temos a string

seq. Usamos um loop for, destacado em vermelho, para atribuirmos o valor da massa

molecular de cada aminoácido à variável mw. Somamos ao final a massa molecular

referente aos terminais da proteína. Por último, mostramos o resultado na tela.


www.python.org

Leitura e edição da sequência de aminoácidos

Loop for para somar as massas dos aminoácidos

Give the input file name => 1kxy.fasta

The protein weighs 14312.020100000016 Daltons

9

Usando-se o programa para o arquivo FASTA 1kxy.fasta, obtemos o resultado abaixo.


www.python.org

# Shows result

print("\nThe protein weighs %8.3f"%mw," Daltons")

10

Podemos formatar a saída da função print(), para definirmos o número de casas de

um número de ponto flutuante (float) com o símbolo %. A linha abaixo traz uma função

print(), para mostrar a massa molecular com até oito casas, sendo três casas após o

ponto decimal. O Programa proteinMW1a.py traz esta modificação.

Programa: proteinMW1a.py

www.python.org

Indica até oito algarismos

Força o uso de três algarismos, após o ponto decimal

O símbolo %, dentro da função print(), indica o uso de formatação

O símbolo f, depois do % mas dentro da função print(), indica o uso de

formatação de ponto flutuante

O símbolo %, fora das aspas mas dentro da função print(), indica

que a variável à direita (mw) seguirá a formatação indicada



11


www.python.org

Usando-se o programa proteinMW1a.py, para o arquivo FASTA 1kxy.fasta, obtemos o

resultado abaixo.

Resumo

Programa para calcular a massa molecular de proteínas e a porcentagem em

massa de cada aminoácido presente na sequência. O programa lê a sequência

de um arquivo no formato FASTA. O usuário fornecerá o nome do arquivo

FASTA. O programa calcula a massa molecular e a porcentagem em massa dos

aminoácidos, a partir da informação sobre a estrutura primária da proteína. Será

usado um dicionário para armazenar a informação sobre a massa molecular de

cada aminoácido.

Massa molecular de proteínas (versão 2)


12


www.python.org

# Sets initial molecular weight variable (mw) to zero

mw = 0

# Source for residue molecular weights: http://www.matrixscience.com/help/aa_help.html (Accessed

# on May 8th 2015)

# To calculate the mass of a neutral peptide or protein, sum the residue masses plus the masses

# of the terminating

# groups (e.g. H at the N-terminus and OH at the C-terminus).

# Sets dictionary aaMW

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

}13

Inicialmente atribuímos zero à variável mw, a massa molecular da proteína será

atribuída a esta variável. Depois criamos o dicionário aaMW, com a massa molecular

de cada resíduo de aminoácido. As massas moleculares estão disponíveis em:

http://www.matrixscience.com/help/aa_help.htm .


www.python.org

Dicionário com a massa molecular

http://www.matrixscience.com/help/aa_help.htm






# Removes the item at the given position in the list, and return it.

seqIn.pop(0) # Removes first element of the list (get rid of the first line)


seq=''.join(seqIn)


seq = seq.replace("\n","") 14

Em seguida lemos o nome do arquivo de entrada. Depois abrimos o arquivo de

entrada e realizamos a leitura da sequência, como visto em programas anteriores. A

sequência foi atribuída à variável seqIn, que é editada para remoção da primeira linha,

transformação de lista para string e remoção do “\n”. A sequência editada é atribuída à

variável seq.


www.python.org


# Looping through to calculate molecular weight

for aa in seq:

mw += aaMW[aa]

mw = mw + 18.0148 # Sums water molecule

15

Logo em seguida temos um loop for, que soma o valor (massa molecular) de cada

chave (aminoácido) do dicionário aaMW à variável mw. Em seguida somamos 18.0148

Da à massa molecular, devido aos aminoácidos dos terminais.


www.python.org

Loop for para somar as massas dos aminoácidos

# Counts number of amino acids

count_A = seq.count("A")

count_R = seq.count("R")

count_N = seq.count("N")

count_D = seq.count("D")

count_C = seq.count("C")

count_E = seq.count("E")

count_Q = seq.count("Q")

count_G = seq.count("G")

count_H = seq.count("H")

count_I = seq.count("I")

count_L = seq.count("L")

count_K = seq.count("K")

count_M = seq.count("M")

count_F = seq.count("F")

count_P = seq.count("P")

count_S = seq.count("S")

count_T = seq.count("T")

count_W = seq.count("W")

count_Y = seq.count("Y")

count_V = seq.count("V")

16

Contamos cada tipo de aminoácido presente na sequência, como indicado abaixo.


www.python.org

print("\nThe protein weighs %8.3f"%mw," Daltons")

if mw>0:

print("\nAmino acid\t\t\tPercentage in mass")

print("Alanine \t\t\t %8.3f"%(100*count_A*aaMW["A"]/mw))

print("Arginine\t\t\t %8.3f"%(100*count_R*aaMW["R"]/mw))

print("Asparagine\t\t\t %8.3f"%(100*count_N*aaMW["N"]/mw))

print("Aspartate\t\t\t %8.3f"%(100*count_D*aaMW["D"]/mw))

print("Cysteine\t\t\t %8.3f"%(100*count_C*aaMW["C"]/mw))

print("Glutamate\t\t\t %8.3f"%(100*count_E*aaMW["E"]/mw))

print("Glutamine\t\t\t %8.3f"%(100*count_Q*aaMW["Q"]/mw))

print("Glycine \t\t\t %8.3f"%(100*count_G*aaMW["G"]/mw))

print("Histidine\t\t\t %8.3f"%(100*count_H*aaMW["H"]/mw))

print("Isoleucine\t\t\t %8.3f"%(100*count_I*aaMW["I"]/mw))

print("Leucine \t\t\t %8.3f"%(100*count_L*aaMW["L"]/mw))

print("Lysine \t\t\t %8.3f"%(100*count_K*aaMW["K"]/mw))

print("Methionine\t\t\t %8.3f"%(100*count_M*aaMW["M"]/mw))

print("Phenylalanine\t\t\t %8.3f"%(100*count_F*aaMW["F"]/mw))

print("Proline \t\t\t %8.3f"%(100*count_P*aaMW["P"]/mw))

print("Serine \t\t\t %8.3f"%(100*count_S*aaMW["S"]/mw))

print("Threonine\t\t\t %8.3f"%(100*count_T*aaMW["T"]/mw))

print("Tryptophan\t\t\t %8.3f"%(100*count_W*aaMW["W"]/mw))

print("Tyrosine\t\t\t %8.3f"%(100*count_Y*aaMW["Y"]/mw))

print("Valine \t\t\t %8.3f"%(100*count_V*aaMW["V"]/mw))

17

Por último, mostramos os resultados na tela.


www.python.org

Mostra resultados se mw>0



Amino acidPercentage in mass

Alanine 5.960

Arginine 12.004

Asparagine 11.959

Aspartate 4.825

Cysteine 5.765

Glutamate 1.804

Glutamine 2.686

Glycine 4.784

Histidine 0.958

Isoleucine 4.744

Leucine 6.325

Lysine 5.373

Methionine 1.833

Phenylalanine 3.085

Proline 1.357

Serine 6.084

Threonine 4.945

Tryptophan 7.806

Tyrosine 3.420

Valine 4.156

18

Usando-se o programa para o arquivo FASTA 1kxy.fasta, obtemos o resultado abaixo.


www.python.org

19


www.python.org

Uma forma alternativa de programarmos, é usar um loop for aplicado diretamente ao

dicionário aaMW, como mostrado abaixo. Nesta solução economizamos uma parte

considerável de linhas de código. Toda ação está concentrada no segundo loop for.

Este loop for é inserido logo após o primeiro loop for, onde é calculada a massa

molecular da proteína (mw). O segundo loop for, aplicado ao dicionário aaMW, tem

como resultado que cada código de uma letra dos aminoácidos é atribuído à variável

res do loop for, o valor retornado para cada chave do dicionário é usado no cálculo da

porcentagem. Esta solução está implementada no programa proteinMW2a.py.

Rode o programa proteinMW2a.py e compare os resultados com a versão anterior.

# Shows results

print("\nThe protein weighs",mw," Daltons")

if mw>0:

print("\nAmino acid\t\tPercentage in mass")

# Looping through to show percentage of each amino acid

for res in aaMW:

print(res,"\t\t\t",100*seq.count(res)*aaMW[res]/mw)

Resumo

Programa para calcular a porcentagem de resíduos de aminoácidos hidrofóbicos

presentes na proteína. A informação sobre a estrutura primária é lida de um

arquivo no formato FASTA padrão, cujo o nome é fornecido pelo usuário. Os

resultados são mostrados na tela. Além de informações sobre o número total de

aminoácidos na proteína, é mostrada a primeira linha do arquivo FASTA, que

traz a identificação da proteína.

Cálculo da porcentagem de aminoácidos

hidrofóbicos

Programa: aaHydro.py


www.python.org

20

21

Estrutura cristalográfica da hemoglobina com a mutação

Glu->Val na posição 6 da cadeia beta. Na estrutura

temos 2 tetrâmeros e a val 6 localiza-se na interface dos

tetrâmetros (elipse), ocultando-a do solvente.

Código PDB: 2HBS

Posicionamento da

Val 6 da cadeia

beta.

Resíduos hidrofóbicos têm uma leve

tendência de apresentarem-se enterrados

na estrutura da proteína. A presença de

um aminoácido hidrofóbico, como a

valina, na superfície da proteína, cria um

ponto de contato desfavorável com o meio

aquoso. Tal situação pode levar à

formação de oligômeros de proteínas,

como observado para a hemoglobina de

indivíduos com anemia falciforme.

Referência: Harrington DJ, Adachi K,

Royer Jr WE. The high resolution crystal

structure of deoxyhemoglobin S.

J.Mol.Biol 1997; 272: 398-407


www.python.org

22

Abaixo temos 10 arquivos FASTA para a cadeia beta da hemoglobina humana. Teste

os arquivos FASTA indicados e identifique aquele que apresenta a hemoglobina da

anemia falciforme. Use como critério a porcentagem de resíduos hidrofóbicos. A cadeia

beta da hemoglobina de indivíduos com anemia falciforme, apresenta uma mutação de

glutamato (polar) para valina (hidrofóbico), assim terá uma porcentagem maior de

aminoácidos hidrofóbicos.

Lista de arquivos a serem testados:

Hb1.fasta, Hb2.fasta, Hb3.fasta, Hb4.fasta, Hb5.fasta, Hb6.fasta, Hb7.fasta Hb8.fasta,

Hb9.fasta, e Hb10.fasta .

.


www.python.org

No código do programa aaHydro.py, temos que identificar os aminoácidos hidrofóbicos

presentes na sequência lida. O diagrama de Venn abaixo traz a lista dos aminoácidos

hidrofóbicos, para montarmos uma lista com os códigos de uma letra. Por exemplo, alista: hydroAA = ["A","L","I","F","M","C","V"] .

Gly

Ala

Val

Leu

Ile

Phe Trp

MetProCys

Ser

Thr

TyrAsn

Gln

Asp Glu

His LysArg

Hidrofóbicos

Alifáticos

Aromáticos

Com enxofrePolares

Ácidos

Básicos

23


www.python.org

# Sets list for hydrophobic amino acids

hydroAA = ["A","L","I","F","M","C","V"]

# Sets initial value for counter of hydrophobic amino acids

count_Hydro = 0






# Removes the item at the given position in the list, and assigns it to firstLine.

firstLine = seqIn.pop(0) # Removes first element of the list (get rid of the first line)


seq=''.join(seqIn)


seq = seq.replace("\n","")

24


www.python.org

Usamos uma lista (hydroAA) para os códigos de uma letra dos aminoácidos

hidrofóbicos. Atribuímos zero ao contador count_Hydro. A parte inicial do programa é

similar ao programa proteinMW2.py, visto que temos que ler a sequência de um

arquivo FASTA. Depois da edição inicial, temos a sequência atribuída à variável seq.

Usamos seqIn.pop(0) para atribuir a primeira linha à variável firstLine.


for aa in seq:

if aa in hydroAA:

count_Hydro += 1

totalAA = len(seq)

# Shows results

print("FASTA identification: ",firstLine)

if totalAA > 0:

print("\nPercentage of hydrophobic amino acids: %8.3f"%(100*count_Hydro/totalAA) )

else:

print("\nError, no amino acids in the structure.")

25


www.python.org

Agora temos um loop for para varremos a sequência de aminoácidos. Dentro do loop

temos um condicional if. No condicional testamos se o aminoácido, atribuído à variável

aa, está na lista hydroAA, em caso afirmativo somamos “1” ao contador count_Hydro.

Por último, mostramos o resultado na tela. Teste o programa para as sequências das

cadeias beta de hemoglobina.

Loop for para contar aminoácidos hidrofóbicos

Mostra resultados na tela

Resumo

Programa para leitura e escrita de arquivo de coordenadas atômicas no formato

protein data bank (PDB). Após a leitura do arquivo PDB, o programa divide o

arquivo de entrada em três arquivos de saída. Um com os átomos da parte

proteica, outro com os átomos dos ligantes e o último com os átomos das

moléculas de água. A parte proteica é escrita no arquivo de saída protein.pdb, a

parte dos ligantes no arquivo lig.pdb e as moléculas de água no arquivo

water.pdb.

Leitura e escrita de arquivos PDB (versão 1)

Programa: readANDwritePDB1.py

26


www.python.org

pdbFileIn = input("\nType the PDB file name => ")

fo = open(pdbFileIn,"r")

f_protein = open("protein.pdb","w")

f_lig = open("lig.pdb","w")

f_water = open("water.pdb","w")

print("\nProtein atoms in the structure: ",pdbFileIn, "to be written in protein.pdb")

print("\nLigand atoms in the structure: ",pdbFileIn, "to be written in lig.pdb")

print("\nWater atoms in the structure: ",pdbFileIn, "to be written in water.pdb")

27

A parte da abertura e leitura do arquivo PDB de entrada é similar aos programas

anteriores. A novidade está na escrita. A parte inicial do programa está mostrada

abaixo. Temos a função open() para a abertura dos arquivos protein.pdb, lig.pdb e

water.pdb, indicadas em vermelho. Em seguida temos três funções print() para

indicar que as coordenadas serão escritas nos arquivos citados acima.


www.python.org

for line in fo:

if line[0:6] == "ATOM ":

f_protein.write(line)

elif line[0:6] == "HETATM" and line[17:20] != "HOH":

f_lig.write(line)

elif line[0:6] == "HETATM" and line[17:20] == "HOH":

f_water.write(line)

fo.close()

f_protein.close()

f_lig.close()

f_water.close()

28

Usamos condicionais no loop for que varre o arquivo de entrada, para selecionarmos

as diferentes fatias de átomos do arquivo PDB. Inicialmente selecionamos a parte

proteica, depois a parte dos ligantes e, por último, a parte das moléculas de água. O

loop for está indicado em vermelho. Por último, fechamos todos os arquivos.


www.python.org

Type the PDB file name => 2a4l.pdb

Protein atoms in the structure: 2a4l.pdb to be written in protein.pdb

Ligand atoms in the structure: 2a4l.pdb to be written in lig.pdb

Water atoms in the structure: 2a4l.pdb to be written in water.pdb

29

Ao rodarmos o programa, criamos três novos arquivos: protein.pdb, lig.pdb e

water.pdb . Abaixo temos o resultado de rodarmos o programa para o arquivo

2A4L.pdb.


www.python.org

Resumo

Programa para leitura e escrita de arquivo de coordenadas atômicas no formato

protein data bank (PDB). Após a leitura do arquivo PDB, o programa divide o

arquivo de entrada em três arquivos de saída. Um com os átomos da parte

proteica, outro com os átomos dos ligantes e o último com os átomos das

moléculas de água. Os nomes dos arquivos de saída são fornecidos pelo

usuário. O programa mostra quantos átomos de cada tipo foram escritos nos

arquivos de saída.

Leitura e escrita de arquivos PDB (versão 2)


30


www.python.org

# Reads and opens input file



# Reads and opens output files

my_protein = input("\nType the PDB file name for protein atoms => ")

my_lig = input("\nType the PDB file name for ligand atoms => ")

my_water = input("\nType the PDB file name for water atoms => ")

fo_protein = open(my_protein,"w")

fo_ligand = open(my_lig,"w")

fo_water = open(my_water,"w")

# Assigns zero to counter variables

count_protein = 0

count_lig = 0

count_wat = 031

No início abrimos os arquivos de entrada e saída. Os arquivos de saída terão os

nomes lidos a partir da função input(). Em seguida, atribuímos zero às variáveis

contadores de átomos, como indicado abaixo.


www.python.org

# Looping through to identify ligands, water and protein atoms

for line in fo:

if line[0:6] == "ATOM ": # Condition to be considered a protein atom

fo_protein.write(line)

count_protein += 1

elif line[0:6] == "HETATM" and line[17:20] != "HOH": # Condition for not water

fo_ligand.write(line)

count_lig += 1

elif line[0:6] == "HETATM" and line[17:20] == "HOH": # Condition for water

fo_water.write(line)

count_wat += 1

32

Agora temos um loop for, que seleciona os diferentes tipos de átomos que serão

escritos nos arquivos PDB de saída, a partir do uso de if e elif. No bloco vinculado a

cada if e elif, somamos “1” à variável do contador específico de cada átomo.


www.python.org

# Closes files

fo.close()

fo_protein.close()

fo_ligand.close()

fo_water.close()

# Shows results

print("\nNumber of protein atoms written in ",my_protein,": ",count_protein)

print("Number of ligand atoms written in ",my_lig,": ",count_lig)

print("Number of water atoms written in ",my_water,": ",count_wat)

33

Por último, fechamos os arquivos e mostramos os resultados na tela.


www.python.org

Type the PDB file name => 2a4l.pdb

Type the PDB file name for protein atoms => protein.pdb

Type the PDB file name for ligand atoms => ligand.pdb

Type the PDB file name for water atoms => water.pdb

Number of protein atoms written in protein.pdb : 2308

Number of ligand atoms written in ligand.pdb : 26

Number of water atoms written in water.pdb : 82

34

Abaixo temos o resultado de rodarmos o programa para o arquivo 2A4L.pdb. Veja

que temos a indicação do número de átomos escritos em cada arquivo de saída.


www.python.org

Com o aumento do poder gráfico do

computadores, a partir da década de 1980,

começaram a ser desenvolvidos

programas para visualização da estrutura

tridimensional de macromoléculas

biológicas. Apresentaremos um dos

principais programas usados hoje em dia

na área de bioinformática, o VMD (Visual

Molecular Dynamics). Clique no ícone

VMD e você terá as janelas mostradas ao

lado. Há duas janelas principais no VMD,

uma gráfica (Open GL Display), mostrada

ao fundo, e outra chamada de menu

principal (VMD main). Esta é usada para

inserirmos os comandos do VMD, como

comandos para carregarmos arquivos de

macromoléculas biológicas e modificarmos

sua representação na tela. Abra a pasta da

disciplina e carregue o arquivo dna.pdb no

menu principal. 35

Menu principal e janela gráfica do programa VMD.

Referência:

HUMPHREY W; DALKE A; SCHULTEN K. VMD - Visual

Molecular Dynamics. Journal of Molecular Graphics,

Amsterdã, v.14, p.33-38, 1996.

Programa Visual Molecular Dynamics (VMD)

www.python.org

Depois de carregar a estrutura do DNA,

clique na tela gráfica. Você terá a imagem

ao lado. O botão da esquerda do mouse

permite que você gire a molécula, o botão

central permite que você aumente e

diminua a estrutura na tela do computador.

Movimente a molécula, de forma a

familiarizar-se com os comandos do

mouse. A representação indicada é

chamada de Lines. Nela temos as ligações

covalentes entre os átomos, com um

código de cores. Ciano para ligações que

saem do carbono, branco para ligações

que saem do hidrogênio, vermelho para

ligações que saem do oxigênio, azul

escuro para ligações que saem do

nitrogênio e amarelo escuro para ligações

de saem do fósforo. A representação Lines

dá uma ideia da conectividade dos átomos

da molécula. 36

Janela gráfica do programa VMD, com a estrutura do DNA

mostrada com a opção Lines..


www.python.org

Clique no menu principal na seguinte

sequência: Graphics > Representations.

Você terá um novo menu de comandos,

como mostrado ao lado.

Neste menu podemos mudar a

representação gráfica da molécula.

Identifique no menu o campo Drawing

Method. Este campo permite que você

escolha diferentes formas de desenhar a

mesma molécula no terminal gráfico. Há

opções para destacar a estrutura

secundária do DNA (New Cartoons). Há

outra para destacar as posições dos

átomos e suas ligações (CPK). A opção

CPK desenha os átomos como esferas e

as ligações covalentes como bastões entre

os átomos. No próximo slide teremos uma

descrição dos principais campos do menu

gráfico.

37

Menu gráfico do programa VMD, com o campo Drawing

Method em Lines..


www.python.org

38

Seleciona a molécula a ser

mostrada, caso tenhamos mais

de uma.

Cria representações gráficas

múltiplas para a mesma

molécula, na indicada temos a

representação Lines mostrada no

campo branco.

Quando temos mais de uma

representação, é nesta janela

que ficam as informações.

Indica quais átomos são

mostrados, na situação indicada

temos todos (all).

Você pode trabalhar com

seleções específicas de átomos,

clicando na opção Selections.

Campo que muda a cor ou

critério de coloração da

molécula.

Campo que seleciona a forma de

desenhar a molécula. Campo que indica a espessura

da linha usada para desenhar a

molécula.

Campo que indica o efeito visual

do material. Temos diversas

opções, como desenhar os

átomos da molécula com uma

textura metálica.


www.python.org

Mude a opção de Drawing method de

Lines para CPK. A representação CPK é

assim chamada em homenagem aos

cientistas que a propuseram (Corey,

Pauling e Koltun) (COREY e PAULING,

1953; KOLTUN, 1965). Ao mudarmos para

CPK teremos a representação ao lado.

Referências:

-COREY, RB; PAULING L. Molecular

models of amino acids, peptides and

proteins. Review of Scientific Instruments,

Nova York, v. 24, n.8, p.621-627, 1953.

-KOLTUN WL. Precision space-filling

atomic models. Biopolymers, Hoboken, v.3,

n.6, p.665-79, 1965.

39

Janela gráfica do programa VMD, com a estrutura do DNA

mostrada com a opção CPK..


www.python.org

Explore as diferentes opções de representação gráfica da molécula de DNA. Teste as

seguintes opções: VDW (para representar átomos como esferas com raios

proporcionais ao raios de van der Waals), Licorice (representa as ligações covalentes

como bastões), New Cartoon (representa a estrutura secundária do DNA, com destaque

para as fitas e as bases) e QuickSurf (mostra a superfície molecular do DNA).

40

VDW Licorice New Cartoon QuickSurf


www.python.org

O VMD é um programa gratuito, que tem versões para Mac OS X, Linux e Windows.

Para fazer download entre no site:

http://www.ks.uiuc.edu/Development/Download/download.cgi?PackageName=VMD .

Você precisa registrar-se no site.

Uma característica interessante do VMD, é que ele permite que você crie arquivos de

imagens da molécula que você está visualizando. Essas figuras apresentam qualidade

gráfica ideal para publicações científicas. Para gerar a imagem, que está na tela, vá ao

menu principal clique: File > Render... . Você terá o menu abaixo. No campo Filename

escolha a pasta e o nome do arquivo. Coloque a extensão .bmp . Há outras opções de

formatos. Depois clique: Start Rendering. No Mac OS X tente a opção .ps para o

formato de saída figura. Depois de gerada a figura, clique duas vezes no arquivo .ps

gerado, para visualizar a figura.

41


www.python.org

http://www.ks.uiuc.edu/Development/Download/download.cgi?PackageName=VMD

A partir das coordenadas atômicas armazenadas num arquivo PDB, podemos

determinar a distância entre átomos na estrutura (distância interatômica). A figura

mostrada abaixo traz a estrutura tridimensional do aminoácido alanina. Usamos o

programa VMD, com a opção Drawing method em CPK, para gerar a figura. O arquivo

PDB traz as coordenadas atômicas que foram carregadas no VMD. Para cada átomo

mostrado na figura, temos uma posição atômica no arquivo PDB.

ATOM 1 N ALA 001 -0.541 1.336 -2.425

ATOM 2 CA ALA 001 0.178 0.132 -2.236

ATOM 3 C ALA 001 1.399 0.101 -3.155

ATOM 4 O ALA 001 2.606 -0.060 -2.668

ATOM 5 H ALA 001 -0.396 1.923 -1.614

ATOM 6 O ALA 001 1.116 0.235 -4.429

ATOM 7 H ALA 001 -1.557 1.207 -2.555

ATOM 8 H ALA 001 0.597 0.213 -1.219

ATOM 9 CB ALA 001 -0.751 -1.285 -2.203

ATOM 10 H ALA 001 -1.525 -1.287 -1.557

ATOM 11 H ALA 001 -0.255 -2.141 -2.003

ATOM 12 H ALA 001 -1.166 -1.414 -3.112

ATOM 13 H ALA 001 -0.173 1.800 -3.246

END

Arquivo PDB para o aminoácido alanina

42

Distância Interatômica

www.python.org

Temos uma relação biunívoca, para cada átomo no arquivo PDB temos um átomo na

estrutura e vice-versa. A figura abaixo mostra as coordenadas atômicas para os

átomos da figura, exceto os hidrogênios. Lembrando que as coordenadas atômicas

estão em Ångstroms (Å), onde 1 Å = 10-10 m.

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

43


www.python.org

As coordenadas atômicas, apresentadas nos arquivos PDB, permitem a determinação

direta de diversos parâmetros estruturais, tais como, distâncias, ângulos e ângulos de

torção. Para o cálculo da distância entre dois átomos (interatômica), i e j, de

coordenadas (X, Y, Z) usamos a equação para a distância Euclidiana (D) entre dois

pontos, como segue:

Como as coordenadas atômicas armazenadas num arquivo PDB estão em Ångstrom

(Å) ( 1 Å = 10-10 m), a distância interatômica, indicada pela equação acima, será dada

em Ångstrom (Å).

D = [ (Xj – Xi )2 + (Yj – Yi )

2 + (Zj – Zi )2 ]1/2

44


www.python.org

Como aplicação, consideremos a distância entre os átomos N e CA (carbono alfa) da

estrutura abaixo. O átomo N foi escolhido como “j” e o carbono alfa (CA) como “i”, a

escolha é arbitrária, visto que o quadrado da diferença entre as coordenadas é o que

importa para o cálculo.

ATOM 1 N ALA 001 -0.541 1.336 -2.425

ATOM 2 CA ALA 001 0.178 0.132 -2.236

D = [ (Xj – Xi )2 + (Yj – Yi )

2 + (Zj – Zi )2 ]1/2

45

CA

N


www.python.org

Substituindo-se os valores das coordenadas atômicas temos:

D = [ (-0,541 – 0,178 )2 + (1,336 – 0,132 )2 + (-2,425 – (-2,236) )2 ]1/2

D = [ (-0,719 )2 + (1,204 )2 + (-0,189 )2 ]1/2

D = [ 0,517 + 1,450 + 0,036 ]1/2

D = [ 2,003 ]1/2 = 1,42 Å

46

CA

N


www.python.org

ATOM 2 CA ALA 001 0.178 0.132 -2.236

ATOM 1 N ALA 001 -0.541 1.336 -2.425

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 as

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 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.

Determina as ligações dissulfeto (versão 1)

Programa: ssBondPDB1.py

47


www.python.org

A presença de resíduos de cisteína próximos, na estrutura tridimensional de uma

proteína, possibilita a oxidação dos grupos SH da cadeia lateral, formando uma

ligação covalente entre as duas cisteínas. Abaixo temos a reação de oxidação dos

resíduos de cisteína na presença de oxigênio.

2(-CH2SH) + ½ O2 -CH2-S-S-CH2 + H2O

Essa ligação chama-se ligação dissulfeto, alguns autores chamam de ponte

dissulfeto. Podemos chamar, também, de ligação SS. No presente texto, usaremos os

termos “ligação dissulfeto” ou “ligação SS”. As ligações dissulfeto conferem à proteína

uma estabilidade estrutural ao seu arranjo tridimensional, podendo ligar partes da

mesma cadeia polipeptídica ou cadeias distintas, como observado na estrutura

tridimensional da insulina (código de acesso PDB: 4EWZ).Num arquivo PDB, os átomos de enxofre da cadeia lateral de um resíduo de cisteína,

recebem o nome de SG. Buscaremos essa string entre os átomos presentes num

arquivo PDB, para identificarmos as ligações dissulfeto.

48


www.python.org

49


www.python.org

Ligação dissulfeto

Estrutura tridimensional da insulina (código de acesso PDB: 4EWZ).

50

No programa ssBondPDB1.py, identificaremos os átomos de SG (colunas de 14-15) e

testarmos o fator de ocupação (colunas 57-60). Para os átomos selecionados, lemos

as coordenadas atômicas (colunas 32-53). Os campos a serem lidos estão em verde.

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]


www.python.org

import math




# Assigns 0 to counter variables

count_SS_bonds = 0

count_SG = 0

# Sets up lists for atomic coordinates of SG

ss_x = []

ss_y = []

ss_z = []51

No início importamos o módulo math, depois lemos o nome do arquivo PDB e o

abrimos. Veja que as linhas de código, referentes à leitura do nome do arquivo PDB,

bem como a sua abertura, são idênticas às usadas no programa

readANDwritePDB2.py. Em seguida, atribuímos zero às variáveis dos contadores de

ligações SS e de átomos SG, variáveis count_SS_bonds e count_SG,

respectivamente. Na sequência, iniciamos as listas para as coordenadas atômicas do

SG.


www.python.org

# Looping through atoms to identify SS bonds

for line in fo:

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]))

count_SG += 1

# Closes file

fo.close() 52

Neste primeiro loop for, se a linha do arquivo tem o átomo SG (line[13:15] == "SG" ) e

se o fator de ocupação for maior que 0,5 ((float(line[56:60]) > 0.50) ), adicionamos as

coordenadas atômicas às respectivas listas. Tal procedimento evita que a mesma

ligação SS seja contada mais de uma vez. Adicionamos as coordenadas atômicas dos

átomos SG identificados às listas: ss_x, ss_y, ss_z. Usamos o método .append() para

adicionarmos as coordenadas atômicas às listas. Assim, teremos listas para as

coordenadas somente dos átomos que nos interessam, os SG. Somamos 1 ao

contador de SG (count_SG) e depois fechamos o arquivo.


www.python.org

# Looping through the SG atoms

for i in range(count_SG):

for j in range(i+1,count_SG):

distance_SS = math.sqrt((ss_x[i]-ss_x[j])**2+(ss_y[i]-ss_y[j] )**2+(ss_z[i]-ss_z[j])**2)

if distance_SS < 2.1 and distance_SS > 2.0:

count_SS_bonds += 1

# Shows results

print("\nNumber of S-S bonds identified in ",pdbFileIn,": ",count_SS_bonds)53

Agora, no segundo loop for, varremos só as coordenadas atômicas dos SG, atribuídas

às listas: ss_x, ss_y e ss_z. Na verdade temos um loop for aninhando em outro loop

for, tal procedimento visa que acessemos cada átomo SG das listas. Uma vez

acessadas as coordenadas, determinamos a distância entre pares de átomos SG.

Inicialmente, no loop for i in range(count_SG), dentro do retângulo vermelho, pegamos

as coordenadas em cada lista. No loop for seguinte, dentro do retângulo azul, pulamos

para o próximo átomo SG e calculamos a distância (distance_SS). Caso a distância

esteja na faixa indicada, somamos 1 ao contador de SS (count_SS_bonds). Por

último, mostramos os resultados na tela. Aninhar loops, como fizemos abaixo, é um

procedimento comum, principalmente quando temos que varrer listas ou trabalhamos

com matrizes. Observe o recuo das linhas vinculadas a cada loop for.


www.python.org

Type the PDB file name => 1kxy.pdb

Number of S-S bonds identified in 1kxy.pdb : 4

54

Abaixo temos o resultado de rodarmos o programa para o arquivo 1KXY.pdb.


www.python.org

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 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, na forma de tabela, identificando os números das cisteínas que participam

das ligações, bem como a distância interatômica da ligação SS.

Determina as ligações dissulfeto (versão 2)


55


www.python.org

56

Temos agora cinco campos a serem lidos das linhas que iniciam com “ATOM “. Os

campos a serem lidos, estão em verde abaixo. Incluímos as colunas de 23 a 26, com o

número do resíduo de aminoácido, que será mostrado na forma de uma tabela no final

do programa.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]


www.python.org

import math




# Assigns 0 to counter variables

count_SS_bonds = 0

count_SG = 0

# Sets up lists for atomic coordinates of SG and number of residue

ss_x = []

ss_y = []

ss_z = []

ss_res_number = []57

O programa é similar à versão 1, assim vamos destacar as mudanças em vermelho.

Temos uma lista extra, a ss_res_number, que terá o número dos resíduos de

aminoácidos, para as linhas com átomos SG. Esta lista terá os valores do campo que

traz a numeração do resíduo de aminoácido (colunas 23-26) .


www.python.org

# Looping through atoms to identify SS bonds

for line in fo:

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)

count_SG += 1

# Closes file

fo.close()

# Prints header to show a table with results

print("\nPairs of cysteines participating in SS-bonds identified in the file: ",pdbFileIn)

print("\nCysteine 1\tCysteine 2\t Distance(A)")58

No primeiro loop for temos o método .append() aplicado à lista ss_res_number, para a

qual será atribuída o número do resíduo de aminoácido que tem o átomo SG. Temos

também a list ss_line, que armazena a linha completa, para acessarmos informações

posteriormente. Em seguida mostramos o cabeçalho da tabela, que terá as cisteínas

identificadas nas ligações dissulfeto.


www.python.org

# Looping through the SG atoms

for i in range(count_SG):

for j in range(i+1,count_SG):

distance_SS = math.sqrt((ss_x[i]-ss_x[j])**2+(ss_y[i]-ss_y[j] )**2+(ss_z[i]-ss_z[j])**2)

if distance_SS < 2.1 and distance_SS > 2.0:

count_SS_bonds += 1

print(ss_line[i][22:26],"\t\t",ss_line[j][22:26],"\t\t%8.3f"%distance_SS)

# Shows final result

print("\nTotal number of S-S bonds identified in ",pdbFileIn,": ",count_SS_bonds) 59

Agora temos uma função print() no loop for, para mostrar o número das cisteínas que

participam de ligações dissulfeto. Introduzimos aqui uma função print() com

formatação %. O %8.3f indica que o número que estiver fora das aspas será um float

com 8 dígitos (incluindo o ponto decimal), sendo três casas decimais após o ponto

decimal. Quando temos % dentro das aspas da função print(), este indica formatação

e, necessariamente, temos que ter a variável precedida de % fora das aspas e dentro

da função print(), para indicar que a formatação % refere-se a esta variável. Não

coloca-se a vírgula separando-se a variável e as aspas, quando usamos a

formatação %.


www.python.org

Type the PDB file name => 1kxy.pdb

Pairs of cysteines participating in SS-bonds identified in the file: 1kxy.pdb

Cysteine 1Cysteine 2 Distance(A)

6 127 2.017

30 115 2.028

64 80 2.025

76 94 2.033

Total number of S-S bonds identified in 1kxy.pdb : 4

60

Abaixo temos o resultado de rodarmos o programa para o arquivo 1KXY.pdb. Veja

que todas as distâncias ficaram com 3 casas após o ponto decimal.


www.python.org

61

A figura abaixo traz as ligações dissulfeto identificadas a partir do programa VMD,

com a representação gráfica Lines. Veja que são mostrados os átomos SG das

ligações dissulfeto, pelos números dos resíduos, confirmamos os resultados

mostrados pelo programa ssBondPDB2.pdb .


www.python.org

-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: 21 de julho 2016.

62

Referências

www.python.org

linguagem de programação python - azevedolab.net · até o momento vimos dados do tipo...

Documents