Bioinformática. Uma introdução com a linguagem Perl · Representação de átomos polares na...

©2

01

6 D

r. W

alte

r F.

de

Aze

ve

do

Jr.

1

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000111111111100000000000000000000000000001111110000000000110000000000000110000001111100000000111110000000000001000011001111111111111111000000000000010001110110001111111000000000000000000011111111111111111111111110000000001111111111111111111111111111110000000000111111111111111111111111110000000000000000111111111111111111111000000000000000000111111111111111110000000000000000000000111111111111111111110000000000000000001111101111111111111111000000000000000001111100111111111111111000000000000000000000111111111111110011100000000000000000000001111111110111111100000000000000000000001110000011101100000000000000000000000000000011111001100000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

azevedolab.net

Diversos programas gráficos permitem a visualização molecular, como a representada

abaixo para o aminoácido alanina. A representação da figura é chamada CPK,

referente aos nomes dos cientistas que a propuseram (Corey, Pauling e Koltun)

(COREY e PAULING, 1953; KOLTUN, 1965). A figura abaixo foi gerada com o

programa VMD (visual molecular dynamics, disponível em:

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

)(HUMPHREY et al, 1996). As esferas em ciano representam os átomos de carbono,

em branco os átomos de hidrogênio, vermelho para oxigênio e azul para o nitrogênio.

Os bastões são ligações covalentes entre os átomos.

VMD é o acrônimo para visual molecular dynamics.

2

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

-HUMPHREY W; DALKE A; SCHULTEN

K. VMD - Visual Molecular Dynamics.

Journal of Molecular Graphics,

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

-KOLTUN WL. Precision space-filling

atomic models. Biopolymers, Hoboken,

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

Bases Moleculares

www.python.org

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

Os aminoácidos apresentam diferenças

na carga elétrica, hidrofobicidade

(literalmente “temor à água”), polaridade e

massa molecular, para citar as principais

características físico-químicas.

Normalmente usamos a unidade Dálton

(Da) para medir a massa molecular de

aminoácidos e moléculas biológicas em

geral. Um Dálton equivale à massa de

1/12 do átomo de carbono 12. Para

proteínas usamos o kiloDálton (kDa), 1

kDa = 103 Da.

Na figura ao lado temos o aminoácido

alanina, que apresenta uma massa

molecular de 89,09 Da, e uma proteína

chamada lisozima, que apresenta uma

massa molecular de 14331,20 Da.

Usaremos o símbolo MW (molecular

weight) para representarmos a massa

molecular.

Lisozima de ovo de galinha (MW = 14331,20 Da ou

14,331 kDa). Código PDB: 6LYZ.

As figuras não estão na mesma escala.

Alanina (MW = 89,09 Da)

3

Aminoácidos

www.python.org

Podemos pensar que a proteína é

formada por uma sequência de

aminoácidos ligados covalentemente. O

primeiro aminoácido liga-se

covalentemente ao segundo, que liga-se

ao terceiro, assim sucessivamente. Tal

arranjo molecular é chamado de polímero,

ou seja, proteínas são polímeros de

aminoácidos. Ao ligarem-se uns aos

outros, cada par de aminoácidos perde

uma molécula de água, o que permite a

formação da ligação peptídica, como

mostrado na figura ao lado. O aminoácido

inserido na estrutura da proteína chama-

se resíduo de aminoácido.

Aspartato

Fenilalanina

Aspartame

H2O

4

Ligação Peptídica

www.python.org

A molécula de aspartame é um

dipeptídeo, pois é formado por dois

resíduos de aminoácidos, aspartato (Asp)

e fenilalanina (Phe). A ligação peptídica

está indicada na molécula. O aspartame é

um adoçante com sabor de 100 a 200

vezes mais doce que a sacarose, por ser

formado de resíduos de aminoácidos é

facilmente metabolizado. No caso de 3

resíduos de aminoácidos temos um

tripeptídeo, 4 um tetrapeptideo, 5 um

pentapeptídeo, e assim sucessivamente.

Aspartame

Ligação peptídica

5

Peptídeos

www.python.org

A molécula de Ala-Gly é um dipeptídeo,

pois é formado por dois resíduos de

aminoácidos, alanina (Ala) e glicina (Gly).

A ligação peptídica está indicada na

molécula. A tabela abaixo mostra a

identificação dos principais tipos de

peptídeos, no que se refere ao número de

resíduos de aminoácidos presentes na

estrutura.

Ala-Gly

Ligação peptídica

Número de resíduos de aminoácido Nome

2 Dipeptídeo

3 Tripeptídeo

4 Tetrapeptídeo

5 Pentapeptídeo

6 Hexapeptídeo

7 Heptapeptídeo

8 Octapeptídeo

9 Eneapeptídeo

10 Decapeptídeo

6

Peptídeos

www.python.org

A figura abaixo mostra uma cadeia peptídica de 6 resíduos de aminoácidos (um

hexapeptídeo), onde lemos a sequência do N (terminal amino) para o C (terminal

carboxílico), tal convenção é usada para numerar os resíduos na sequência. Este

procedimento facilita a análise de diversas características das sequências de

aminoácidos, tais como, conservação de resíduos de aminoácidos em determinada

posição, identidade sequencial entre diversas proteínas, identificação de sítios ativos,

no caso de enzimas, entre outros aspectos.

Terminal N

Terminal CR1 R3 R5

R2 R4 R6

R’s indicam as cadeias laterais

7

Peptídeos

www.python.org

Sempre que estudamos a interação de fármacos com proteínas, temos interesse na

informação sobre as distâncias interatômicas, assim vamos definir como medimos tais

distâncias. No mundo molecular, usamos a unidade chamada angstrom (Å), que

equivale a 10-10m. Outra unidade usada no estudo de moléculas é o nanômetro (nm),

1 nm = 10-9 m. Na presente disciplina usaremos sempre angstroms para medidas de

distâncias. Abaixo temos a distância interatômica entre átomos de um fármaco

(roscovitine) e a proteína quinase dependente de ciclina 2 em Å.

8

Angstrom

1 Å = 10-10 m

www.python.org

Estes átomos estão ligados covalentemente, cada ligação é representada

por um bastão ligando os átomos, representados por esferas.

A ligação covalente é a responsável por ligações químicas entre os átomos. Uma

ligação forte mantém a cadeia principal da proteína e as cadeias laterais unidas. Na

