bioinformática. uma introdução com a linguagem python · forma de fazermos, não estou afirmando...
TRANSCRIPT
Arrays
©2
01
5 D
r. W
alte
r F.
de
Aze
ve
do
Jr.
1
azevedolab.net
2
Programa: flying_saucer0.pdewww.processing.org
FlyingSaucer mySaucer; // Declares an object
float speed; // speed of flying saucer
float score; // score
void setup() {
size(200, 480);
mySaucer = new FlyingSaucer(100, 0, 20, 20);// Initializes object
speed = 0;
}
void draw() {
background(255);
// Calls method updateY() on object mySaucer
mySaucer.updateY();
// Calls method drawFlyingSaucer() on object mySaucer
mySaucer.drawFlyingSaucer();
// Calls method gameOver() on object mySaucer
mySaucer.gameOver();
// Calls method updateScore() on object mySaucer
mySaucer.myScore();
}
void mousePressed() {
speed = speed * -0.45;
println("Your score", score);
}
As primeiras linhas indicam a
definição do objeto mySaucer da
classe FlyingSaucer() e das
variáveis globais.
Depois temos a função setup(),
onde definimos o tamanho da
tela, inicializamos o objeto
mySaucer e atribuímos valor
inicial a variável global speed.
Na função draw(), definimos a cor
de fundo e chamamos os
métodos sobre o objeto
mySaucer.
Agora temos a função
mousePressed(), que é
executada no evento do mouse
ser pressionado. Assim, ela não
fica incorporada como método e
sim uma função à parte.
3
Na classe FlyingSaucer() as
primeiras linhas indicam as
variáveis. Em seguida definimos
o construtor da classe, onde os
valores iniciais são atribuídos a
algumas variáveis, previamente
definidas no início da classe.
Agora temos variáveis
temporárias na definição do
construtor, que permitem que
usemos esta classe para
construirmos discos com
diferentes posições iniciais na
tela.
class FlyingSaucer {
float x; // x location of flying saucer
float y; // y location of flying saucer
float gravity; // gravity acting on the flying saucer
float r; // intensity for red
float g; // intensity for green
float b; // intensity for blue
float score_antigrav; // Initial cutoff value for antigrav
float maxHeight; // Maximum height
float cockpitX; // Cockpit length
float cockpitY; // Cockpit height
float saucerX; // Saucer length
float saucerY; // Saucer height
FlyingSaucer(float tempX, float tempY, float tempCockpitX, float
tempCockpitY) { // Constructor
cockpitX = tempCockpitX; // Initial value for cockpit
length
cockpitY = tempCockpitY; // Initial value for cockpit
height
saucerX = cockpitX + 100.0; // Initial value for saucer
length
saucerY = cockpitY; // Initial value for saucer
height
x = tempX; // Initial value for x coordinate
y = tempY; // Initial value for y coordinate
gravity = 0.1; // Initial value for gravity
score_antigrav = 2000; // Initial value for
score_antigrav
maxHeight = 480; // Initial value for maxHeight
}
Programa: flying_saucer0.pdewww.processing.org
4
FlyingSaucer(float tempX, float tempY, float tempCockpitX, float tempCockpitY) { // Constructor
cockpitX = tempCockpitX; // Initial value for cockpit length
cockpitY = tempCockpitY; // Initial value for cockpit height
saucerX = cockpitX + 100.0; // Initial value for saucer length
saucerY = cockpitY; // Initial value for saucer height
x = tempX; // Initial value for x coordinate
y = tempY; // Initial value for y coordinate
gravity = 0.1; // Initial value for gravity
score_antigrav = 2000; // Initial value for score_antigrav
maxHeight = 480; // Initial value for maxHeight
}
Olhando-se os detalhes do código do construtor, vemos que temos variáveis para os
valores iniciais das coordenadas x e y (tempX e tempY), bem como para valores iniciais
da largura e altura do cockpit do disco voador, variáveis tempCockpitX e tempCockpitY.
Usando-se este recurso, podemos montar diversos discos, quando inicializamos o
objeto no setup().
Programa: flying_saucer0.pdewww.processing.org
5
Depois temos o métodos vistos
na aula anterior.
Programa: flying_saucer0.pdewww.processing.org
void drawFlyingSaucer() {
// Function to display the flying saucer
noStroke();
ellipseMode(CENTER);
r = random(1, 256);
g = random(1, 256);
b = random(1, 256);
fill(color(r, g, b));
// Cockpit
ellipse(x, y, cockpitX, cockpitY);
fill(175);
// Saucer
ellipse(x, y+10, saucerX, saucerY);
}
void updateY() {
y = y + speed;
speed = speed + gravity;
}
void gameOver() {
if (y > maxHeight) {
println("Your score ", score);
println("Game Over!");
noLoop();
}
}
void myScore() {
if (y < maxHeight) {
score = score + 1;
}
// If score > score_antigrav increase height
if (score > score_antigrav ) {
println("Super antigrav!");
y = y -300;
score_antigrav = 1.05*score_antigrav + 2000;
}
}}
6
Exercício de programação: Modifique o código do programa flying_saucer0.pde, de
forma que tenhamos dois discos voadores. Dica: Declarem dois objetos, como indicado
abaixo.
Exercício de Programação: two_flying_saucers0.pdewww.processing.org
FlyingSaucer mySaucer1; // Declares first object
FlyingSaucer mySaucer2; // Declares second object
.....
7
Arrayswww.processing.org
Poderíamos usar o código two_flying_saucers0.py como protótipo para criamos um
código com uma invasão de discos voadores, por exemplo 100 discos na tela. Uma
forma de fazermos, não estou afirmando que devemos, seria repetirmos a declaração
de objeto 100 vezes. Imaginem como ficaria a chamada dos métodos para os 100
objetos!
FlyingSaucer mySaucer1; // Declares first object
FlyingSaucer mySaucer2; // Declares second object
FlyingSaucer mySaucer3; // Declares third object
.....
8
Arrayswww.processing.org
Uma forma elegante de superarmos este problema, é por meio do uso de arrays. Vimos
em Python que arrays são variáveis indexadas, onde podemos acessar um valor
específico dentro de uma lista de valores. Em Python, usamos arrays da biblioteca
NumPy. Em Processing podemos definir arrays, como indicado abaixo. A variável
myArray é um array de inteiros.
int[] myArray;
Os dois colchetes indicam que é um array
Nome do array
Tipo do array
9
Arrayswww.processing.org
Usamos o operador “new”, para definirmos o tamanho do array, ou seja, quantos
elementos ele contém. Uma vez definido o número de elementos do array, não
podemos mudar este número.
int[] myArray = new int [42];
Tipo do array
Os dois colchetes indicam que é um array
Nome do array
Operador “new” significa que
estamos fazendo um novo arrayTipo do array
Tamanho do array
10
Arrayswww.processing.org
Para inicializamos arrays, podemos atribuir os valores, como indicado abaixo.
int[] myArray = { 1, 5, 8, 9, 4, 5 };
Tipo do array
Os dois colchetes indicam que é um array
Nome do array
Lista com os valores a serem
atribuídos ao array
11
Arrayswww.processing.org
Os valores podem ser atribuídos especificamente para um elemento do array, por
exemplo, queremos atribuir o número 9 ao quarto elemento do array, o código está
indicado abaixo.
myArray[3] = 9;
Nome do array
O número 3 indica o quarto elemento do array.
Começamos a contar o zero, a primeira posição
tem índice zero.
12
Arrayswww.processing.org
Bem, ainda não resolvemos nosso problema inicial da repetição. Se tivermos a seguinte
situação, queremos um array com 1000 elementos do tipo float, com números aleatórios
entre 0 e 10. Poderíamos fazer o seguinte:
float[] values = new float[1000];
values[0] = random(0,10);
values[1] = random(0,10);
values[2] = random(0,10);
values[3] = random(0,10);
values[4] = random(0,10);
values[5] = random(0,10);
......
13
Arrayswww.processing.org
Ou podemos usar um loop for, como indicado abaixo. Usamos values.length para
acessar uma propriedade que todo array tem, ou seja, número de elementos,
values.length retorna o número de elementos do array values, que foi definido na
primeira linha do código.
float[] values = new float[1000];
for (int i = 0; i < values.length; i + + ) {
values[i] = 0;
}
14
Programa: one_car0.pdewww.processing.org
Car myCar1;
void setup() {
size(200, 200);
myCar1 = new Car(color(255, 0, 0), 0, 100, 2);
}
void draw() {
background(255);
myCar1.move();
myCar1.display();
}
class Car {
color c;
float xpos;
float ypos;
float xspeed;
Car(color tempC, float tempXpos, float tempYpos, float
tempXspeed) {
c = tempC;
xpos = tempXpos;
ypos = tempYpos;
xspeed = tempXspeed;
}
void display() {
stroke(0);
fill(c);
rectMode(CENTER);
rect(xpos, ypos, 20, 10);
}
void move() {
xpos = xpos + xspeed;
if (xpos > width) {
xpos = 0;
}
}
}
Ao lado temos o código
one_car0.pde, que gera um
objeto da classe Car. O
construtor da classe Car tem
variáveis para a cor (tempC),
posição (tempX e tempY) e
velocidade (tempSpeed).
Podemos modificar o código
one_car0.pde, para termos um
código que gere dois carros.
15
Programa: two_cars0.pdewww.processing.org
Car myCar1;
Car myCar2;
void setup() {
size(200, 200);
myCar1 = new Car(color(255, 0, 0), 0, 100, 2);
myCar2 = new Car(color(0, 0, 255), 0, 10, 1);
}
void draw() {
background(255);
myCar1.move();
myCar1.display();
myCar2.move();
myCar2.display();
}
class Car {
color c;
float xpos;
float ypos;
float xspeed;
Car(color tempC, float tempXpos, float tempYpos, float
tempXspeed) {
c = tempC;
xpos = tempXpos;
ypos = tempYpos;
xspeed = tempXspeed;
}
void display() {
stroke(0);
fill(c);
rectMode(CENTER);
rect(xpos, ypos, 20, 10);
}
void move() {
xpos = xpos + xspeed;
if (xpos > width) {
xpos = 0;
}}}
Para dois carros, basta
acrescentar a declaração de um
novo objeto, myCar2, a
inicialização do novo objeto, bem
como as respectivas chamadas
de métodos, indicadas em
vermelho.
16
Podemos usar o que aprendemos sobre arrays, para criamos um array de objetos.
Podemos modificar o programa one_car0.pde, para que tenhamos agora 100 carros.Inicialmente declaramos um array com 100 objetos, com Car[] cars = new
Car[100] ; . Em seguida usamos loops for para inicializarmos os objetos e para os
métodos. O código segue no próximo slide.
Arrays de Objetoswww.processing.org
17
Programa: cars100.pdewww.processing.org
Car[] cars = new Car[100] ;
void setup() {
size(200, 200);
smooth();
for (int i = 0; i < cars.length; i++ ) {
cars[i] = new Car(color(i*2), 0, i*2, i/20.0);
}
}
void draw() {
background(255);
for (int i = 0; i < cars.length; i++ ) {
cars[i].move();
cars[i].display();
}
}
class Car {
color c;
float xpos;
float ypos;
float xspeed;
Car(color c_, float xpos_, float ypos_, float xspeed_) {
c = c_;
xpos = xpos_;
ypos = ypos_;
xspeed = xspeed_;
}
void display() {
rectMode(CENTER);
stroke(0);
fill(c);
rect(xpos, ypos, 20, 10);
}
void move() {
xpos = xpos + xspeed;
if (xpos > width) {
xpos = 0;
}}}
Criamos 100 objetos da classe
Car. Depois usamos um loop for
para inicializarmos 100 objetos.
No draw() usamos outro loop for
para os métodos. Vejam, uma
vez definida a classe, podemos
fazer uso de arrays e loops para
expandirmos para qualquer
número de objetos. Uma
facilidade da programação
orientada a objetos.
18
Exercício de programação: Modifique o código do programa flying_saucer0.pde, de
forma que tenhamos 100 discos voadores.
Exercício de Programação: flying_saucers100.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: 05 de outubro de 2015.
19
Referênciaswww.processing.org