bioinformática. uma introdução com a linguagem perl · de água entram em contato com a...
Post on 11-Feb-2019
221 Views
Preview:
TRANSCRIPT
©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
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
Código de acesso PDB: 1VXA
N
C
18
Estrutura da Mioglobina
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
Código de acesso PDB: 1VXA
N
C
19
Estrutura da Mioglobina
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
Código de acesso PDB: 1VXA
N
C
20
Estrutura da Mioglobina
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
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
Protein Data Bank (Para Sequências)
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
Protein Data Bank (Para Sequências)
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
Protein Data Bank (Para Sequências)
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
Protein Data Bank (Para Sequências)
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]
Leitura de Arquivos no Formato FASTA
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...
Leitura de Arquivos no Formato FASTA
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.
Leitura de Arquivos no Formato FASTA
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
Leitura de Arquivos no Formato FASTA
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
Leitura de Arquivos no Formato FASTA
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.
Leitura de Arquivos no Formato FASTA
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.
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
Supressor de Tumor p53
Fonte da figura: http://pdb101.rcsb.org/motm/31. Acesso em 30 de junho de 2016.
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
Supressor de Tumor p53
Fonte da figura: http://pdb101.rcsb.org/motm/31. Acesso em 30 de junho de 2016.
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
Supressor de Tumor p53
Fonte da figura: http://pdb101.rcsb.org/motm/31. Acesso em 30 de junho de 2016.
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
Algoritmo de Needleman/Wunsch (Preenchimento)
www.python.org
Sequência #2
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 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
Aplicando-se o critério temos: M2,1 = MAXIMUM[
M1, 0 + S2,1 (coincidência ou não na diagonal da matriz),
M2,0 + w (gap na sequência #1),
M1,1 + w (gap na sequência #2)] = MAXIMUM[1,0,1], ou seja, M2,1 = 1
58
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M3,1 = MAXIMUM[
M2, 0 + S3,1 (coincidência ou não na diagonal da matriz),
M3,0 + w (gap na sequência #1),
M2,1 + w (gap na sequência #2)] = MAXIMUM[0,0,1], ou seja, M3,1 = 1
59
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M4,1 = MAXIMUM[
M3, 0 + S4,1 (coincidência ou não na diagonal da matriz),
M4,0 + w (gap na sequência #1),
M3,1 + w (gap na sequência #2)] = MAXIMUM[0,0,1], ou seja, M4,1 = 1
60
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M5,1 = MAXIMUM[
M4, 0 + S5,1 (coincidência ou não na diagonal da matriz),
M5,0 + w (gap na sequência #1),
M4,1 + w (gap na sequência #2)] = MAXIMUM[0,0,1], ou seja, M5,1 = 1
61
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M6,1 = MAXIMUM[
M5, 0 + S6,1 (coincidência ou não na diagonal da matriz),
M6,0 + w (gap na sequência #1),
M5,1 + w (gap na sequência #2)] = MAXIMUM[1,0,1], ou seja, M6,1 = 1
62
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M7,1 = MAXIMUM[
M6, 0 + S7,1 (coincidência ou não na diagonal da matriz),
M7,0 + w (gap na sequência #1),
M6,1 + w (gap na sequência #2)] = MAXIMUM[0,0,1], ou seja, M7,1 = 1
63
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M1,2 = MAXIMUM[
M0, 1 + S1,2 (coincidência ou não na diagonal da matriz),
M1,1 + w (gap na sequência #1),
M0,2 + w (gap na sequência #2)] = MAXIMUM[0,1,0], ou seja, M1,2 = 1
64
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M1,3 = MAXIMUM[
M0, 2 + S1,3 (coincidência ou não na diagonal da matriz),
M1,2 + w (gap na sequência #1),
M0,3 + w (gap na sequência #2)] = MAXIMUM[0,1,0], ou seja, M1,3 = 1
65
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M1,4 = MAXIMUM[
M0, 3 + S1,4 (coincidência ou não na diagonal da matriz),
M1,3 + w (gap na sequência #1),
M0,4 + w (gap na sequência #2)] = MAXIMUM[0,1,0], ou seja, M1,4 = 1
66
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M1,5 = MAXIMUM[
M0, 4 + S1,5 (coincidência ou não na diagonal da matriz),
M1,4 + w (gap na sequência #1),
M0,5 + w (gap na sequência #2)] = MAXIMUM[0,1,0], ou seja, M1,5 = 1
67
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M1,6 = MAXIMUM[
M0, 5 + S1,6 (coincidência ou não na diagonal da matriz),
M1,5 + w (gap na sequência #1),
M0,6 + w (gap na sequência #2)] = MAXIMUM[0,1,0], ou seja, M1,6 = 1
68
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M1,7 = MAXIMUM[
M0, 6 + S1,7 (coincidência ou não na diagonal da matriz),
M1,6 + w (gap na sequência #1),
M0,7 + w (gap na sequência #2)] = MAXIMUM[0,1,0], ou seja, M1,7 = 1
69
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M1,8 = MAXIMUM[
M0, 7 + S1,8 (coincidência ou não na diagonal da matriz),
M1,7 + w (gap na sequência #1),
M0,8 + w (gap na sequência #2)] = MAXIMUM[1,1,0], ou seja, M1,8 = 1
70
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M1,9 = MAXIMUM[
M0, 8 + S1,9 (coincidência ou não na diagonal da matriz),
M1,8 + w (gap na sequência #1),
M0,9 + w (gap na sequência #2)] = MAXIMUM[0,1,0], ou seja, M1,9 = 1
71
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M1,10 = MAXIMUM[
M0, 9 + S1,10 (coincidência ou não na diagonal da matriz),
M1,9 + w (gap na sequência #1),
M0,10 + w (gap na sequência #2)] = MAXIMUM[0,1,0], ou seja, M1,10 = 1
72
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M1,11 = MAXIMUM[
M0, 10 + S1,11 (coincidência ou não na diagonal da matriz),
M1,10 + w (gap na sequência #1),
M0,11 + w (gap na sequência #2)] = MAXIMUM[0,1,0], ou seja, M1,11 = 1
73
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M2,2 = MAXIMUM[
M1, 1 + S2,2 (coincidência ou não na diagonal da matriz),
M2,1 + w (gap na sequência #1),
M1,2 + w (gap na sequência #2)] = MAXIMUM[1,1,1], ou seja, M2,2 = 1
74
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M3,2 = MAXIMUM[
M2, 1 + S3,2 (coincidência ou não na diagonal da matriz),
M3,1 + w (gap na sequência #1),
M2,2 + w (gap na sequência #2)] = MAXIMUM[2,1,1], ou seja, M3,2 = 2
75
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M4,2 = MAXIMUM[
M3, 1 + S4,2 (coincidência ou não na diagonal da matriz),
M4,1 + w (gap na sequência #1),
M3,2 + w (gap na sequência #2)] = MAXIMUM[1,1,2], ou seja, M4,2 = 2
76
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M5,2 = MAXIMUM[
M4, 1 + S5,2 (coincidência ou não na diagonal da matriz),
M5,1 + w (gap na sequência #1),
M4,2 + w (gap na sequência #2)] = MAXIMUM[1,1,2], ou seja, M5,2 = 2
77
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M6,2 = MAXIMUM[
M5, 1 + S6,2 (coincidência ou não na diagonal da matriz),
M6,1 + w (gap na sequência #1),
M5,2 + w (gap na sequência #2)] = MAXIMUM[1,1,2], ou seja, M6,2 = 2
78
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M7,2 = MAXIMUM[
M6, 1 + S7,2 (coincidência ou não na diagonal da matriz),
M7,1 + w (gap na sequência #1),
M7,2 + w (gap na sequência #2)] = MAXIMUM[2,1,2], ou seja, M7,2 = 2
79
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M2,3 = MAXIMUM[
M1, 2 + S2,3 (coincidência ou não na diagonal da matriz),
M2,2 + w (gap na sequência #1),
M1,3 + w (gap na sequência #2)] = MAXIMUM[1,1,1], ou seja, M2,3 = 1
80
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M2,4 = MAXIMUM[
M1, 3 + S2,4 (coincidência ou não na diagonal da matriz),
M2,3 + w (gap na sequência #1),
M1,4 + w (gap na sequência #2)] = MAXIMUM[1,1,1], ou seja, M2,4 = 1
81
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M2,5 = MAXIMUM[
M1, 4 + S2,5 (coincidência ou não na diagonal da matriz),
M2,4 + w (gap na sequência #1),
M1,5 + w (gap na sequência #2)] = MAXIMUM[1,1,1], ou seja, M2,5 = 1
82
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M2,6 = MAXIMUM[
M1, 5 + S2,6 (coincidência ou não na diagonal da matriz),
M2,5 + w (gap na sequência #1),
M1,6 + w (gap na sequência #2)] = MAXIMUM[1,1,1], ou seja, M2,6 = 1
83
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M2,7 = MAXIMUM[
M1, 6 + S2,7 (coincidência ou não na diagonal da matriz),
M2,6 + w (gap na sequência #1),
M1,7 + w (gap na sequência #2)] = MAXIMUM[1,1,1], ou seja, M2,7 = 1
84
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M2,8 = MAXIMUM[
M1, 7 + S2,8 (coincidência ou não na diagonal da matriz),
M2,7 + w (gap na sequência #1),
M1,8 + w (gap na sequência #2)] = MAXIMUM[2,1,1], ou seja, M2,8 = 2
85
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M2,9 = MAXIMUM[
M1, 8 + S2,9 (coincidência ou não na diagonal da matriz),
M2,8 + w (gap na sequência #1),
M1,9 + w (gap na sequência #2)] = MAXIMUM[1,2,1], ou seja, M2,9 = 2
86
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M2,10 = MAXIMUM[
M1, 9 + S2,10 (coincidência ou não na diagonal da matriz),
M2,9 + w (gap na sequência #1),
M1,10 + w (gap na sequência #2)] = MAXIMUM[1,2,1], ou seja, M2,10 = 2
87
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M2,11 = MAXIMUM[
M1, 10 + S2,11 (coincidência ou não na diagonal da matriz),
M2,10 + w (gap na sequência #1),
M1,11 + w (gap na sequência #2)] = MAXIMUM[1,2,1], ou seja, M2,11 = 2
88
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M3,3 = MAXIMUM[
M2, 2 + S3,3 (coincidência ou não na diagonal da matriz),
M3,2 + w (gap na sequência #1),
M2,3 + w (gap na sequência #2)] = MAXIMUM[2,2,1], ou seja, M3,3 = 2
89
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M4,3 = MAXIMUM[
M3, 2 + S4,3 (coincidência ou não na diagonal da matriz),
M4,2 + w (gap na sequência #1),
M3,3 + w (gap na sequência #2)] = MAXIMUM[2,2,2], ou seja, M4,3 = 2
90
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M5,3 = MAXIMUM[
M4, 2 + S5,3 (coincidência ou não na diagonal da matriz),
M5,2 + w (gap na sequência #1),
M4,3 + w (gap na sequência #2)] = MAXIMUM[2,2,2], ou seja, M5,3 = 2
91
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M6,3 = MAXIMUM[
M5, 2 + S6,3 (coincidência ou não na diagonal da matriz),
M6,2 + w (gap na sequência #1),
M5,3 + w (gap na sequência #2)] = MAXIMUM[2,2,2], ou seja, M6,3 = 2
92
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M7,3 = MAXIMUM[
M6, 2 + S7,3 (coincidência ou não na diagonal da matriz),
M7,2 + w (gap na sequência #1),
M6,3 + w (gap na sequência #2)] = MAXIMUM[3,2,2], ou seja, M7,3 = 3
93
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M3,4 = MAXIMUM[
M2, 3 + S3,4 (coincidência ou não na diagonal da matriz),
M3,3 + w (gap na sequência #1),
M2,4 + w (gap na sequência #2)] = MAXIMUM[1,2,1], ou seja, M3,4 = 2
94
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M3,5 = MAXIMUM[
M2, 4 + S3,5 (coincidência ou não na diagonal da matriz),
M3,4 + w (gap na sequência #1),
M2,5 + w (gap na sequência #2)] = MAXIMUM[1,2,1], ou seja, M3,5 = 2
95
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M3,6 = MAXIMUM[
M2, 5 + S3,6 (coincidência ou não na diagonal da matriz),
M3,5 + w (gap na sequência #1),
M2,6 + w (gap na sequência #2)] = MAXIMUM[1,2,1], ou seja, M3,6 = 2
96
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M3,7 = MAXIMUM[
M2, 6 + S3,7 (coincidência ou não na diagonal da matriz),
M3,6 + w (gap na sequência #1),
M2,7 + w (gap na sequência #2)] = MAXIMUM[2,2,1], ou seja, M3,7 = 2
97
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M3,8 = MAXIMUM[
M2, 7 + S3,8 (coincidência ou não na diagonal da matriz),
M3,7 + w (gap na sequência #1),
M2,8 + w (gap na sequência #2)] = MAXIMUM[1,2,2], ou seja, M3,8 = 2
98
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M3,9 = MAXIMUM[
M2, 8 + S3,9 (coincidência ou não na diagonal da matriz),
M3,8 + w (gap na sequência #1),
M2,9 + w (gap na sequência #2)] = MAXIMUM[2,2,2], ou seja, M3,9 = 2
99
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M3,10 = MAXIMUM[
M2, 9 + S3,10 (coincidência ou não na diagonal da matriz),
M3,9 + w (gap na sequência #1),
M2,10 + w (gap na sequência #2)] = MAXIMUM[2,2,2], ou seja, M3,10 = 2
100
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Aplicando-se o critério temos: M3,11 = MAXIMUM[
M2, 10 + S3,11 (coincidência ou não na diagonal da matriz),
M3,10 + w (gap na sequência #1),
M2,11 + w (gap na sequência #2)] = MAXIMUM[3,2,2], ou seja, M3,11 = 3
101
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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
Algoritmo de Needleman/Wunsch (Preenchimento)
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 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 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 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
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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 - - 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
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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, temos 4 em todos, assim seguimos na diagonal, o
que indica uma coincidência, como mostrado abaixo.
107
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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
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
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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
Novo movimento na diagonal, temos o alinhamento abaixo.
109
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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
O escore mais alto está à esquerda (3), o que representa a inserção de gap na
sequência 2, como mostrado abaixo.
110
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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
Temos agora movimento na diagonal, e coincidência, como indicado abaixo.
111
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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
O maior escore localiza-se à esquerda (2), o que representa a inserção de gap na
sequência 2, como mostrado abaixo.
112
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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
Agora temos um deslocamento na diagonal, o que leva a uma coincidência no
alinhamento, como mostrado abaixo.
113
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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
Temos o maior escore na posição acima, o que representa uma inserção de gap na
sequência 1, como indicado abaixo.
114
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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
Por último temos um deslocamento na diagonal, o que representa uma coincidência,
como indicado abaixo.
115
Algoritmo de Needleman/Wunsch (Alinhamento)
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 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
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
Algoritmo de Needleman/Wunsch (Alinhamento)
www.python.org
Sequência #1 G - A A T T C A G T T A
| | | | | |
Sequência #2 G G A - T - C - G - - A
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
Algoritmo de Needleman/Wunsch (Alinhamento)
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
Algoritmo de Needleman/Wunsch (Alinhamento)
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
Algoritmo de Needleman/Wunsch (Alinhamento)
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
Algoritmo de Needleman/Wunsch (Alinhamento)
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
Algoritmo de Needleman/Wunsch (Alinhamento)
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
Algoritmo de Needleman/Wunsch (Alinhamento)
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
Algoritmo de Needleman/Wunsch (Alinhamento)
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
Algoritmo de Needleman/Wunsch (Alinhamento)
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
top related