representação CPK, a ligação covalente é indicada por um bastão unindo esferas. As

esferas indicam os átomos.

9

Interações Moleculares (Ligação Covalent)

www.python.org

Interação hidrofóbica, literalmente “temor à água”, indica uma força que impele os

resíduos hidrofóbicos para o interior da estrutura da proteína. Resíduos hidrofílicos

apresentam uma leve tendência estatística de apresentarem-se na superfície da

proteína. De forma inversa, temos uma tendência estatística de encontrarmos

resíduos hidrofóbicos enterrados na proteína. Na figura abaixo temos em ciano os

átomos de carbono (hidrofóbicos), em vermelho e azul os átomo hidrofílicos.

Representação de átomos polares na superfície da

proteína Purina Nucleosídeo Fosforilase.

Visualização do interior hidrofóbico da proteína,

representado no centro da figura.

10

Interações Moleculares (Hidrofóbica)

www.python.org

É a interação devido à proximidade entre átomos e envolve regiões não polares das

moléculas. As nuvens eletrônicas dos átomos passam a interagir por causa do dipolo

(cargas positiva e negativa posicionadas em extremos da molécula ou átomo) que

surge na nuvem eletrônica do átomo. Este dipolo é devido às características quânticas

do sistema, onde a indeterminação da posição do elétron leva à possibilidade de num

dado instante termos um elétron numa posição favorável à formação de um dipolo

elétrico. Tal dipolo pode interagir com a nuvem eletrônica de um átomo próximo. A

interação é relativamente fraca e de curto alcance.

RVDW RVDW

Átomos próximos permitem uma interação entre as nuvens eletrônicas, o que causa a força de van

der Waals. Quando a distância é menor que a soma dos raios de van der Waals (RVDW) a repulsão

surge entre os átomos. 11

Interações Moleculares (van der Waals)

www.python.org

As ligações de hidrogênio são de origem eletrostática, onde ocorre o

compartilhamento de um H entre átomos não ligados covalentemente. A ligação de

hidrogênio pode ocorrer entre moléculas diferentes. Por exemplo, quando moléculas

de água entram em contato com a superfície de uma proteína, as interações ocorrem

por meio de ligações de H. Numa ligação de hidrogênio temos sempre um átomo

doador de H e um aceitador de H. Na verdade não há transferência do H do doador

para o aceitador, e sim uma ação eletrostática do próton (H) sobre o aceitador. Na

figura abaixo o oxigênio é o aceitador e o nitrogênio é o doador. A distância (r) entre o

doador e o aceitador (r) varia entre 2,5 a 3,4 Å.

CON H

Doador Aceitador

r

12

Interações Moleculares (Ligações de Hidrogênio)

www.python.org

As ligações de H são responsáveis pela

estabilização de diversas macromoléculas

biológicas. Entre elas as moléculas de

DNA e RNA. Os pares de bases que

estabilizam a molécula de DNA

apresentam um padrão de ligações de

hidrogênio. Quando Watson e Crick

elucidaram a estrutura tridimensional do

DNA identificaram os pares de bases,

Citosina-Guanina (C-G) e Adenina-Timina

(A-T), que se conectam por ligações de

hidrogênio. A figura ao lado ilustra a

estrutura cristalográfica do DNA, os pares

de bases na região central da molécula

funcionam como amarras que seguram as

duas fitas do DNA.

13

A estrutura da hélice alfa foi prevista

teoricamente por Linus Pauling em 1950.

Vale a pena lembrar, que naquela data,

não havia informação estrutural sobre

proteínas, e sua previsão foi baseada na

estrutura cristalográfica de aminoácidos,

dipeptídeos e tripeptídeos, determinados

a partir de cristalografia por difração de

raios X. A estrutura de hélice alfa foi

posteriormente confirmada, quando a

estrutura cristalográfica da mioglobina foi

determinada em 1959.

14

Hélice Alfa

www.python.org

O enovelamento da hélice alfa leva a uma

estrutura onde as cadeias laterais ficam

voltadas para fora da estrutura, criando

uma estrutura cilíndrica compacta. Uma

análise das preferências dos resíduos de

aminoácidos indicou que leucina (Leu),

glutamato (Glu), metionina (Met) e alanina

(Ala), são encontrados preferencialmente

em hélices alfa (regra do LEMA), e os

resíduos prolina (Pro), isoleucina (Ile),

glicina (Gly) e serina (Ser), dificilmente

são encontrados em hélices alfas, regra

do PIGS. A figura da direita ilustra uma

visão de cima da hélice alfa, indicando as

cadeias laterais voltadas para o lado de

fora da hélice, tal estrutura tem um

diâmetro aproximado de 5 Å.

Normalmente encontramos em hélices

alfas os seguintes resíduos de

aminoácidos (regra do LEMA):

Leucina (L),

Glutamato (E),

Metionina (M) e

Alanina (A)

Normalmente ausentes em hélices alfas

(regra do PIGS):

Prolina (P),

Isoleucina (I),

Glicina (G) e

Serina (S) 15

Hélice Alfa

www.python.org

A estrutura tridimensional da hélice alfa é

estabilizada por um padrão de ligações de

hidrogênio, envolvendo o oxigênio da

carbonila do resíduo i com o nitrogênio do

resíduo i+4, como ilustrado na figura ao

lado com linhas tracejadas.

Há várias representações possíveis das

hélices numa estrutura. A representação

CPK faz uso de esferas para cada átomo

e bastões para as ligações covalentes,

como mostrada na figura ao lado. Tal

representação permite a identificação de

detalhes estruturais, possibilitando

destacar características estruturais, tais

como, ligações de hidrogênio, orientação

espacial e conectividade, contudo, tal

representação torna-se pesada, ao

olharmos para estruturas completas,

como a do próximo slide.

Ligação de hidrogênio

16

Hélice Alfa

www.python.org

Na figura ao lado temos a representação

em CPK da estrutura da mioglobina. A

presença das hélices fica de difícil

visualização, devido à grande quantidade

de átomos. A mioglobina tem 1260

átomos, ou seja, uma esfera para cada

átomo, o que dificulta a identificação das

hélices. Uma forma alternativa é

representação estilizada da hélice, onde

usamos somente os átomos da cadeia

principal, ou somente os carbonos alfa,

para geramos uma representação gráfica

da estrutura.

Representação gráfica: CPK

Código de acesso PDB: 1VXA

N

C

17

