Aula 09 – Strings, Leitura e Escrita de
Arquivos (continuação)
©2
01
5 D
r. W
alte
r F.
de
Aze
ve
do
Jr.
1
azevedolab.net
2
Exercício de programação: Elabore um programa que leia um arquivo FASTA e gere
um gráfico de barras, onde a altura da barra é proporcional ao número de aminoácidos.
Programa read_fasta_01.pdewww.processing.org
3
A seguir temos o código read_fasta_01.pde. Como o código é longo dividiremos em
partes, explicando o funcionamento de cada trecho do código.
Esta parte inicial traz a definição de variáveis globais, temos um total de três arrays. O
array data_count_aa será usado para armazenar a quantidade de cada aminoácido,
por isso foi definido como um array do tipo inteiro de 20 elementos. O array do tipo
string sequence armazenará a sequência de amino ácidos lida do arquivo FASTA. O
terceiro array, é atribuído à variável my_all_aa, é do tipo string e traz o código de uma
letra para cada um dos 20 aminoácidos naturais.
Programa read_fasta_01.pdewww.processing.org
int[] data_count_aa = new int [20];
String[] sequence;
String[] my_all_aa = {
"A", "R", "N", "D", "C", "E", "Q", "G", "H", "I",
"L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"
}; // Amino acid array
4
Abaixo temos a definição da função setup(), no caso é bem simples, definimos o
tamanho da tela com a função size(400,100) e carregamos o conteúdo do arquivo no
formato FASTA com a função loadStrings(“2a4l.fasta”). Neste caso o arquivo a ser lido
chama-se 2a4l.fasta e tem que necessariamente estar no diretório onde estamos
rodando o código. Como sabemos, a função setup() é executada somente uma vez.
Programa read_fasta_01.pdewww.processing.org
void setup() {
size(400, 100);
// Load FASTA file as an array of Strings
sequence = loadStrings( "2a4l.fasta");
}
5
Agora temos a função draw(). Nela definimos a cor de fundo, com a função
background(). Definimos a cor da linha, com a função stroke() e a cor de
preenchimento do retângulo, com a função fill(). Em seguida chamamos a função
count_amino_acids(), uma função que definimos para leitura do número de amino
ácidos. Esta função será detalhada nos próximos slides. Em seguida temos um loop
for, que desenha um retângulo para cada amino ácido, onde a altura do retângulo é
definida pelo número de aminoácidos. Veja na definição do retângulo, que a altura é
definida por –data_aa[i], que traz o número de aminoácidos, o sinal - é para
invertermos o retângulo, de baixo para cima. O noLoop() encerra a função draw().
Programa read_fasta_01.pdewww.processing.org
void draw() {
background(255);
stroke(0);
fill(255);
count_amino_acids();
//Looping through data_count_aa
for (int i = 0; i < data_count_aa.length; i ++ ) {
rect(i*20, 100, 20, - data_count_aa[i]);
}
noLoop();
}
6
Programa read_fasta_01.pdewww.processing.org
void count_amino_acids() {
int count_aa = 0; // Count for each amin oacid
String sequence_string = ""; // String for sequence
String my_count_out = ""; // String for number of amino acids
// Looping through to get all aa in one string after header
for (int i = 1; i < sequence.length; i++) {
// Get lines after header
sequence_string += sequence[i];
}
// Looping through all 20 amino acids (elements of an array)
for ( int j = 0; j < my_all_aa.length; j++) {
// Looping through sequence_string
for (int k = 0; k < sequence_string.length (); k++) {
String my_aa = str(sequence_string.charAt(k));
// Test if amino acid is in the sequence
if (my_aa.equals(my_all_aa[j]) ) {
count_aa += 1;
}
}
// Builds a string with the numbers of each aa
if (j == 0) {
my_count_out += str(count_aa);
} else {
my_count_out +=","+str(count_aa);
}
count_aa = 0;
}
data_count_aa = int(split(my_count_out, ','));
}
Ao lado temos o código da
função count_amino_acids().
Inicialmente definimos
variáveis locais. Um contador
de aminoácido, é atribuído à
variável do tipo inteiro
count_aa. Temos duas
variáveis do tipo string,
sequence_string e
my_count_out. À variável
sequence_string, é atribuída
a sequência após o
cabeçalho do arquivo FASTA.
À variável my_count_out, é
atribuída uma string com os
valores dos contadores de
cada aminoácido, separados
por vírgulas.
7
Programa read_fasta_01.pdewww.processing.org
O primeiro loop for varre a
string lida do arquivo FASTA,
atribuída à variável
sequence. No loop é omitida
a primeira linha, para evitar o
cabeçalho do arquivo FASTA.
Veja que o primeiro valor
atribuído à variável i é 1,
assim, a primeira linha, que
está na posição zero, não é
adicionada à string
sequence_string.
void count_amino_acids() {
int count_aa = 0; // Count for each amin oacid
String sequence_string = ""; // String for sequence
String my_count_out = ""; // String for number of amino acids
// Looping through to get all aa in one string after header
for (int i = 1; i < sequence.length; i++) {
// Get lines after header
sequence_string += sequence[i];
}
// Looping through all 20 amino acids (elements of an array)
for ( int j = 0; j < my_all_aa.length; j++) {
// Looping through sequence_string
for (int k = 0; k < sequence_string.length (); k++) {
String my_aa = str(sequence_string.charAt(k));
// Test if amino acid is in the sequence
if (my_aa.equals(my_all_aa[j]) ) {
count_aa += 1;
}
}
// Builds a string with the numbers of each aa
if (j == 0) {
my_count_out += str(count_aa);
} else {
my_count_out +=","+str(count_aa);
}
count_aa = 0;
}
data_count_aa = int(split(my_count_out, ','));
}
8
Programa read_fasta_01.pdewww.processing.org
Agora temos dois loops for,
um para varrer o array do
tipo string com o código de
uma letra de cada
aminoácido, variável
my_all_aa. O outro loop for
varre todos elementos
atribuídos ao array
sequence_string. Cada
caractere da string
sequence_string é um
aminoácido, que é convertido
para string, para ser
comparado no if com o
aminoácido contido no array
my_all_aa. Toda vez que a
condição for verdadeira, é
somado um ao contador de
aminoácidos, atribuído à
variável count_aa.
void count_amino_acids() {
int count_aa = 0; // Count for each amin oacid
String sequence_string = ""; // String for sequence
String my_count_out = ""; // String for number of amino acids
// Looping through to get all aa in one string after header
for (int i = 1; i < sequence.length; i++) {
// Get lines after header
sequence_string += sequence[i];
}
// Looping through all 20 amino acids (elements of an array)
for ( int j = 0; j < my_all_aa.length; j++) {
// Looping through sequence_string
for (int k = 0; k < sequence_string.length (); k++) {
String my_aa = str(sequence_string.charAt(k));
// Test if amino acid is in the sequence
if (my_aa.equals(my_all_aa[j]) ) {
count_aa += 1;
}
}
// Builds a string with the numbers of each aa
if (j == 0) {
my_count_out += str(count_aa);
} else {
my_count_out +=","+str(count_aa);
}
count_aa = 0;
}
data_count_aa = int(split(my_count_out, ','));
}
9
Programa read_fasta_01.pdewww.processing.org
Em seguida montamos a
string my_count_out.
Usamos o método split() para
dividirmos os valores dos
contadores de cada resíduo
de aminoácido e atribuir
como elemento do array
data_count_aa.
void count_amino_acids() {
int count_aa = 0; // Count for each amin oacid
String sequence_string = ""; // String for sequence
String my_count_out = ""; // String for number of amino acids
// Looping through to get all aa in one string after header
for (int i = 1; i < sequence.length; i++) {
// Get lines after header
sequence_string += sequence[i];
}
// Looping through all 20 amino acids (elements of an array)
for ( int j = 0; j < my_all_aa.length; j++) {
// Looping through sequence_string
for (int k = 0; k < sequence_string.length (); k++) {
String my_aa = str(sequence_string.charAt(k));
// Test if amino acid is in the sequence
if (my_aa.equals(my_all_aa[j]) ) {
count_aa += 1;
}
}
// Builds a string with the numbers of each aa
if (j == 0) {
my_count_out += str(count_aa);
} else {
my_count_out +=","+str(count_aa);
}
count_aa = 0;
}
data_count_aa = int(split(my_count_out, ','));
}
10
À direita temos o gráfico de barra gerado. À esquerda temos o arquivo FASTA
2a4l.fasta usado para gerar o gráfico.
Programa read_fasta_01.pdewww.processing.org
>2A4L:A|PDBID|CHAIN|SEQUENCE
MENFQKVEKIGEGTYGVVYKARNKLTGEVVALKKIRLDTETEGVPSTAIREISLLKELNHPNIVKLLDVIHTENKLYLVF
EFLHQDLKKFMDASALTGIPLPLIKSYLFQLLQGLAFCHSHRVLHRDLKPQNLLINTEGAIKLADFGLARAFGVPVRTYT
HEVVTLWYRAPEILLGCKYYSTAVDIWSLGCIFAEMVTRRALFPGDSEIDQLFRIFRTLGTPDEVVWPGVTSMPDYKPSF
PKWARQDFSKVVPPLDEDGRSLLSQMLHYDPNKRISAKAALAHPFFQDVTKPVPHLRL
11
Exercício de programação: Elabore um programa que leia um arquivo FASTA e gere
um gráfico de barras, onde a altura da barra é proporcional ao número de aminoácidos
de cada tipo, considerando a classificação mostrada no diagrama de Venn abaixo.
Programa read_fasta_02.pdewww.processing.org
Diagrama de Venn para os 20 aminoácidos mais comuns.
12
Iremos mostrar um programa que lê um arquivo FASTA e gera um gráfico de barras. O
nome do arquivo FASTA é digitado pelo usuário e o gráfico traz a identificação de cada
aminoácido e a quantidade do aminoácido, como mostrado no gráfico abaixo
Programa read_fasta_03.pdewww.processing.org
13
Programa read_fasta_03.pdewww.processing.org
As novidades já começam na
primeira linha, como iremos
escrever na tela, e não com
println(), temos que chamar a
classe fonte, com Pfont f.
Este linha define que f é um
objeto que pertence à classe
fonte, que é capaz de gerar
caracteres na tela.
Depois temos o array com a
quantidade de cada
aminoácido, atribuído à
variável data_count_aa. À
variável norm_data_count_aa
é atribuído um float que é
proporcional ao número de
aminoácidos, dado pela
equação
norm_data_count_aa[l] =
(1/1.2)*(y_length/my_max)*d
ata_count_aa[l];
PFont f;
int[] data_count_aa = new int [20]; // Array with 20 elements
float[] norm_data_count_aa = new float [20]; // Array with 20 ele.
String[] sequence;
String[] my_all_aa = {
"A", "R", "N", "D", "C", "E", "Q", "G", "H", "I",
"L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"
}; // Amino acid array
int screen_length = 800;
int screen_height = 600;
float x_length = 0.8*screen_length;
float y_length = 0.8*screen_height;
int bar_length = 30;
int delta_xy = 80;
int offset = 15;
// Variable to store text currently being typed
String typing = "" ;
// Variable to store saved text when return is hit
String saved = " " ;
String my_fasta;
14
Programa read_fasta_03.pdewww.processing.org
As strings atribuídas às
variáveis sequence e
my_all_aa já foram
detalhadas no código
read_fasta_01.pde. Às
variáveis screen_length e
screen_height serão
atribuídos os valores da
largura e altura da tela,
respectivamente. Às
variáveis do tipo float
x_length e y_length são
atribuídos os comprimentos
dos eixos x e y,
respectivamente.
Escolhemos usar 80 % do
tamanho da tela para os
tamanhos dos eixos.
PFont f;
int[] data_count_aa = new int [20]; // Array with 20 elements
float[] norm_data_count_aa = new float [20]; // Array with 20 ele.
String[] sequence;
String[] my_all_aa = {
"A", "R", "N", "D", "C", "E", "Q", "G", "H", "I",
"L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"
}; // Amino acid array
int screen_length = 800;
int screen_height = 600;
float x_length = 0.8*screen_length;
float y_length = 0.8*screen_height;
int bar_length = 30;
int delta_xy = 80;
int offset = 15;
// Variable to store text currently being typed
String typing = "" ;
// Variable to store saved text when return is hit
String saved = " " ;
String my_fasta;
15
Programa read_fasta_03.pdewww.processing.org
Às variáveis bar_length,
delta_xy e offset são
atribuídos os valores do
comprimento do retângulo,
os deslocamentos do
posicionamento x e y, e um
ajuste para posicionamento
do retângulo e texto na tela.
São escolhas do
programador, para gerar um
gráfico simétrico.
À variável typing é atribuído o
caractere que está sendo
digitado, um por vez.
À variável saved é atribuída a
string digitada, que traz o
nome do arquivo FASTA.
À variável my_fasta é
atribuído o nome do arquivo
FASTA.
PFont f;
int[] data_count_aa = new int [20]; // Array with 20 elements
float[] norm_data_count_aa = new float [20]; // Array with 20 ele.
String[] sequence;
String[] my_all_aa = {
"A", "R", "N", "D", "C", "E", "Q", "G", "H", "I",
"L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"
}; // Amino acid array
int screen_length = 800;
int screen_height = 600;
float x_length = 0.8*screen_length;
float y_length = 0.8*screen_height;
int bar_length = 30;
int delta_xy = 80;
int offset = 15;
// Variable to store text currently being typed
String typing = "" ;
// Variable to store saved text when return is hit
String saved = " " ;
String my_fasta;
16
Programa read_fasta_03.pdewww.processing.org
A função setup() define o
tamanho da tela, chamando
a função size(). Além disso,
chama a função createFont(),
que no caso define a fonte
como sendo arial 16.
A função draw() define a cor
de fundo, com a função
background(), e redefine o
tamanho da fonte, com a
chamada da função
createFont(). A função fill()
define a cor como preta. A
função textFont(f) define que
o texto seguirá a fonte
definida anteriormente.
void setup() {
size(screen_length, screen_height);
f = createFont( "Arial", 16, true);
}
void draw() {
background(255);
f = createFont( "Arial", 24, true);
fill(0);
textFont(f);
textAlign(CENTER);
text( " Type in FASTA file? ", width/2, 30);
}
17
Programa read_fasta_03.pdewww.processing.org
A função textAlign() indica
como o texto será
posicionado. A função text()
define o texto a ser escrito natela, como caso a string "
Type in FASTA file? “.
Os outros dois argumentos
são as coordenadas x e y em
pixels, onde será posicionado
o texto, no código ao lado
temos, width/2 e 30.
void setup() {
size(screen_length, screen_height);
f = createFont( "Arial", 16, true);
}
void draw() {
background(255);
f = createFont( "Arial", 24, true);
fill(0);
textFont(f);
textAlign(CENTER);
text( " Type in FASTA file? ", width/2, 30);
}
18
Programa read_fasta_03.pdewww.processing.org
Ao lado temos a função
gen_bar_plot(), que
basicamente gera o gráfico
de barras, usando a
informação atribuída à
variávelnorm_data_count_aa[i].
Também definimos o texto
com os nomes dos eixos e o
texto com o título do gráfico.
As linhas que envolvem o
gráfico, são definidas pela
função drawLine().
void gen_bar_plot() {
//Looping through data
for (int i = 0; i < data_count_aa.length; i ++ ) {
stroke(0);
fill(0, 0, 255);
strokeWeight(1);
rect(i*bar_length+delta_xy+offset, screen_height - delta_xy,
bar_length-5, - norm_data_count_aa[i]);
line( (i+1)*bar_length+delta_xy-3, screen_height - delta_xy - 6,
(i+1)*bar_length+delta_xy-3, screen_height - delta_xy); // tick marks
drawLine(delta_xy, screen_height - delta_xy, x_length, 0);
drawLine(delta_xy, screen_height - delta_xy - y_length, x_length, 0);
drawLine(delta_xy, screen_height - delta_xy, y_length, 270);
drawLine(delta_xy + x_length, screen_height - delta_xy, y_length,
270);
fill(0);
textFont(f);
textAlign(CENTER);
text(data_count_aa[i], i*bar_length+delta_xy+15+offset,
1.05*(screen_height - delta_xy)- norm_data_count_aa[i]-30);
text(my_all_aa[i], i*bar_length+delta_xy+15+offset,
1.05*(screen_height - delta_xy) );
}
f = createFont( "Arial", 24, true);
fill(255);
noStroke();
rect(width/2-200, 8, 400, 30);
fill(0);
textFont(f);
textAlign(CENTER);
text( " Amino Acid Distribution for "+my_fasta, width/2, 30);
f = createFont( "Arial", 16, true);
textFont(f);
textAlign(CENTER);
text( " Amino acid", width/2, height-30);
textFont(f);
rotate(-1.57);
textAlign(CENTER);
text( "Number of Amino Acids", -height/2, width/2-340);
}
19
Programa read_fasta_03.pdewww.processing.org
A função
count_amino_acids() é
praticamente idêntica à
descrita no código
read_fasta_01.pde. Uma das
diferenças é a variável
total_aa, ao qual é atribuído
o número total de
aminoácidos lidos. Outra
variável nova é a my_max, à
qual é atribuída a maior
quantidade de aminoácidos.
Este valor máximo é usado
para normalizar a altura dos
retângulos, para que não
tenhamos retângulos maiores
que o eixo y (variável
y_length).
void count_amino_acids() {
int count_aa = 0; // Count for each amino acid
String sequence_string = ""; // String for sequence
String my_count_out = ""; // String for number of amino acids
// Looping through sequence to get all sequence in one string
for (int i = 1; i < sequence.length; i++) {
sequence_string += sequence[i];
}
// Get total number of amino acids
int total_aa = int(sequence_string.length() );
// Looping through all 20 amino acids (elements of an array)
for ( int j = 0; j < my_all_aa.length; j++) {
// Looping sequence_string
for (int k = 0; k<sequence_string.length (); k++) {
String my_aa = str(sequence_string.charAt(k));
// Test if amino acid is in the sequence
if (my_aa.equals(my_all_aa[j]) ) {
count_aa += 1;
}
}
if (total_aa > 0) {
data_count_aa[j] = count_aa;
count_aa = 0;
}
}
int my_max = max(data_count_aa);
// Looping through all 20 amino acids (elements of an array)
for ( int l = 0; l < my_all_aa.length; l++) {
norm_data_count_aa[l] =
(1/1.2)*(y_length/my_max)*data_count_aa[l];
}
}
20
Programa read_fasta_03.pdewww.processing.org
A função drawLine() é usada
para desenhar uma linha, a
partir dos argumentos para
as coordenadas do início da
linha cx e cy, e duas
variáveis adicionais, para o
tamanho, len, e o ângulo de
rotação em radianos da linha,
variável angle.
void drawLine(float cx, float cy, float len, float angle) {
strokeWeight(2);
stroke(0);
pushMatrix();
translate(cx, cy);
rotate(radians(angle));
line(0, 0, len, 0);
popMatrix();
}
21
Programa read_fasta_03.pdewww.processing.org
A função keyPressed() foi
vista na aula anterior, ela
basicamente registra o que
foi digitado, para termos os
nome do arquivo FASTA, a
ser atribuído à variável
my_fasta.
void keyPressed() {
// If the return key is pressed, save the String and clear it
if (key == '\n') {
saved = typing;
my_fasta = saved;
sequence = loadStrings(my_fasta);
count_amino_acids(); // Call count_amino_acids()
gen_bar_plot(); // Call gen_bar_plot()
typing = " " ;
noLoop();
// Otherwise, concatenate the String
} else {
typing = typing + key;
}
}
22
Exercício de programação: Modifique o código read_fasta_03.pde, de forma que seja
mostrado sobre as barras do gráfico a porcentagem do aminoácido, ao invés da
quantidade de aminoácidos.
Programa read_fasta_04.pdewww.processing.org
23
Usamos a função loadStrings() para carregamos a informação armazenada num
arquivo que está no nosso computador. Mas a abrangência desta função vai além do
nosso computador. Podemos usá-la para fazer donwload de um arquivo disponível na
web. Por exemplo, arquivos no formato FASTA são armazenados no site do Protein
Data Bank (PDB) (http://www.rcsb.org/pdb/home/home.do), assim, podemos usar a
função loadStrings() para fazer download de arquivos, diretamente do PDB.
O programa donwload_fasta_01.pde faz download do arquivo FASTA 2A4L. Veja a
simplicidade do código.
Função loadStrings()www.processing.org
String my_url = "http://www.rcsb.org/pdb/files/fasta.txt?structureIdList=2a4l" ;
String[] lines = loadStrings(my_url);
String my_fasta = join(lines, " " );
println(my_fasta);
24
A primeira linha do código define o endereço do site, que é atribuído à variável my_url.
A segunda linha usa a função loadStrings(), que baixa a string contida no site indicado.
O método join() junta as linhas, usando como delimitador um espaço. Por último
mostramos a informação lida.
Assim podemos baixar qualquer arquivo FASTA disponível no PDB, basta usarmos
como string atribuída à variável my_urlhttp://www.rcsb.org/pdb/files/fasta.txt?structureIdList=xxxx,
onde xxxx é o código acesso PDB da sequência FASTA.
Função loadStrings()www.processing.org
String my_url = "http://www.rcsb.org/pdb/files/fasta.txt?structureIdList=2a4l" ;
String[] lines = loadStrings(my_url);
String my_fasta = join(lines, " " );
println(my_fasta);
25
Exercício de programação: Modifique o código download_fasta_01.pde, de forma que
o código de acesso PDB da sequência FASTA seja digitado pelo usuário. Além disso, o
programa mostra a sequência numa tela, sem gráficos.
Programa download_fasta_02.pdewww.processing.org
26
Exercício de programação: Modifique o código read_fasta_03.pde, de forma seja
digitado o código de acesso PDB da sequência a ser baixada pelo usuário. O programa
faz o gráfico de barras da sequência baixada.
Programa read_fasta_05.pdewww.processing.org
-MODEL, Mitchell L. Bioinformatics Programming Using Python. Sebastopol: O’Reilly Media, Inc., 2011. 1584 p.
-REAS, Casey & FRY, Bem. Geeting Started with Processing. Sebastopol: O’Reilly Media, Inc., 2010. 194 p.
-SHIFFMAN, Daniel. Learning Processing. A Beginner’s Guide to Programming Images, Animation, and Interaction.
Burlington: Morgan Kaufmann, 2008. 453 p.
-SHIFFMAN, Daniel. The Nature of Code: Simulating Natural Systems with Processing. Mountain View: The Nature of Code,
2012. 498 p.
Última atualização: 16 de novembro de 2015.
27
Referênciaswww.processing.org
Top Related