Embed Size (px)
Citation preview
Aula 08 – Strings, Leitura e Escrita de
Arquivos
©2
01
5 D
r. W
alte
r F.
de
Aze
ve
do
Jr.
1
azevedolab.net
2
Em Python não precisamos definir o tipo da variável, já em Processing temos que
definir os tipos das variáveis. As variáveis do tipo string são definidas pelo uso da
classe String, como indicado no exemplo abaixo.
O código acima chama-se string_class_01.pde.
Como String na verdade é uma classe da linguagem de programação Java, do qual o
Processing é derivado, podemos usar os métodos definidos para a classe String, que
permite que manipulemos dados do tipo string. Veremos alguns métodos relevantes
para bioinformática.
Classe Stringwww.processing.org
String my_string = "You don't know the power of the dark side!";
println(my_string);
3
O método charAt() retorna o caractere que está na posição indicada entre os
parênteses. Lembre-se que começamos a contar no zero. Assim o my_string.charAt(4)
retorna “d”. Veja o código abaixo.
O código acima chama-se string_class_02.pde.
Ao rodarmos o código acima temos impresso na tela o caractere “d”.
Métodos da Classe String: .charAt()www.processing.org
String my_string = "You don't know the power of the dark side!";
println(my_string.charAt(4));
4
O método my_string.length() retorna quantos caracteres estão na string my_string. No
programa string_class_03.pde, mostrado abaixo, temos um loop for que começa no
primeiro caractere da string, posição zero, e varre até o último caractere, obtido com o
método my_string.length().
Ao rodarmos o código acima, temos impresso na tela a sequência de caracteres da
string my_string, um por um é mostrado na tela, inclusive os espaços.
Métodos da Classe String: .length()www.processing.org
String my_string = "You don't know the power of the dark side!";
for (int i = 0; i< my_string.length(); i++) {
println(my_string.charAt(i));
}
5
O método .toUpperCase() converte todos os caracteres de uma string para letras
maiúsculas.
O código acima chama-se string_class_04.pde.
A execução do código acima gera uma sequência de caracteres de letras maiúsculas
na tela.
String my_string = "You don't know the power of the dark side!";
String my_new_string = my_string.toUpperCase();
for (int i = 0; i<my_string.length (); i++) {
println(my_new_string.charAt(i));
}
Métodos da Classe String: .toUpperCase()www.processing.org
6
De forma complementar, temos o método .toLowerCase(), que converte todos os
caracteres de uma string para letras minúsculas.
O código acima chama-se string_class_05.pde.
Sem novidades na execução do código, agora temos os caracteres minúsculos. Veja
que os métodos .toUpperCase() e .toLowerCase() são para serem aplicados à classe
String.
String my_string = "You don't know the power of the dark side!";
String my_new_string = my_string.toLowerCase();
for (int i = 0; i<my_string.length (); i++) {
println(my_new_string.charAt(i));
}
Métodos da Classe String: .toLowerCase()www.processing.org
7
O método .equals() compara duas strings, verificando a igualdade. No código abaixo,
temos dois loops for, que varrem o array de strings my_strings. O objetivo do código é
identificar se há palavras duplicadas no array my_strings.
O código acima chama-se string_class_06.pde.
Veja que o segundo loop for vai até o valor de i, para que não repita a varredura de
forma redundante. Dentro do segundo loop for temos o condicional if, com o método
.equals(), que compara as strings. Execute o código e veja qual string é repetida.
String[] my_strings = {
"You", "don't", "know", "the", "power", "of", "the", "dark",
"side!"
};
for (int i = 0; i < my_strings.length; i++) {
for (int j = 0; j < i; j++) {
if ( my_strings[i].equals(my_strings[j]) ) {
println(my_strings[i]+" is a duplicate");
}
}
}
Métodos da Classe String: .equals()www.processing.org
8
Outro aspecto que podemos destacar do código, é o uso de concatenação de strings,
com o operador “+”, veja que concatenamos (juntamos) as strings e mostramos na tela
o resultado.
String[] my_strings = {
"You", "don't", "know", "the", "power", "of", "the", "dark",
"side!"
};
for (int i = 0; i < my_strings.length; i++) {
for (int j = 0; j < i; j++) {
if ( my_strings[i].equals(my_strings[j]) ) {
println(my_strings[i]+" is a duplicate");
}
}
}
Concatenação de Stringswww.processing.org
9
No código abaixo, usamos o operador “+=“ para ir aumentando uma string, que é
atribuída à variável my_new_string e mostrada na tela. O processo de construir a string
está inserido num loop for, destacado em vermelho. Em cada iteração é adicionada
uma string do array my_strings.
O código acima chama-se string_class_07.pde.
String[] my_strings = {
"You", "don't", "know", "the", "power", "of", "the", "dark",
"side!"
};
String my_new_string = " ";
for (int i = 0; i < my_strings.length; i++) {
my_new_string += " "+my_strings[i];
println(my_new_string);
}
Concatenação de Stringswww.processing.org
10
O método .indexOf() procura uma string colocada entre parênteses e retorna o índice
onde inicia a string sonda de procura. No código abaixo, foi atribuída a string “power” à
variável do tipo string my_probe, que será usada como sonda para busca na string
atribuída à variável my_string.
O código acima chama-se string_class_08.pde.
Veja que o método .indexOf() retorna um número inteiro. Uma questão que podemos
nos colocar, qual número é retornado quando não achamos a string? A resposta é -1.
String my_string = "You don't know the power of the dark side!";
String my_probe = "power";
int my_index = my_string.indexOf(my_probe);
println(my_index);
Métodos da Classe String: .indexOf()www.processing.org
11
No código abaixo introduzimos um condicional if que verifica se a string sonda foi
encontrada, caso seja encontrada é mostrado o índice, caso contrário, é mostrada a
mensagem que a string não foi encontrada.
O código acima chama-se string_class_09.pde. Edite o código e mude a string
atribuída à my_probe para uma que e não tenha sido atribuída à variável my_string.
Tente “lower” por exemplo.
String my_string = "You don't know the power of the dark side!";
String my_probe = "power";
int my_index = my_string.indexOf(my_probe);
if (my_index != -1) {
println(my_index);
} else {
println("String not found");
}
Métodos da Classe String: .indexOf()www.processing.org
12
O método .substring(s,e) gera uma nova string com uma parte da string original. As
variáveis s e indicam o índice do início e fim, respectivamente. O código abaixo fatia a
string original, atribuída à variável my_string, entre os índices 19 e 24, atribui a nova
string à variável my_new_string e mostra o resultado na tela.
O código acima chama-se string_class_10.pde.
Edite o código e mude os índices inicial e final e rode o código.
String my_string = "You don't know the power of the dark side!";
String my_new_string = my_string.substring(19,24);
println(my_new_string);
Métodos da Classe String: .substring()www.processing.org
13
Um aspecto importante para
programas é a entrada de dados
via teclado. Em Python usamos a
função input(). Bem, Processing é
uma linguagem cujo o
desenvolvimento foi voltado para
o ambiente gráfico e, tal função de
entrada de dados, não é tão
simples. Vejamos um programa
que lê dados digitados. Vimos
anteriormente o tratamento de
eventos, como clicar no mouse ou
pressionar uma tecla. O programa
string_class_11.pde usa a função
keyPressed() para pegar
caractere por caractere digitado, e
atribui-lo à variável typing.
Quando pressionamos Enter
(“\n”), finalizamos a entrada de
dados. O conteúdo da variável
saved é mostrado na tela.
Entrada de Dados Via Tecladowww.processing.org
// Variable to store text currently being typed
String typing = " " ;
// Variable to store saved text when return is hit
String saved = " " ;
void setup() {
size(300, 200);
}
void draw() {
background(255);
}
void keyPressed() {
// If the return key is pressed, save the String and clear it
if (key == '\n') {
saved = typing;
println(saved);
typing = " " ;
// Otherwise, concatenate the String
} else {
typing = typing + key;
}
}
14
Ao rodarmos o programa,
digitamos depois de clicar na
janela criada. Depois do Enter,
será mostrada a mensagem
digitada. // Variable to store text currently being typed
String typing = " " ;
// Variable to store saved text when return is hit
String saved = " " ;
void setup() {
size(300, 200);
}
void draw() {
background(255);
}
void keyPressed() {
// If the return key is pressed, save the String and clear it
if (key == '\n') {
saved = typing;
println(saved);
typing = " " ;
// Otherwise, concatenate the String
} else {
typing = typing + key;
}
}
Entrada de Dados Via Tecladowww.processing.org
15
O método split() divide uma string, onde podemos selecionar onde particionarmos a
string. O critério é o delimitador colocado entre aspas “ “, como espaço “ “, ou vírgula
“,”. Vejamos alguns exemplos.
O código acima chama-se string_class_12.pde.
A string atribuída à variável my_string é dividida usando-se o espaço “ “ como
delimitador, ou seja, toda vez que um espaço for encontrado na string, o trecho anterior
é separado.
// Splitting a String based on spaces
String my_string = "You don't know the power of the dark side!" ;
String[] my_new_strings = split(my_string, " " );
for (int i = 0; i < my_new_strings.length; i ++ ) {
println(my_new_strings[i] + " " + i);
}
Métodos da Classe String: split()www.processing.org
16
No código abaixo critério é o delimitador colocado entre aspas “,“ é vírgula, vejamos o
código.
O código acima chama-se string_class_13.pde.
// Splitting a String based on commas
String my_string = "You,don't,know,the,power,of,the,dark,side!" ;
String[] my_new_strings = split(my_string, "," );
for (int i = 0; i < my_new_strings.length; i ++ ) {
println(my_new_strings[i] + " " + i);
}
Métodos da Classe String: split()www.processing.org
17
O código abaixo traz múltiplos delimitadores, a partir do método .splitTokens(). No
código, usamos “,+*!” como delimitadores.
O código acima chama-se string_class_14.pde.
// Splitting a String based on multiple delimiters
String my_string = "You,don't,know,the+power,of,the*dark,side!" ;
String[] my_new_strings = splitTokens(my_string, ",+*!" );
for (int i = 0; i < my_new_strings.length; i ++ ) {
println(my_new_strings[i] + " " + i);
}}
Métodos da Classe String: splitTokens()www.processing.org
18
O código abaixo converte um array de strings para inteiro, onde cada elemento do
array é um número, com o int().
O código acima chama-se string_class_15.pde.
// Calculate sum of a list of numbers in a String
String numbers = " 1,1,2,3,5,8,13,21,34,55 " ;
// Converting the String array to an int array
int[] list = int(split(numbers, "," ));
int sum = 0;
for (int i = 0; i < list.length; i ++ ) {
sum = sum + list[i];
}
println(sum);
Métodos da Classe String: split()www.processing.org
19
O operador str() pode ser aplicado a um array de inteiros e convertê-los a um array de
strings, como no programa numbers_2_strings.pde abaixo.
int[] numbers = {
1, 1, 2, 3, 5, 8, 13, 21, 34, 55
};
for (int i = 0; i< numbers.length; i++) {
println(numbers[i]);
}
// Convert to string
String[] my_strings = str(numbers);
println(my_strings);
Operador str()www.processing.org
20
Para concatenar, além do operador +, podemos usar o método .join(). O código abaixo
usa o método .join() para juntar os elementos de um array. O método .join() faz uso de
delimitador, para indicar o que ficará entre os elementos do array sendo concatenado.
O código acima chama-se string_class_16.pde.
String[] my_strings = {
"You", "don't", "know", "the", "power", "of", "the", "dark",
"side!"
};
String one_string = join(my_strings, " ");
println(one_string);
Métodos da Classe String: join()www.processing.org
21
Para lermos os dados de um arquivo texto, usamos a função loadStrings(). Nesta
função, cada linha de um arquivo texto é transformado em elemento de um array de
strings. Vejamos um exemplo.
O código acima chama-se read_file_01.pde.
No código acima, cada linha contida no arquivo dark.txt é atribuída como elemento do
array lines. O loop for varre o array e mostra na tela. Abaixo temos o arquivo dark.txt, a
ser lido pelo programa acima.
Leitura de Arquivoswww.processing.org
String[] lines = loadStrings("dark.txt" );
println( " there are " + lines.length + " lines ");
for (int i = 0; i < lines.length; i ++ ) {
println(lines[i]);
}
You
don't
know the power
of
the dark
side!
22
O programa abaixo (read_file_02.pde) lê a primeira linha do arquivo data01.csv e gera
um gráfico de barras. Os dados estão separados por vírgulas, arquivo no formato csv
(comma separated values). A primeira linha de código traz a definição de um array
global do tipo inteiro, a variável data.
Leitura de Arquivoswww.processing.org
int[] data;
void setup() {
size(200, 300);
// Load csv file as a String
String[] stuff = loadStrings( "data01.csv");
// Convert string into an array of integers
// using ',' as a delimiter
data = int(split(stuff[0], ','));
}
void draw() {
background(255);
stroke(0);
for (int i = 0; i < data.length; i ++ ) {
fill(data[i]);
rect(i*20, 0, 20, data[i]);
}
noLoop();
}
23
Na função setup() definimos uma tela de 200 x 300 pixels e carregamos o conteúdo do
arquivo data01.csv para um array do tipo string, a variável stuff. Em seguida, por meio
do método .split() dividimos primeira e única linha do arquivo data01.csv, considerando
a vírgula como delimitadora. Este conteúdo é convertido para inteiro, por meio do int()
e atribuído à variável data.
Leitura de Arquivoswww.processing.org
int[] data;
void setup() {
size(200, 300);
// Load csv file as a String
String[] stuff = loadStrings( "data01.csv");
// Convert string into an array of integers
// using ',' as a delimiter
data = int(split(stuff[0], ','));
}
void draw() {
background(255);
stroke(0);
for (int i = 0; i < data.length; i ++ ) {
fill(data[i]);
rect(i*20, 0, 20, data[i]);
}
noLoop();
}
24
Na função draw(), a principal novidade é o loop for, onde varremos entre 0 e o tamanho
do array data (data.length). Neste loop usamos fill() para definir a cor de preenchimento
do retângulo, e geramos retângulos com comprimentos definidos pelos valores lidos do
arquivo csv. No final, usamos o noLoop(), para finalizar a execução do draw().
Leitura de Arquivoswww.processing.org
int[] data;
void setup() {
size(200, 300);
// Load csv file as a String
String[] stuff = loadStrings( "data01.csv");
// Convert string into an array of integers
// using ',' as a delimiter
data = int(split(stuff[0], ','));
}
void draw() {
background(255);
stroke(0);
for (int i = 0; i < data.length; i ++ ) {
fill(data[i]);
rect(i*20, 0, 20, data[i]);
}
noLoop();
}
25
Abaixo à esquerda temos o arquivo data01.csv e à direita o gráfico gerado.
Leitura de Arquivoswww.processing.org
1,1,2,3,5,8,13,21,34,55
26
No exemplo a seguir, modificamos a coordenada y de início do desenho do retângulo
para 300, a parte inferior da janela gráfica, e invertemos o sinal dos elementos do array
data[i], como indicado no código read_file_03.pde abaixo. O arquivo csv de entrada é o
data02.csv.
Leitura de Arquivoswww.processing.org
int[] data;
void setup() {
size(200, 300);
// Load csv file as a String
String[] stuff = loadStrings( "data02.csv");
// Convert string into an array of integers
// using ',' as a delimiter
data = int(split(stuff[0], ','));
}
void draw() {
background(255);
stroke(0);
for (int i = 0; i < data.length; i ++ ) {
fill(data[i]);
rect(i*20, 300, 20,- data[i]);
}
noLoop();
}
27
Abaixo à esquerda temos o arquivo data02.csv e à direita o gráfico gerado.
Leitura de Arquivoswww.processing.org
0,20,40,60,80,100,120,160,180,200
28
Para escrever arquivos, usamos o método saveStrings(). O programa write_file_01.pde
escreve uma sequência de aminoácidos no arquivo my_sequence.fasta. A função
saveData() é chamada quando o mouse é pressionado.
Escrita de Arquivoswww.processing.org
String[] sequence_in = {
"MENFQKVEKIGEGTYGVVYKARNKLTGEVVALKKIRLDTE",
"TEGVPSTAIREISLLKELNHPNIVKLLDVIHTENKLYLVF",
"EFLHQDLKKFMDASALTGIPLPLIKSYLFQLLQGLAFCHS"
};
void setup() {
size(100, 100);
}
void draw() {
background(255);
}
void saveData() {
String[] sequence_out = new String[sequence_in.length];
for (int i = 0; i < sequence_in.length; i ++ ) {
sequence_out[i] = sequence_in[i];
}
saveStrings( "my_sequence.fasta", sequence_out);
}
void mousePressed() {
saveData();
}
29
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
-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: 09 de novembro de 2015.
30
Referênciaswww.processing.org