Estrutura da Mioglobina

www.python.org

A representação ao lado conecta os

carbonos alfa da estrutura, o que facilita a

visualização das hélices. Vemos na

estrutura diversas hélices, num total de 8.

Usamos o programa VMD com a opção

trace. O programa representa trechos em

hélice alfa em rosa. Estão destacados na

figura o início (terminal N, ou amino-

terminal) e o final (terminal C ou carboxi-

terminal).

Representação gráfica: trace


N

C

18


www.python.org

Programas de visualização gráfica de

macromoléculas, como o VMD,

apresentam opções de representação em

cartoons, que perde os detalhes mas

facilita a identificação de aspectos gerais

sobre a estrutura tridimensional da

proteína, como na figura, gerada com o

VMD, com opção de representação

gráfica new cartoons. Os laços que

conectam a estrutura não apresentam o

formato helicoidal, sendo representado

por um tubo contínuo mais fino que a fita

usada nas representações das hélices.

Representação gráfica: new cartoon


N

C

19


www.python.org

Outra representação gráfica possível para

as hélices é a representação em cilindro,

onde cada hélice é indicada como um

cilindro. A figura ao lado representa a

estrutura das hélices da mioglobina como

cilindros. A topologia da hélice é comum

em estruturas de proteínas, tal ubiquidade

deve-se às características geométricas

das hélices, que permitem a compactação

dos aminoácidos, numa estrutura regular

e relativamente rígida. As hélices

permitem, ainda, que resíduos de

aminoácidos hidrofóbicos concentrem-se

numa parte da hélice, deixando do outro

lado resíduos hidrofílicos, tais

características são úteis em proteínas

transmembranares, por exemplo. Assim,

na história evolutiva de cada ser, a

presença de hélices nas proteínas pode

levar a vantagens, daí sua ubiquidade.

Representação gráfica: cartoon


N

C

20


www.python.org

A fita beta apresenta uma cadeia principal

distendida, não havendo hélices em sua

topologia. Uma cadeia distendida, como

mostrada na figura ao lado, não possibilita

a existência de ligações de hidrogênio,

como observadas nas hélices, contudo,

tal arranjo, libera o oxigênio da carbonila e

o nitrogênio da cadeia principal para

fazerem ligações de hidrogênio, com

partes distantes da cadeia peptídica, ou

mesmo, com outras cadeias peptídicas. A

condição necessária é a proximidade do

par doador-aceitador da ligação de

hidrogênio. Os terminais N e C são

indicados na figura.

C

N

21

Fita Beta

www.python.org

N

C

Ligação de hidrogênio

C

N

A disposição próxima das fitas beta

possibilita ligações de hidrogênio que

fortalecem a estrutura tridimensional da

proteína. O arranjo mostrado ao lado é a

base para a montagem de uma folha beta,

com várias fitas betas. Quando as fitas,

que formam a folha beta, apontam todas

na mesma direção, temos um folha beta

paralela. O padrão entrelaçado das

ligações de hidrogênio fornece uma

estabilidade estrutural ao sistema, o que

possibilita a montagem de folhas betas

com várias fitas.

N

C

22

Fita Beta

www.python.org

Para simplificar a representação gráfica,

normalmente usamos vetores, como os

indicados ao lado. Cada vetor representa

uma fita beta, que em conjunto formam a

folha. A cabeça do vetor indica o terminal

C e o início do vetor o terminal N.

C C

NN

N

C

23

Fita Beta

www.python.org

Outra possibilidade de formarmos uma

folha beta é com fitas beta alternadas,

como mostrado na figura ao lado. Na

folha ao lado temos 3 fitas, onde a

primeira segue com o terminal N na parte

superior, a segunda com o terminal C na

parte superior, e assim alternando-se,

num padrão antiparalelo de fitas beta.

24

Fita Beta

www.python.org

N

C

Na representação das fitas beta como

vetores, fica claro a alternância do sentido

das fitas beta, desenhadas em azul. Os

trechos em amarelo são partes da cadeia

proteica que conectam as fitas, chamados

de alças. As alças não apresentam a

geometria da hélice nem da fita, mas

conectam tais elementos estruturais.

25

Alças

Alça

Fita beta

Fita Beta

www.python.org

Primária Secundária Terciária Quaternária

Na análise da estrutura de uma proteína podemos visualizar diferentes níveis de

complexidade. Do mais simples para o mais complexo. A sequência de resíduos de

aminoácidos é a estrutura primária. A identificação das partes da estrutura primária

que formam hélices, fitas e laços é a estrutura secundária. As coordenadas atômicas

de todos os átomos que formam a proteína é a estrutura terciária. Por último, se a

proteína tem mais de uma cadeia polipeptídica, esta apresenta uma estrutura

quaternária.

26

Níveis Estruturais de Proteínas

Uma forma de armazenarmos informações sobre a estrutura primária de uma proteína

é num arquivo texto simples, onde o códigos de uma letra são armazenados. A

primeira letra é o resíduo de aminoácido do terminal amino, a segunda letra é o

resíduo de aminoácido ligado ao primeiro, e assim sucessivamente até o último

resíduo de aminoácido, que está no terminal carboxilíco. Um dos formatos mais

usados é chamado formato FASTA, pois um dos primeiros programas usados para

busca em base de dados de sequência recebe esse nome (FASTA). Abaixo temos o

arquivo FASTA, para a estrutura primária da cadeia beta da hemoglobina humana.

>2HBS:B|PDBID|CHAIN|SEQUENCE

VHLTPVEKSAVTALWGKVNVDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAV

MGNPKVKAHGKKVLGAFSDGLAHLDN

LKGTFATLSELHCDKLHVDPENFRLLGNVLVCVLAHHFGKEFTPPVQAAYQKVVA

GVANALAHKYH

Linha de identificação da proteína (não contém aminoácidos)Onde inicia a sequência (terminal N) o aminoácido Valina

Onde termina a sequência (terminal C) o aminoácido Histidina

27

Proteínas

www.python.org

Todo arquivo no formato FASTA inicia com o símbolo “>”, o que facilita ao

programador, pois indica que um símbolo será usado para marcar a linha de

identificação, as outras linhas mostram a estrutura primária da proteína. O formato

FASTA pode ser usado também para armazenar estruturas primárias de ácidos

nucleicos, só que nesse caso teremos nucleotídeos, ao invés de resíduos de

aminoácidos.

