Linguagem de Programação Python

azevedolab.net
1
© 2016 Dr. Walter F. de Azevedo Jr.
000000000000000000000000000000000000000
000000000000000000000000000000000000000
000000000000000000000000010000000000000
000000000000000000000111111111100000000
000000000000000000001111110000000000110
000000000000110000001111100000000111110
000000000001000011001111111111111111000
000000000010001110110001111111000000000
000000000011111111111111111111111110000
000001111111111111111111111111111110000
000000111111111111111111111111110000000
000000000111111111111111111111000000000
000000000111111111111111110000000000000
000000000111111111111111111110000000000
000000001111101111111111111111000000000
000000001111100111111111111111000000000
000000000000111111111111110011100000000
000000000000001111111110111111100000000
000000000000001110000011101100000000000
000000000000000000011111001100000000000
000000000000000000000000110000000000000
000000000000000000000000000000000000000
000000000000000000000000000000000000000
000000000000000000000000000000000000000
000000000000000000000000000000000000000
Módulo random
www.python.org
Vamos usar alguns programas simples na aula de hoje, para o estudo dos itens
destacados no slide anterior. Os programas estão disponíveis no site:
http://www.delmarlearning.com/companions/content/1435455002/downloads/index.asp
?isbn=1435455002, acesso em: 21 de julho 2016. Esses programas são discutidos no
livro: DAWSON, Michael. Python Programming, for the absolute beginner. 3ed.
Boston: Course Technology, 2010. 455 p.
Considere o programa craps_roller.py, mostrado abaixo. Vamos analisar cada linha de
código nos próximos slides. O programa simula o lançamento de dois dados, como
num jogo de cassino chamado “Craps Roller”, quem tiver interesse em saber quais
são
as
chances
de
ganhar
no
“Craps
Roller”,
veja
o
site:
http://www.math.uah.edu/stat/games/Craps.html, acesso em: 21 de julho 2016.
import random
# Generates random numbers from 1 to 6
die1 = random.randint(1,6)
die2 = random.randrange(6) + 1
total = die1 + die2
print(“\nYou rolled a ”,die1,“and a ”,die2,” for a total of “,total)
2
Módulo random
www.python.org
A primeira linha importa o módulo random. Já vimos nas aulas anteriores, que o
comando import é usado para carregar um arquivo com código previamente
preparado. O código carregado, com o comando import, passa a fazer parte do
programa que o chama. Assim, podemos chamar uma função específica do módulo
carregado. Normalmente, os módulos são preparados dentro de um tema, por
exemplo, o módulo random traz funções relacionadas à geração de números
aleatórios. Na verdade, o termo aleatório deveria ser substituído por “pseudoaleatório”,
visto que o interpretador Python usa uma equação para gerar os números ditos
aleatórios, assim não podem ser considerados aleatórios no sentido restrito da
palavra. Para termos números aleatórios, devemos usar fenômenos naturais, tais
como decaimento de partículas alfa, para, desta forma, obtermos uma sequência de
números aleatórios. Mais informações em: http://www.fourmilab.ch/hotbits/ , acesso
em: 21 de julho 2016.
import random
# Generates random numbers from 1 to 6
die1 = random.randint(1,6)
die2 = random.randrange(6) + 1
total = die1 + die2
print(“\nYou rolled a ”,die1,“and a ”,die2,” for a total of “,total)
3
Módulo random
www.python.org
Para gerarmos os números com o módulo random, chamamos as funções
necessárias. Por exemplo, a função randint(), destacada em vermelho no código
abaixo. Para chamarmos a função, usamos a notação dot, vista anteriormente.
Especificamente, random.randint(1,6) retorna um número entre 1 e 6, incluindo os
extremos. Esse número é atribuído à variável die1. Se chamássemos a função
diretamente, com randint(1,6), teríamos uma mensagem de erro, especificamente, um
erro de sintaxe ou execução. Assim, a regra para o uso das funções presentes nos
módulos, é colocar o nome do módulo, ao qual pertence a função, seguido do
ponto “.” e o nome da função, como indicado no quadro abaixo.
modulo.função(argumento(s))
import random
# Generates random numbers from 1 to 6
die1 = random.randint(1,6)
die2 = random.randrange(6) + 1
total = die1 + die2
print(“\nYou rolled a ”,die1,“and a ”,die2,” for a total of “,total)
4
Módulo random
www.python.org
A função randrange(6) gera um número entre 0 e 5, ou seja, o número indicado como
argumento da função, não faz parte do conjunto de números pseudoaleatórios a
serem gerados pela função. Assim, se usarmos a função randrange() para gerar um
número pseudoaleatório entre 1 e 6, temos que somar “1” ao resultado, como
mostrado na linha de código em vermelho abaixo. Veja, como na função randint(), os
números gerados são inteiros, a diferença é que na função randrange() não
precisamos especificar o limite inferior, é assumido ser zero “0”. É usada a notação
dot, e o resultado atribuído à variável die2.
import random
# Generates random numbers from 1 to 6
die1 = random.randint(1,6)
die2 = random.randrange(6) + 1
total = die1 + die2
print(“\nYou rolled a ”,die1,“and a ”,die2,” for a total of “,total)
5
Módulo random
www.python.org
Como os números pseudoaleatórios foram atribuídos às variáveis die1 e die2,
podemos operar com os valores. A linha em destaque abaixo, realiza a soma dos
valores atribuídos às variáveis die1 e die2 e atribui o resultado à variável total. A linha
seguinte mostra o resultado na tela.
import random
# Generates random numbers from 1 to 6
die1 = random.randint(1,6)
die2 = random.randrange(6) + 1
total = die1 + die2
print(“\nYou rolled a ”,die1,“and a ”,die2,” for a total of “,total)
6
Programa guess_my_number.py
www.python.org
Veremos a aplicação do módulo random num programa de jogo, onde você tenta
adivinhar um número pseudoaleatório entre 1 e 100 gerado pelo computador, o
programa chama-se guess_my_number.py. Veremos a execução do programa antes
de vermos seu código.
Welcome to 'Guess My Number'!
I'm thinking of a number between 1 and 100.
Try to guess it in as few attempts as possible.
Take a guess: 50
Lower...
Take a guess: 25
Higher...
Take a guess: 38
Higher...
Take a guess: 44
You guessed it! The number was 44
And it only took you 4 tries!
7
Programa guess_my_number.py
www.python.org
O programa guess_my_number.py está mostrado abaixo. A primeira linha importa o
módulo random, que tem as funções para gerarmos números pseudoaleatórios.
import random
print("\tWelcome to 'Guess My Number'!")
print("\nI'm thinking of a number between 1 and 100.")
print("Try to guess it in as few attempts as possible.\n")
the_number = random.randint(1, 100)
guess = int(input("Take a guess: "))
tries = 1
while guess != the_number:
# guessing loop
if guess > the_number:
print("Lower...")
else:
print("Higher...")
guess = int(input("Take a guess: "))
tries += 1
print("You guessed it!
The number was", the_number)
print("And it only took you", tries, "tries!\n")
8
Programa guess_my_number.py
www.python.org
As três linhas seguintes são funções print() que mostram uma mensagem de boasvindas e informações sobre o jogo.
import random
print("\tWelcome to 'Guess My Number'!")
print("\nI'm thinking of a number between 1 and 100.")
print("Try to guess it in as few attempts as possible.\n")
the_number = random.randint(1, 100)
guess = int(input("Take a guess: "))
tries = 1
while guess != the_number:
# guessing loop
if guess > the_number:
print("Lower...")
else:
print("Higher...")
guess = int(input("Take a guess: "))
tries += 1
print("You guessed it!
The number was", the_number)
print("And it only took you", tries, "tries!\n")
9
Programa guess_my_number.py
www.python.org
Depois usamos a função randint(1,100) do módulo random, para gerar um número
pseudoaleatório entre 1 e 100. O número gerado será atribuído à variável the_number.
import random
print("\tWelcome to 'Guess My Number'!")
print("\nI'm thinking of a number between 1 and 100.")
print("Try to guess it in as few attempts as possible.\n")
the_number = random.randint(1, 100)
guess = int(input("Take a guess: "))
tries = 1
while guess != the_number:
# guessing loop
if guess > the_number:
print("Lower...")
else:
print("Higher...")
guess = int(input("Take a guess: "))
tries += 1
print("You guessed it!
The number was", the_number)
print("And it only took you", tries, "tries!\n")
10
Programa guess_my_number.py
www.python.org
O programa agora pergunta ao usuário pelo o número que ele acha que foi escolhido
pelo computador, e atribui esse número à variável guess. O número 1 é atribuído à
variável tries, que indica o número de tentativas que o jogador fez.
import random
print("\tWelcome to 'Guess My Number'!")
print("\nI'm thinking of a number between 1 and 100.")
print("Try to guess it in as few attempts as possible.\n")
the_number = random.randint(1, 100)
guess = int(input("Take a guess: "))
tries = 1
while guess != the_number:
# guessing loop
if guess > the_number:
print("Lower...")
else:
print("Higher...")
guess = int(input("Take a guess: "))
tries += 1
print("You guessed it!
The number was", the_number)
print("And it only took you", tries, "tries!\n")
11
Programa guess_my_number.py
www.python.org
A condição do loop while, é que o valor atribuído à variável guess seja diferente do
atribuído à variável the_number, ou seja, o bloco do loop while será executado,
enquanto os números forem diferentes.
import random
print("\tWelcome to 'Guess My Number'!")
print("\nI'm thinking of a number between 1 and 100.")
print("Try to guess it in as few attempts as possible.\n")
the_number = random.randint(1, 100)
guess = int(input("Take a guess: "))
tries = 1
while guess != the_number:
# guessing loop
if guess > the_number:
print("Lower...")
else:
print("Higher...")
guess = int(input("Take a guess: "))
tries += 1
print("You guessed it!
The number was", the_number)
print("And it only took you", tries, "tries!\n")
12
Programa guess_my_number.py
www.python.org
No bloco do loop temos o comando if, que testa se o valor atribuído à variável guess é
maior que ao atribuído à variável the_number, caso seja, o programa mostra a
mensagem “Lower...”, indicando que o jogador deve digitar um número menor.
import random
print("\tWelcome to 'Guess My Number'!")
print("\nI'm thinking of a number between 1 and 100.")
print("Try to guess it in as few attempts as possible.\n")
the_number = random.randint(1, 100)
guess = int(input("Take a guess: "))
tries = 1
while guess != the_number:
# guessing loop
if guess > the_number:
print("Lower...")
else:
print("Higher...")
guess = int(input("Take a guess: "))
tries += 1
print("You guessed it!
The number was", the_number)
print("And it only took you", tries, "tries!\n")
13
Programa guess_my_number.py
www.python.org
Caso o valor atribuído à variável guess, não seja maior que o atribuído à variável
the_number, é mostrada a mensagem “Higher ...”, para que o jogador digite um
número mais alto.
import random
print("\tWelcome to 'Guess My Number'!")
print("\nI'm thinking of a number between 1 and 100.")
print("Try to guess it in as few attempts as possible.\n")
the_number = random.randint(1, 100)
guess = int(input("Take a guess: "))
tries = 1
while guess != the_number:
# guessing loop
if guess > the_number:
print("Lower...")
else:
print("Higher...")
guess = int(input("Take a guess: "))
tries += 1
print("You guessed it!
The number was", the_number)
print("And it only took you", tries, "tries!\n")
14
Programa guess_my_number.py
www.python.org
Depois é lido um novo valor para o número e atribuído à variável guess. É somado 1
ao valor atribuído à variável tries. O bloco de comandos é executado, até que a
condição do while não seja mais satisfeita, ou seja, o jogador achou o número.
import random
print("\tWelcome to 'Guess My Number'!")
print("\nI'm thinking of a number between 1 and 100.")
print("Try to guess it in as few attempts as possible.\n")
the_number = random.randint(1, 100)
guess = int(input("Take a guess: "))
tries = 1
while guess != the_number:
# guessing loop
if guess > the_number:
print("Lower...")
else:
print("Higher...")
guess = int(input("Take a guess: "))
tries += 1
print("You guessed it!
The number was", the_number)
print("And it only took you", tries, "tries!\n")
15
Programa guess_my_number.py
www.python.org
Como o programa só sairá do bloco do loop while, quando o jogador acertar o número,
colocamos, logo após os comandos do loop while, duas funções print() com as
informações sobre o número encontrado e o número de tentativas necessárias.
import random
print("\tWelcome to 'Guess My Number'!")
print("\nI'm thinking of a number between 1 and 100.")
print("Try to guess it in as few attempts as possible.\n")
the_number = random.randint(1, 100)
guess = int(input("Take a guess: "))
tries = 1
while guess != the_number:
# guessing loop
if guess > the_number:
print("Lower...")
else:
print("Higher...")
guess = int(input("Take a guess: "))
tries += 1
print("You guessed it!
The number was", the_number)
print("And it only took you", tries, "tries!\n")
16
GenBank
www.python.org
O GenBank é uma base de dados de sequências de genes, como destacado na sua
página de entrada. Toda informação, advinda do sequenciamento de diversos
genomas, está armazenada de forma organizada e de acesso aberto no GenBank. O
acesso pode ser feito no site: http://www.ncbi.nlm.nih.gov/genbank/
17
GenBank
www.python.org
Vamos ilustrar um exemplo com a consulta de sequência de bases do genoma do
Mycobacterium tuberculosis. No campo indicado abaixo, selecionamos “Genome”.
18
GenBank
www.python.org
Depois digitamos Mycobacterium tuberculosis. No campo indicado abaixo, e
pressionamos “Search”.
19
GenBank
www.python.org
O resultado da nossa busca está mostrado abaixo. Na parte em destaque temos o
dendrograma, que mostra a proximidade entre os genomas depositados com o do
Mycobacterium tuberculosis. Nosso foco é o depósito identificado como H37Rv.
20
GenBank
www.python.org
Abaixo, na mesma página, temos informação sobre os genomas que apresentam a
identificação Mycobacterium tuberculosis, pode haver mais de um, como abaixo, pois
foram sequenciadas diferentes cepas da bactéria. Vamos olhar os detalhes da tabela
abaixo.
21
GenBank
www.python.org
A tabela abaixo traz informações sobre o o tamanho dos genomas (em MegaBases,
ou seja 106 bases) de Mycobacterium tuberculosis, bem como disponibilidade do
genoma, a porcentagem de bases CG no genoma, o número de genes identificados e
proteínas.
22
GenBank
www.python.org
Outra informação da página, destaca as publicações relacionadas com os genomas
descritos. Abaixo temos 3 artigos em destaque.
23
GenBank
www.python.org
Clicando no genoma indicado abaixo, teremos detalhamento das informações
específicas do genoma clicado.
24
GenBank
www.python.org
Podemos acessar o arquivo FASTA com a sequência completa do genoma, clicando
na opção FASTA, mostrada abaixo.
25
GenBank
www.python.org
Abaixo temos a sequência de bases de todo genoma do Mycobacterium tuberculosis.
26
GenBank
www.python.org
Podemos salvá-la e manipulá-la com o editor de texto, clicamos na opção Send to,
indicada abaixo.
27
GenBank
www.python.org
Ao clicarmos teremos as opções mostradas abaixo, clicamos no File.
28
GenBank
www.python.org
Podemos escolher o formato e clicar na opção de criar o arquivo de saída, indicado
abaixo.
29
GenBank
www.python.org
Teremos o download do arquivo fasta com a sequência completa do genoma de
Mycobacterium tuberculosis, como indicado abaixo. O nome do arquivo baixado é
sequence.fasta.
30
Protein Data Bank
www.python.org
Vimos nas últimas aulas diversos programas em Python para a manipulação de
arquivos FASTA. Podemos dizer, que a informação armazenada em tais arquivos,
apresenta complexidade unidimensional, temos a estrutura primária de ácidos
nucleicos e proteínas. Por outro lado, informações sobre a estrutura tridimensional de
macromoléculas biológicas podem ser armazenadas em arquivos no formato protein
data bank (PDB). Veremos agora um programa para a manipulação da informação
contida nos arquivos PDB.
31
Protein Data Bank
www.python.org
Um arquivo PDB tem basicamente dois tipos de informação. A primeira, indicada pelo
início da linha com as palavras-chaves REMARK, HEADER, TITLE, CRYST1 e
COMPND entre outras. São comentários sobre detalhes da estrutura depositada,
como autores, detalhes sobre a técnica usada para resolução da estrutura, bem como
informações sobre a qualidade estereoquímica da molécula armazenada no arquivo. O
outro tipo de informação, são as coordenadas atômicas. Esta informação é a de maior
importância, pois indica as coordenadas x, y e z de cada átomo da estrutura
depositada, são iniciadas pelas palavras-chaves ATOM ou HETATM.
32
Protein Data Bank
www.python.org
Vejamos como fazer o download da estrutura da cyclin-dependente kinase 2 em
complexo com o fármaco roscovitine depositada com o código 2A4L. Inicialmente
digitamos o código da proteína que desejamos baixar, no caso 2A4L, e clicamos na
lupa, como indicado abaixo.
33
Protein Data Bank
www.python.org
Agora temos acesso à estrutura. Para fazer download, clicamos na opção “Download
File>PDB File(Text)”. Assim podemos escolher a pasta onde salvar o arquivo PDB.
34
Protein Data Bank
www.python.org
Os arquivos PDB são arquivos texto simples, poderíamos abrir com qualquer editor de
texto para ver seu conteúdo. Abaixo temos as primeiras linhas do arquivo 2A4L.pdb.
Veja que o PDB tem uma estrutura fixa, à esquerda no início de cada linha temos uma
palavra-chave que identifica o tipo de informação contida na linha. Por exemplo,
HEADER identifica a molécula armazenada, no caso uma transferase. Temos,
também, a data do depósito da estrutura. Em seguida temos a palavra-chave TITLE,
que identifica a molécula depositada. Nas próximas linhas temos a palavra-chave
COMPND, que detalha a(s) molécula(s) contida(s) no arquivo. Não iremos identificar
todas as palavras-chaves do PDB neste primeiro contato. Vamos nos concentrar nas
coordenadas atômicas.
HEADER
TITLE
COMPND
COMPND
COMPND
COMPND
COMPND
COMPND
TRANSFERASE
29-JUN-05
2A4L
HUMAN CYCLIN-DEPENDENT KINASE 2 IN COMPLEX WITH ROSCOVITINE
MOL_ID: 1;
2 MOLECULE: HOMO SAPIENS CYCLIN-DEPENDENT KINASE 2;
3 CHAIN: A;
4 SYNONYM: CDK2;
5 EC: 2.7.1.37;
6 ENGINEERED: YES
35
Protein Data Bank
www.python.org
Abaixo temos a primeira linha com coordenadas atômicas do arquivo 2A4L.pdb.
Temos dois tipos de palavras-chaves usadas para linhas de coordenadas atômicas,
uma é a palavra-chave ATOM, que é usada para identificar coordenadas atômicas
para proteína. A outra é a palavra-chave HETATM, que traz a parte não proteica da
estrutura, pode ser um inibidor ligado à estrutura da proteína, cofatores, íons ou outras
moléculas que aparecem em complexo com a proteína.
ATOM
1
N
MET A
1
101.710 112.330
93.759
1.00 48.54
N
36
Protein Data Bank
www.python.org
Veremos em breve como fazer a leitura de um arquivo PDB em Python, mas antes
veremos o formato das linhas de coordenadas atômicas. Vamos considerar que lemos
uma linha de um arquivo PDB e temos a informação atribuída à variável line. Uma
string em Python pode ser fatiada em colunas, por exemplo, line[0:6] representa as
seis primeiras posições da string atribuída à variável line. Assim teríamos “ATOM “ em
line[0:6], veja que sempre iniciamos na posição zero, assim line[0] é “A”, line[1]” é “T” e
assim sucessivamente. Usando tal funcionalidade do Python, podemos dividir uma
linha do PDB em diferentes fatias. Cada linha de um arquivo PDB tem 80 colunas, ou
seja, uma string com 80 caracteres.
ATOM
1
N
MET A
1
101.710 112.330
93.759
1.00 48.54
N
37
Protein Data Bank
www.python.org
Como já destacamos, as informações sobre as coordenadas atômicas estão em linhas
que iniciam com ATOM ou HETATM. Abaixo temos a indicação dos campos de uma
linha, com informações sobre o conteúdo de cada parte num arquivo PDB.
ATOM
1
N
MET A
1
101.710 112.330
93.759
1.00 48.54
N
Colunas 57-60 para a ocupação, é atribuída à variável line[56:60]
Colunas 32-53 para as coordenadas atômicas, são atribuídas às variáveis
line[30:38], line[38:46], line[46:54]
Colunas 23-26 para o número do resíduo, é atribuída à variável line[22:26]
Coluna 22 para o identificador da cadeia, é atribuída à variável line[21:22]
Colunas de 18-20 para o nome do aminoácido (ou ligante, ou HOH), é atribuída à variável line[17:20]
Colunas de 14-15 para o nome do átomo, é atribuída à variável line[13:15]
Colunas de 7-11 para a ordem do átomo, é atribuída à variável line[6:11]
Colunas de 1-6 para string com ATOM ou HETATM, é atribuída à variável line[0:6]
38
Protein Data Bank
www.python.org
As informações sobre as últimas colunas.
ATOM
1
N
MET A
1
101.710 112.330
93.759
1.00 48.54
N
Colunas 62-65 para o fator de vibração térmica, é atribuída à variável line[61:65]
Colunas 77-77 para o elemento químico, é atribuída à variável line[76:77]
Além das informações indicadas anteriormente, há o
identificador de segmento (colunas 73-76), atribuído à
variável line[72:76]. Temos, também, a carga elétrica do
átomo (colunas 79-80), atribuída à variável line[78:80].
Vamos ilustrar com um programa para leitura de arquivos PDB.
39
Programa: readPDB1.py
www.python.org
Leitura de arquivos PDB (versão 1)
Programa: readPDB1.py
Resumo
Programa para leitura de arquivo de coordenadas atômicas no formato protein
data bank (PDB). Após a leitura do arquivo PDB, o programa mostra as
coordenadas atômicas da parte proteica na tela. O usuário digita o nome do
arquivo PDB de entrada. As colunas 32-53 são usadas para as coordenadas
atômicas x, y e z, e serão atribuídas às variáveis line[30:38], line[38:46] e
line[46:54], respectivamente.
40
Programa: readPDB1.py
www.python.org
Com 6 linhas de código conseguimos o programa para leitura do arquivo PDB. Na
primeira linha lemos o nome do arquivo de entrada, que é atribuído à variável
pdbFileIn. Em seguida, o arquivo é aberto com a função open() e o conteúdo atribuído
ao objeto arquivo fo. Cada elemento do objeto arquivo é uma linha do arquivo PDB. A
partir de um loop for, podemos varrer o objeto arquivo fo. Dentro do loop for testamos
se a string atribuída à variável line[0:6] é igual “ATOM “. Caso seja, mostramos as
coordenadas atômicas atribuídas às variáveis line[30:38], line[38:46], line[46:54]. Por
último, fechamos o arquivo com close(). O código está mostrado abaixo.
pdbFileIn = input("\nType the PDB file name => ")
fo = open(pdbFileIn,"r")
for line in fo:
if line[0:6] == "ATOM
":
print(line[30:38], line[38:46], line[46:54])
fo.close()
Como os arquivos PDB tem uma estrutura bem definida, temos certeza que seu
conteúdo está dividido em linhas, assim, para a leitura simples, não precisamos do
41
.readlines() .
Programa: readPDB1.py
www.python.org
Ao rodarmos o programa para o arquivo 2A4L.pdb, temos o seguinte resultado. Só
as primeiras linhas são mostradas abaixo, visto que o arquivo PDB tem milhares de
linhas com coordenadas atômicas.
Type the PDB file name => 2a4l.pdb
101.710 112.330
93.759
102.732 113.140
94.479
103.199 114.420
93.762
102.995 114.577
92.561
103.933 112.272
94.785
104.548 112.540
96.126
106.336 112.671
95.934
106.542 114.250
95.159
103.906 115.275
94.503
104.085 116.695
94.178
105.065 117.015
93.046
104.918 118.030
92.386
104.531 117.459
95.428
103.464 117.597
96.515
......
42
Programa: randomDNA1.py (Trabalho 3)
www.python.org
Random DNA (versão 1)
Programa: randomDNA1.py
Resumo
Programa para gerar um trecho de DNA com uma sequência aleatória. A
sequência do DNA será atribuída a uma variável do tipo string (variável dna),
onde cada base será gerada aleatoriamente (variável base), a partir do módulo
random e adicionada à sequência de DNA. O programa tem como entrada o
tamanho da sequência de DNA, a ser gerada aleatoriamente. A sequência
aleatória será mostrada na tela. Para adicionar a base aleatória à sequência de
DNA, podemos usar o operador “+” ou “”.join([dna,base]).
43
Programa: randomDNA1.py (Trabalho 3)
www.python.org
O programa é relativamente simples, o principal bloco do programa é um loop while,
que monta a sequência do DNA. Dentro do loop while temos que gerar um número
aleatório, entre 1 e 4, por exemplo. Depois temos que testar qual número foi gerado,
usando o comando if/elif/else. Atribuímos a cada número uma base (variável base),
que será adicionada à string dna. Podemos usar o operador “+” para ir montando a
sequência, por exemplo:
dna = dna + base
Podemos, ainda, usar o método “”.join(), como indicado abaixo.
dna = "".join([dna,base])
Em ambas situações, temos que criar a variável dna antes do loop while, para que
possa ser adicionada a base. À variável dna devemos atribuir uma string vazia, como
indicado abaixo.
dna = ""
44
Programa: randomDNA2.py (Trabalho 3)
www.python.org
Random DNA (versão 2)
Programa: randomDNA2.py
Resumo
Programa para gerar um trecho de DNA com uma sequência aleatória. A
sequência do DNA será atribuída a uma variável do tipo string (variável dna),
onde cada base será gerada aleatoriamente (variável base), a partir do módulo
random e adicionada à sequência de DNA. O programa tem como entrada o
tamanho da sequência de DNA, a ser gerada aleatoriamente. A sequência
aleatória será mostrada na tela. Para adicionar a base aleatória à sequência de
DNA, podemos usar o operador “+” ou “”.join([dna,base]). O programa calcula as
porcentagens de cada base presente na sequência de DNA gerada e mostra o
resultado na tela.
45
Programa: randomDNA2.py (Trabalho 3)
www.python.org
Nesta versão do programa, temos que criar contadores para cada uma das bases do
DNA. Para contar as bases, temos que inicialmente atribuir zero aos contadores, como
mostrado abaixo:
count_C = 0
count_G = 0
count_A = 0
count_T = 0
Os contadores serão atualizados em cada iteração do loop while. Depois de finalizado
o loop while, serão calculadas as porcentagens, como segue:
if count_bases > 0:
perc_C = 100*count_C/count_bases
perc_G = 100*count_G/count_bases
perc_A = 100*count_A/count_bases
perc_T = 100*count_T/count_bases
Tomamos o cuidado de testar se o contador de bases (count_bases) é maior que zero,
para evitar a divisão por zero. Uma vez pronto o programa, teste para sequências de
diferentes tamanhos, por exemplo para 100, 1000 e 10000. O que você pode dizer
sobre a “aleatoriedade” do módulo random?
46
Programa: randomDNA3.py (Trabalho 3)
www.python.org
Random DNA (versão 3)
Programa: randomDNA3.py
Resumo
Programa para gerar um trecho de DNA com uma sequência aleatória. A
sequência do DNA será atribuída a uma variável do tipo string (variável dna),
onde cada base será gerada aleatoriamente (variável base), a partir do módulo
random e adicionada à sequência de DNA. O programa tem como entradas o
tamanho da sequência de DNA, a ser gerada aleatoriamente, e o nome do
arquivo de saída, onde a sequência será gravada. A sequência aleatória será
mostrada na tela. Para adicionar a base aleatória à sequência de DNA, podemos
usar o operador “+” ou “”.join([dna,base]). O programa calcula as porcentagens
de cada base presente na sequência de DNA gerada e mostra o resultado na
47
tela.
Programa: randomDNA3.py (Trabalho 3)
www.python.org
Agora, a sequência gerada será armazenada num arquivo de saída. Usamos a função
input() para ler o nome do arquivo de saída. A função open() é usada para criar o
arquivo, onde a sequência do DNA será escrita, como indicado abaixo:
# Reads output file name
file_in = input("\nGive the DNA file name => ")
# Opens DNA file
dna_out = open(file_in,"w")
Depois de gerada a sequência do DNA, como nos programas anteriores, podemos
escrevê-la no arquivo de saída, como mostrado abaixo:
# Writes sequence to output file
dna_out.write(dna)
# Closes DNA file
dna_out.close()
48
Programa: readGenome.py (Trabalho 3)
www.python.org
Read Genome
Programa: readGenome.py
Resumo
Programa para a leitura da sequência de bases de um genoma armazenado
num arquivo FASTA. Após a leitura, será mostrada na tela as seguintes
informações: Identificador do FASTA , Numero de Adeninas, Numero de Timinas,
Numero de Citosinas, Numero de Guaninas, Numero de bases nao identificadas,
Numero de Citosinas e Guaninas, Numero de Adeninas e Timinas, Porcentagem
de Citosinas e Guaninas, Porcentagem de Adeninas e Timinas, Porcentagem de
bases nao identificadas, Numero total de bases lidas, Numero de bases nao
identificadas
49
Programa: readGenome.py (Trabalho 3)
www.python.org
Aplique o código no sequência armazenada no arquivo sequence.fasta. Os resultados
esperados são os seguintes:
•Resultado da contagem de bases do arquivo: sequence.fasta
•Identificador do fasta: >gi|57116681|ref|NC_000962.2| Mycobacterium tuberculosis
H37Rv chromosome, complete genome
•Numero de Adeninas: 758565
•Numero de Timinas: 758379
•Numero de Citosinas: 1449985
•Numero de Guaninas: 1444603
•Numero de bases nao identificadas: 0
•Numero de Citosinas e Guaninas: 2894588
•Numero de Adeninas e Timinas: 1516944
•Porcentagem de Citosinas e Guaninas: 65.6141222595688
•Porcentagem de Adeninas e Timinas: 34.3858777404312
•Porcentagem de bases nao identificadas 0
•Numero total de bases lidas 4411532
50
Programa: readPDB2.py (Trabalho 3)
www.python.org
Leitura de arquivos PDB (versão 2)
Programa: readPDB2.py
Resumo
Programa para leitura de arquivo de coordenadas atômicas no formato protein
data bank (PDB). Após a leitura do arquivo PDB, o programa mostra na tela as
linhas referentes à parte não-proteica da estrutura, identificadas com a palavrachave “HETATM”. O usuário digita o nome do arquivo PDB de entrada.
51
Trabalho 3
www.python.org
Lista de programas do trabalho 3
randomDNA1.py
randomDNA2.py
randomDNA3.py
readGenome.py
readPDB2.py
Data da entrega: Até o dia 27 de julho 2016.
52
Referências
www.python.org
-BRESSERT, Eli. SciPy and NumPy. Sebastopol: O’Reilly Media, Inc., 2013. 56 p.
-DAWSON, Michael. Python Programming, for the absolute beginner. 3ed. Boston: Course Technology, 2010. 455 p.
-HETLAND, Magnus Lie. Python Algorithms. Mastering Basic Algorithms in the Python Language. Nova York: Springer
Science+Business Media LLC, 2010. 316 p.
-IDRIS, Ivan. NumPy 1.5. An action-packed guide dor the easy-to-use, high performance, Python based free open source
NumPy mathematical library using real-world examples. Beginner’s Guide. Birmingham: Packt Publishing Ltd., 2011. 212 p.
-KIUSALAAS, Jaan. Numerical Methods in Engineering with Python. 2ed. Nova York: Cambridge University Press, 2010. 422
p.
-LANDAU, Rubin H., PÁEZ, Manuel José, BORDEIANU, Cristian C. A Survey of Computational Physics. Introductory
Computational Physics. Princeton: Princeton University Press, 2008. 658 p.
-LUTZ, Mark. Programming Python. 4ed. Sebastopol: O’Reilly Media, Inc., 2010. 1584 p.
-MODEL, Mitchell L. Bioinformatics Programming Using Python. Sebastopol: O’Reilly Media, Inc., 2011. 1584 p.
-TOSI, Sandro. Matplotlib for Python Developers. Birmingham: Packt Publishing Ltd., 2009. 293 p.
Última atualização: 21 de julho 2016.
53