>2HBS:B|PDBID|CHAIN|SEQUENCE

VHLTPVEKSAVTALWGKVNVDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAV

MGNPKVKAHGKKVLGAFSDGLAHLDN

LKGTFATLSELHCDKLHVDPENFRLLGNVLVCVLAHHFGKEFTPPVQAAYQKVVA

GVANALAHKYH

Linha de identificação da proteína (não contém aminoácidos)Onde inicia a sequência (terminal N) o aminoácido Valina

Onde termina a sequência (terminal C) o aminoácido Histidina

28

Proteínas

www.python.org

Umas das bases de dados mais usadas em Bioinformática, é o Protein Data Bank

(www.rcsb.org/pdb). Essa base de dados armazena estruturas de macromoléculas

biológicas, que foram determinadas experimentalmente por técnicas de cristalografia

por difração de raios X, ressonância magnética nuclear entre outras. Veremos como

fazer o download de uma sequência de aminoácidos de uma proteína.

29

Protein Data Bank (Para Sequências)

www.python.org

http://www.rcsb.org/pdb

O PDB pode ser acessado diretamente, quando se conhece o código da estrutura

depositada. Toda vez que é realizado um estudo estrutural experimental, recomenda-

se que as coordenadas atômicas (posição de cada átomo da estrutura), bem como a

sequência de aminoácidos, sejam depositas no PDB. Ao depositar essa informação, é

gerado um código alfanumérico de quatro dígitos, que será usado como identificador

da estrutura depositada. Por exemplo, vamos buscar a estrutura 2A4L.

30


www.python.org

Depois de digitar “2A4L”, clicamos na lupa ao lado do campo, onde digitamos o código

da estrutura, ou, simplesmente clicamos Enter/Return. O resultado da busca está

mostrado abaixo. Há diversas informações que podem ser exploradas. Teremos uma

aula específica sobre o PDB, onde tais funcionalidades serão explicadas. Hoje vamos

focar no download da sequência. Veja, na porção à direita, temos “Download Files”.

31


www.python.org

Clicamos em “Download Files” e temos o menu de opções para download.

Escolhemos “FASTA sequence”, direcionamos para pasta onde queremos nossa

sequência.

32


www.python.org

Abaixo temos a sequência baixada no formato FASTA, veja que é um arquivo texto

simples, como destacado anteriormente. A seguir, iremos descrever alguns programas

em Python para a leitura de arquivos de sequência no formato FASTA.

33

>2A4L:A|PDBID|CHAIN|SEQUENCE

MENFQKVEKIGEGTYGVVYKARNKLTGEVVALKKIRLDTETEGVPSTAIREISLLKELNHPNIVKLLDVIHTENKLYLVF

EFLHQDLKKFMDASALTGIPLPLIKSYLFQLLQGLAFCHSHRVLHRDLKPQNLLINTEGAIKLADFGLARAFGVPVRTYT

HEVVTLWYRAPEILLGCKYYSTAVDIWSLGCIFAEMVTRRALFPGDSEIDQLFRIFRTLGTPDEVVWPGVTSMPDYKPSF

PKWARQDFSKVVPPLDEDGRSLLSQMLHYDPNKRISAKAALAHPFFQDVTKPVPHL


www.python.org

34

Comando if

www.python.org

Vimos, já na primeira aula, o comando if e seu uso na ramificação da execução de um

código em Python. Se não tivéssemos a possibilidade de ramificação da execução do

código, os programas seguiriam seu caminho definido, do primeiro ao último comando,

sem a possibilidade de ramificações. O comando if tem esta qualidade, ramificar a

execução, vinculado a um teste que, dependendo do resultado, tomará um caminho

ou outro. Vimos até o momento o if isolado, bem como o if com o else. Além desses

citados, temos o elif, o quadro no próximo slide ilustra o uso do if, else e elif.

Comando Descrição

If condição :

bloco...

O comando if testa a condição, e, caso seja verdadeira, executa

o bloco de comandos. Caso seja falsa, pula o bloco de

comandos.

If condição:

bloco 1

else:

bloco 2

O comando if testa a condição, e, caso seja verdadeira, executa

o bloco 1 de comandos. Caso seja falsa, executa o bloco 2 de

comandos, vinculado ao else.

If condição 1:

bloco 1

elif condição 2:

bloco 2

elif condição 3:

bloco 3

....

elif condição N:

bloco N

else:

bloco N + 1

O comando if testa a condição 1, e, caso seja verdadeira,

executa o bloco 1 de comandos e ignora os elif e else, mesmo

que esses tenham condições verdadeiras. Caso seja falsa, testa

a condição 2, se verdadeira, executa o bloco 2 e ignora os outros

elif e else, se presentes. Essa abordagem é seguida pelos outros

elif e else, se presentes. Veja, uma vez que uma das condições é

satisfeita, o bloco referente a esta condição é executado e o

programa ignora os outros elif e else, se presentes.

35

Comando if

www.python.org

36

Comando if

www.python.org

O programa ex_if.py mostra uma aplicação do if, elif e else. O programa lê um número

inteiro (numInt) e testa em que intervalo ele se encontra.

# Program to show how an if works

numInt = int(input("Type a number => "))

# Test number

if numInt == 0:

print("Your number is zero")

elif numInt > 0 and numInt < 10:

print("Your number is in the range 0 < x < 10")

elif numInt < 0:

print("Your number is negative")

else:

print("Your number is >= 10")

37

Loop for

www.python.org

O loop for permite a repetição de um bloco de comandos, tal situação permite que o

fluxo normal de execução do programa seja modificada. No loop for temos um bloco

de comandos que são repetidos. O formato é similar ao condicional if, onde temos um

bloco de comandos recuados.

Cada ciclo de repetição do loop for é chamado iteração.

for (indicação de repetição):

bloco de comandos

38

Loop for

www.python.org

No programa ex_for.py temos um loop for que repete 10 vezes a execução do bloco

de comandos associado ao loop, ou seja, print(i). Em cada iteração, o valor atribuído à

variável i é acrescido de 1. Como valor inicial atribuído à variável i é zero, o loop

encerra quando 9 for atribuído à variável i.

Veja que o comando range() define a faixa que será varrida no loop for. O range(10)

começa do zero e vai até o número inteiro anterior ao indicado entre parênteses, ou

seja, 9. Execute o código e veja os resultados.

# Program to show how a loop for works

# Looping through i from 0 to 9

for i in range(10):

print(i)

39

Loop while

www.python.org

Outro tipo de loop é o while, que executa um bloco de código, enquanto uma

determinada condição for satisfeita. Uma vez que a condição não seja mais satisfeita,

o programa sai do loop while. Abaixo temos a estrutura geral do loop while.

O loop while assemelha-se ao comando if, o bloco de código é executado se a

condição for satisfeita. A diferença reside que o loop while executa o bloco de forma

repetida, até que a condição não seja mais satisfeita. Isto pode levar a situação onde a

condição nunca seja satisfeita, o que chamamos de loop infinito. A condição, testada

no início, é testada depois da execução do bloco de código, assim, espera-se que

tenhamos uma variável, que durante uma dada execução do bloco, irá mudar, para

que a condição não seja mais satisfeita e a execução do bloco vinculada à condição

do loop while seja encerrada.

while (condição):

bloco vinculado à condição

40

No programa ex_while.py temos um loop while que repete 10 vezes a execução do

bloco de comandos associado ao loop, ou seja, print(i). Em cada iteração, o valor

atribuído à variável i é acrescido de 1 (i += 1). Como o valor inicial atribuído à variável i

é zero (i = 0), o loop encerra quando a condição não for mais satisfeita, ou seja,

quando o i for >= 10.

Veja que o valor atribuído à variável i é acrescido de 1 em cada iteração do loop. A

variável i é chamada variável sentinela, pois sua condição é monitorada durante o

loop while. Loops while devem ser usados com cuidado, visto que podem facilmente

levar a um loop infinito, onde a condição de parada nunca é satisfeita.

# Program to show how a loop while works

# Looping through i from 0 to 9

i = 0

while i < 10:

print(i)

i += 1

Loop while

www.python.org

# Program to read sequence from a file in FASTA format

# Reads input file name and assigns it to the variable fastaIn

fastaIn = input("Type input file => ")

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

# Looping through to show file content

print("\nSequence read from the file: ",fastaIn)

for line in seqIn:

print(line,end='')

41

O programa readFasta1.py lê um arquivo no formato FASTA e, em seguida, mostra a

sequência na tela. Vamos destacar as novidades do código em vermelho. O programa

é relativamente simples, a principal novidade é o método .readlines(), que lê todo o

arquivo como uma lista, atribuindo cada linha do arquivo a um elemento da lista.

Havíamos usado anteriormente o método .readline(), que lê somente a primeira do

arquivo como uma string.

Leitura de Arquivos no Formato FASTA

www.python.org

Caso nosso programa leia o arquivo 2a4.fasta, mostrado abaixo, cada linha do arquivo

de entrada será um elemento da lista. A ordem de cada elemento de uma lista é

indicado por colchetes, assim, o elemento seqIn[0] é o primeiro elemento, seqIn[1], o

segundo elemento e assim sucessivamente. A vantagem de lermos com o método

.readlines(), é que temos uma maneira rápida de acessarmos o conteúdo de cada

linha. Por outro lado, ao imprimirmos toda lista na tela, teremos o conteúdo mostrado

como uma linha, onde os elementos são separados por vírgula. Veja no próximo slide.

42

>2A4L:A|PDBID|CHAIN|SEQUENCE

MENFQKVEKIGEGTYGVVYKARNKLTGEVVALKKIRLDTETEGVPSTAIREISLLKELNHPNIVKLLDVIHTENKLYLVF

EFLHQDLKKFMDASALTGIPLPLIKSYLFQLLQGLAFCHSHRVLHRDLKPQNLLINTEGAIKLADFGLARAFGVPVRTYT

HEVVTLWYRAPEILLGCKYYSTAVDIWSLGCIFAEMVTRRALFPGDSEIDQLFRIFRTLGTPDEVVWPGVTSMPDYKPSF

PKWARQDFSKVVPPLDEDGRSLLSQMLHYDPNKRISAKAALAHPFFQDVTKPVPHL

seqIn[0]

seqIn[1]

seqIn[2]

Arquivo FASTA 2a4.fasta Elementos da lista

seqIn[3]

seqIn[4]


www.python.org

43

A rodarmos o programa readFasta1.py, temos o resultado mostrado abaixo. Na

verdade mostramos todo o conteúdo em várias linhas, mas na tela temos todo o

conteúdo numa linha, além de termos as vírgulas e a sequência de escape “\n”

indicada. Tal situação não é conveniente, veremos a seguir o código readFasta2.py,

que mostra o conteúdo do arquivo de uma forma limpa, onde cada elemento da lista

seqIn será mostrado numa linha por vez e sem sequências de escape, como a “/n”.

Precisaremos fazer uso do loop for.

Type input file => 2a4l.fasta

Sequence read from 2a4l.fasta

['>2A4L:A|PDBID|CHAIN|SEQUENCE\n',

'MENFQKVEKIGEGTYGVVYKARNKLTGEVVALKKIRLDTETEGVPSTAIREISLLKELNHPNIVKLLDVIHTENKLYLVF\n',

'EFLHQDLKKFMDASALTGIPLPLIKSYLFQLLQGLAFCHSHRVLHRDLKPQNLLINTEGAIKLADFGLARAFGVPVRTYT\n',

'HEVVTLWYRAPEILLGCKYYSTAVDIWSLGCIFAEMVTRRALFPGDSEIDQLFRIFRTLGTPDEVVWPGVTSMPDYKPSF\n',

'PKWARQDFSKVVPPLDEDGRSLLSQMLHYDPNKRISAKAALAHPFFQDVTKPVPHLRL']

Press Enter/Return to finish program...


www.python.org

# Program to show the characters in a string, one in each line

myString = "Python"

# Looping through the string

for char in myString:

print(char)

44

Uma das formas de mostrarmos uma linha por vez da lista seqIn, é usarmos o loop for,

que permite que uma ação seja repetida. No caso, a ação de impressão na tela de

cada elemento da lista. Vamos ver alguns exemplos simples, antes de aplicarmos ao

programa readFasta2.py. Vamos considerar o programa showCharacters.py, que

mostra cada caractere de uma string, um por vez. O loop for está destacado nas linhas

vermelhas. O loop for atribui cada caractere contido na string myString à variável char,

no loop for temos a função print(char), que será repetida enquanto houver caracteres

na string myString. Cada caractere é mostrado numa linha. Veja que a função print()

está recuada para direita, este recurso é obrigatório quando usamos o loop for,

delimita o bloco que será executado no loop for. Veja, também, que finalizamos a linha

onde está o loop for com “:”, esta parte também é obrigatória para o uso do loop for.


www.python.org

45

Abaixo temos o resultado da execução do programa showCharacters.py, vemos que

cada caractere da string “Python” é mostrado numa linha. O loop for caminha sobre a

string myString, um caractere por vez, este processo é chamada iteração, tem a ideia

de repetição. Em inglês é usado o termo “iteration”. Outro ponto a ser destacado, o

loop for usa o recurso do recuo, em inglês “indentation”, para destacar o bloco que

será executado no loop. Especificamente, o bloco tem somente a função print().

P

y

t

h

o

n


www.python.org

46

O loop for pode varrer listas, como vemos no código showElements.py, que mostra os

elementos na lista myList. A lógica de programação é mesma do programa

showCharacters.py, só trocamos a string por lista. O resultado é que o loop for mostra

agora um elemento da lista por vez, um em cada linha. O loop for está destacado em

vermelho. Veja que cada elemento da lista myList é uma string. Separamos os

elementos da lista por vírgulas, como mostrado para a lista na definição da lista

myList, na segunda linha do programa abaixo.

Ao executarmos o programa showElements.py, temos o resultado abaixo

# Program to show the elements in a list, one in each line

myList = ["Python","is","cool"]

# Looping through the list

for elements in myList:

print(elements)

Python

is

cool


www.python.org

# Program to read sequence from a file in FASTA format

# Reads input file name and assigns it to the variable fastaIn

fastaIn = input("Type input file => ")

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

# Looping through to show file content

print("\nSequence read from the file: ",fastaIn)

for line in seqIn:

print(line,end='')

47

O programa readFasta2.py lê um arquivo no formato FASTA e, em seguida, mostra os

elementos da lista seqIn, um em cada linha. Como sempre, destacamos as novidades

do código em vermelho. Agora temos o loop for, que mostra cada elemento da lista

seqIn numa linha. A função print(line,end=‘’), do bloco do loop for, mostra um elemento

por vez, sem pular uma linha, o end=‘’, garante tal imposição. Tal recurso foi incluído,

pois os elementos da lista lidos do arquivo FASTA já têm uma sequência de escape

“\n” no final, assim, ao executarmos o código, teremos a mudança de linha.


www.python.org

A célula é normalmente atacada por agentes químicos, vírus e radiação que podem

levar a danos celulares que resultam em tumores. Para prevenir o aparecimento e

progressão de tumores, a célula dispõe de mecanismos de defesa, entre eles há um

mediado pela proteína supressora de tumor p53. A p53 apresenta uma estrutura

tetramérica, como mostrada abaixo, há trechos longos conectando suas unidades.

Contudo, como essas regiões conectoras são flexíveis, até o momento não foi

conseguida a estrutura cristalográfica completa do complexo. Por outro lado, temos as

estruturas dos componentes, que possibilitam a montagem do quebra-cabeça

molecular.

48

Supressor de Tumor p53

Fonte da figura: http://pdb101.rcsb.org/motm/31. Acesso em 30 de junho de 2016.

http://pdb101.rcsb.org/motm/31

No centro da p53 temos o domínio de tetramerização (indicado por A), que serve para

a ancoragem dos outros domínios da proteína. Conectado ao centro, temos quatro

domínios de ligação ao DNA (DNA-binding domain) (indicados por B). Ao final dos

domínios de ligação ao DNA, temos os domínios de transativação (transactivation

domain ) (indicados por B), que ativam o mecanismo de leitura do DNA.

49



A

B

C


Como podemos inferir pelo nome da proteína, a p53 tem um papel importante no

câncer. Há dois tipos de mutações associadas ao câncer. O primeiro está relacionado

com o crescimento celular descontrolado e com a multiplicação celular. O segundo

está relacionado com mutações em mecanismos de controle normais que protegem a

célula contra o crescimento anormal. A p53 enquadra-se no segundo tipo.

50



A

B

C


A maioria das mutações na p53 associadas com câncer ocorrem no domínio de

ligação de DNA (DNA-binding domain) (Vogelstein et al., 2000). A mutação mais

comum ocorre no resíduo Arg248, indicada na figura abaixo. p53 induz a expressão

da proteína inibidora de CDKs, p21 (Waldman et al., 1995; Bunz et al., 1998). O que

indica a importância da inibição das CDKs para câncer.

51



Arg248

Domínio de ligação

de DNA

DNA

Referências:

Waldman, T., K. W. Kinzler, and B. Vogelstein.

1995. p21 is necessary for the p53-mediated G1

arrest in human cancer cells. Cancer Res.

55:5187-5190.

Bunz, F., A. Dutriaux, C. Lengauer, T. Waldman,

S. Zhou, J. P. Brown, J. M. Sedivy, K. W. Kinzler,

and B. Vogelstein. 1998. Requirement for p53

and p21 to sustain G2 arrest after DNA damage.

Science 282:1497-1501.

B. Vogelstein, B., Lane, D., Levine, A.J. (2000):

Surfing the p53 network. Nature 408, pp. 307-

310.


Olhando-se o processo de ativação da quinase dependente de ciclina 2 (cyclin-

dependent kinase 2) (CDK2), vemos que esta passa por uma montagem, como

indicada na figura abaixo. Na forma inativa, a CDK2 liga-se à ciclina. Nesta situação

ela apresenta os resíduos Thr14 e Tyr15 fosforilados, que obstruem parcialmente o

sítio ativo da CDK2. Em seguida a CDK2 sofre fosforilação no resíduo Thr161, reação

esta catalisada pelo complexo CDK7/Ciclina H. Logo em seguida, a CDK2 sofre

desfosforilação dos resíduos Thr14 e Tyr15, reação catalisada pela fosfatase cdc25,

como indicado abaixo. Nesta etapa o sítio ativo fica livre, tornado o complexo

CDK2/ciclina ativo.

52

Quinases Dependentes de Ciclina

Fonte da figura: Canduri F, de Azevedo Jr., W. F. Structural Basis for Interaction of Inhibitors with Cyclin-

Dependent Kinase 2. Current Computer-Aided Drug Design, 2005, 1, 53-64

O algoritmo de Needleman/Wunsch (Needleman and Wunsch, 1970) tem como foco o

alinhamento global de sequências de DNA e proteínas. Com a explosão dos dados

genômicos no final do século passado, um problema central nos estudos genômicos

foi o alinhamento de sequências. Tais alinhamentos permitem inferir similaridade

sequencial e relacionar com as aspectos biológicos, como evolução, função,

conservação de estrutura tridimensional entre outros. O algoritmo de

Needleman/Wunsch será descrito aqui como modelo para entendermos as principais

características computacionais do alinhamento de sequências.

53

Algoritmo de Needleman/Wunsch

www.python.org

Referência:

Needleman, S. B. & Wunsch, C. D. (1970) "A General Method Applicable to the Search for Similarities in the

Amino Acid Sequence of Two Proteins," J. Mol. Biol., 48, 443-453.

Considerando-se os tipos de algoritmos vistos até o momento, temos que o algoritmo

de Needleman/Wunsch é de programação dinâmica.

O algoritmo de Needleman/Wunsch é dividido nas seguintes etapas:

1) Inicialização da matriz;

2) Preenchimento da matriz;

3) Alinhamento.

Para ilustrar o funcionamento do algoritmo, vamos considerar o alinhamento de duas

sequências:

GAATTCAGTTA (sequência #1) (temos m bases na sequência)

GGATCGA (sequência #2) (temos n bases na sequência)

54

Algoritmo de Needleman/Wunsch

www.python.org

Na fase de inicialização, montamos uma matriz m x n, como indicado abaixo. Na

matriz, às primeiras coluna e linha atribuímos zero, visto que estamos considerando

um alinhamento sem penalidade de gap inicial.

55

Algoritmo de Needleman/Wunsch (Inicialização)

www.python.org

0 G A A T T C A G T T A

0 0 0 0 0 0 0 0 0 0 0 0 0

G 0

G 0

A 0

T 0

C 0

G 0

A 0

Sequência #2

Sequência #1

0

1

2

3

4

5

6

7

0 1 2 3 4 5 6 7 8 9 10 11

Para o preenchimento da matriz, consideramos o início a partir da esquerda superior

da matriz. Para cada elemento Mi,j da matriz, determinaremos a seguinte função

escore:

Mi,j = MAXIMUM[

Mi-1, j-1 + Si,j (coincidência ou não na diagonal da matriz),

Mi,j-1 + w (gap na sequência #1),

Mi-1,j + w (gap na sequência #2)]

Onde w é o peso para inserção de um gap (intervalo), consideramos w = 0.

Si,j = 1 se a base na posição i da sequência #1 é a mesma da posição j na sequência #

2 (escore de coincidência), caso contrário,

Si,j = 0 (escore para não coincidência)

56

Algoritmo de Needleman/Wunsch (Preenchimento)

www.python.org

Aplicando-se o critério temos: M1,1 = MAXIMUM[

M0, 0 + S1,1 (coincidência ou não na diagonal da matriz),

M1,0 + w (gap na sequência #1),

M0,1 + w (gap na sequência #2)] = MAXIMUM[1,0,0], ou seja, M1,1 = 1

57


www.python.org

Sequência #2


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1

G 0

A 0

T 0

C 0

G 0

A 0

Sequência #1

0

1

2

3

4

5

6

7

0 1 2 3 4 5 6 7 8 9 10 11





58


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1

G 0 1

A 0

T 0

C 0

G 0

A 0

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





59


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1

G 0 1

A 0 1

T 0

C 0

G 0

A 0

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





60


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1

G 0 1

A 0 1

T 0 1

C 0

G 0

A 0

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





61


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0

A 0

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





62


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





63


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





64


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





65


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





66


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





67


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





68


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





69


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





70


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





71


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





72


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





73


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





74


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1

A 0 1

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





75


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1

A 0 1 2

T 0 1

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





76


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1

A 0 1 2

T 0 1 2

C 0 1

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





77


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





78


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





79


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





80


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





81


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





82


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





83


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





84


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





85


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





86


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





87


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





88


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





89


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2

T 0 1 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





90


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2

T 0 1 2 2

C 0 1 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





91


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2

T 0 1 2 2

C 0 1 2 2

G 0 1 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





92


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2

T 0 1 2 2

C 0 1 2 2

G 0 1 2 2

A 0 1 2

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





93


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2

T 0 1 2 2

C 0 1 2 2

G 0 1 2 2

A 0 1 2 3

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





94


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2

T 0 1 2 2

C 0 1 2 2

G 0 1 2 2

A 0 1 2 3

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





95


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2

T 0 1 2 2

C 0 1 2 2

G 0 1 2 2

A 0 1 2 3

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





96


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2

T 0 1 2 2

C 0 1 2 2

G 0 1 2 2

A 0 1 2 3

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





97


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2

T 0 1 2 2

C 0 1 2 2

G 0 1 2 2

A 0 1 2 3

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





98


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2

T 0 1 2 2

C 0 1 2 2

G 0 1 2 2

A 0 1 2 3

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





99


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2

T 0 1 2 2

C 0 1 2 2

G 0 1 2 2

A 0 1 2 3

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





100


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2

T 0 1 2 2

C 0 1 2 2

G 0 1 2 2

A 0 1 2 3

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11





101


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2

C 0 1 2 2

G 0 1 2 2

A 0 1 2 3

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11

Aplicando-se o critério para o restante da matriz, temos o resultado abaixo.

102


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11

No alinhamento iniciamos onde temos o maior escore, na posição 7,11, indicada pelo

círculo vermelho abaixo. Para escolher o próximo movimento, vemos as posições

anteriores, indicadas por flechas. Todas tem escore 5, assim movemos na diagonal.

Movimento na diagonal significa alinhamento das duas bases.

103

Algoritmo de Needleman/Wunsch (Alinhamento)

www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11

O alinhamento parcial está indicado abaixo.

104


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11

Sequência #1 G - A A T T C A G T T A

| | | | | |

Sequência #2 G G A - T - C - G - - A

Analisando-se os escores vizinhos, vemos que o maior está à esquerda (5), o que

indica uma inserção de gap na sequência 2, como mostrado abaixo.

105


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11


| | | | | |

Sequência #2 G G A - T - C - G - - AGap

Analisando-se os escores vizinhos, vemos que o maior está à esquerda (5) de novo, o

que indica uma nova inserção de gap na sequência 2, como mostrado abaixo.

106


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11


| | | | | |


Analisando-se os escores vizinhos, temos 4 em todos, assim seguimos na diagonal, o

que indica uma coincidência, como mostrado abaixo.

107


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11


| | | | | |


O maior escore entre os vizinhos é 4, o que indica a inserção de um novo gap na

sequência 2, como mostrado abaixo.

108


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11


| | | | | |


Novo movimento na diagonal, temos o alinhamento abaixo.

109


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11


| | | | | |


O escore mais alto está à esquerda (3), o que representa a inserção de gap na


110


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11


| | | | | |


Temos agora movimento na diagonal, e coincidência, como indicado abaixo.

111


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11


| | | | | |


O maior escore localiza-se à esquerda (2), o que representa a inserção de gap na


112


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11


| | | | | |


Agora temos um deslocamento na diagonal, o que leva a uma coincidência no

alinhamento, como mostrado abaixo.

113


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11


| | | | | |


Temos o maior escore na posição acima, o que representa uma inserção de gap na

sequência 1, como indicado abaixo.

114


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11


| | | | | |


Por último temos um deslocamento na diagonal, o que representa uma coincidência,

como indicado abaixo.

115


www.python.org


0 0 0 0 0 0 0 0 0 0 0 0 0

G 0 1 1 1 1 1 1 1 1 1 1 1

G 0 1 1 1 1 1 1 1 2 2 2 2

A 0 1 2 2 2 2 2 2 2 2 2 3

T 0 1 2 2 3 3 3 3 3 3 3 3

C 0 1 2 2 3 3 4 4 4 4 4 4

G 0 1 2 2 3 3 4 4 5 5 5 5

A 0 1 2 3 3 3 4 5 5 5 5 6

Sequência #1

0

1

2

3

4

5

6

7

Sequência #2

0 1 2 3 4 5 6 7 8 9 10 11


| | | | | |


Completamos o alinhamento. O algoritmo apresentado é uma simplificação, ficou

faltando um valor para a penalidade de gap na montagem da matriz. Programas de

alinhamento modernos, como BLAST e outros, levam em conta as penalidades. Além

disso, é feito uso de matrizes de escore, para pontuar diferentes alinhamentos, como

no caso de aminoácidos.

116


www.python.org


| | | | | |


Abaixo temos o programa algo_NW1.py, que realiza o alinhamento de duas

sequências, a partir do algoritmos de Needleman/Wunsch. O programa é

relativamente longo, assim apresentaremos por partes.

Inicialmente importamos a bibliotema NumPy que traz recursos matemáticos como

matrizes e vetores. As matrizes e vetores são implementados como arrays, que

assemelham-se a listas, mas com um tipo somente de dados.

Em seguida definimos as sequências a serem alinhadas e determinas o tamanho

delas.

117


www.python.org

# Import library

import numpy as np

# Sequences to aligned

seq1 = "GAATTCAGTTA"

seq2 = "GGATCGA"

# Length of sequences

n1 = len(seq1)+1

n2 = len(seq2)+1

Agora definimos a matriz caminho, a ser atribuída à variável M. Usamos o recurso

np.array(). Veja que as variáveis n1 e n2 definem os números de linhas e colunas da

matriz caminho.

Em seguida temos dois loops for para mostrar as sequências na tela.

118


www.python.org

# Set up path matrix

M = np.array([[0]*n1]*n2,int) # np.array([[0]*column]*row,float

# Show sequence

print("Sequences to be aligned:")

for i in range(n1-1):

print(seq1[i],end="")

print()

for j in range(n2-1):

print(seq2[j],end="")

Abaixo temos os trecho do código que define a matriz caminho (path matrix), com “1”

atribuído quando as bases coincidem.

119


www.python.org

# Define path matrix

# Looping through matrix

for i in range(1,n2):

for j in range(1,n1):

if seq1[j-1] == seq2[i-1]:

M[i][j] = 1

Para a construção da matriz completa, usamos a condição já vista para o alinhamento,

Mi,j = MAXIMUM[

Mi-1, j-1 + Si,j (coincidência ou não na diagonal da matriz),

Mi,j-1 + w (gap na sequência #1),

Mi-1,j + w (gap na sequência #2)]

120


www.python.org

# Build path matrix

for i in range(1,n2):

for j in range(1,n1):

my_array = [M[i-1][j-1] + M[i][j], M[i][j-1],M[i-1][j]]

M[i][j] = np.max(my_array)

Agora mostramos a matriz caminho na tela.

121


www.python.org

# Show path matrix

print("\n\nPath matrix:")

for i in range(n2):

for j in range(n1):

print(M[i][j],end=" ")

print()

Abaixo atribuímos valores para variáveis i e j que serão usadas em loops. Definimos

strings vazias para irmos montando as sequências alinhadas.

122


www.python.org

# Set up initial values for i and j

i = n2-1

j = n1-1

# Set up empty strings

s1 = ""

s2 = ""

Abaixo temos um loop while que monta as sequências alinhadas, que vão sendo

atribuídas às variáveis s1 e s2.

123


www.python.org

# while loop

while( i > 0 or j >0):

my_array = [M[i-1][j-1], M[i][j-1],M[i-1][j]]

m1 = np.max(my_array)

if m1 == M[i-1][j-1]:

s1 += seq1[j-1]

s2 += seq2[i-1]

i -= 1

j -= 1

elif m1 == M[i][j-1]:

s1 += seq1[j-1]

s2 += "-"

j -= 1

elif m1 == M[i-1][j]:

s1 += "-"

s2 += seq2[i-1]

i -= 1

Agora mostramos os resultados na tela. Como montamos as sequências invertidas,

temos que inverter as strings, usando-se o comando s1[::-1]. Este comando inverte a

sequência de bases atribuídas à variável s1.

Trabalho 2.

Modifique o código algo_NW1.py de forma que o novo programa leia as sequências de

dois arquivos de entrada no formato FASTA. O novo programa deve chamar-se

algo_NW2.py.

Data da entrega: 26/07/2016.

124


www.python.org

print("\nAligned sequences:")

print(s1[::-1])

print(s2[::-1])

ALBERTS, B. et al. Biologia Molecular da Célula. 4a edição. Porto Alegre: Artmed editora, Porto Alegre, 2004.

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

Referências

www.python.org

Bioinformática. Uma introdução com a linguagem Perl · Representação de átomos polares na...

Documents

Transcript of Bioinformática. Uma introdução com a linguagem Perl · Representação de átomos polares na...