Um programa Perl

Programação PERL
Israel Tojal da Silva
[email protected]
Sumário
Introdução – visão geral
Variáveis e Estrutura de Dados
Referências
Expressões Regulares
Funções
Manipulação de Arquivos
Ordenação
Introdução
Perl : Guia de Consulta Rápida
Decio Jr. - Ed. Novatec
Learning Perl (4th ed)
by Randal L. Schwartz, Tom Phoenix, brian d foy. Ed. O'Reilly
Programming Perl (2nd Edition)
by Larry Wall, Tom Christiansen, Randal L. Schwartz,
Stephen Potter Ed. O'Reilly
Advanced Perl Programming (2th ed)
by Simon Cozens. Ed. O'Reilly
Introdução
O que é PERL?
“Perl is a language for getting your job done”
Larry Wall
Introdução
•
PERL ( Practical Extraction and Report Language ) é uma linguagem de programação
criada por Larry Wall em 1987 e que pode ser usada em uma grande variedade de
tarefas :
•
Processamento de texto;
•
Desenvolvimento Web;
•
Administração de sistemas;
•
Acesso a Banco de Dados;
Introdução
•
Características da PERL
•
Linguagem simples;
•
Alto nível;
•
Suporte a várias plataformas (Unix, Mac OS, Windows, ...);
•
Modular e Orientadas a Objetos;
•
Desenvolvimento rápido;
Perl x Bioinformática
http://www.bioperl.org/
Perl x Bioinformática
Perl x Bioinformática
Perl x Bioinformática
Primeiro programa
hello.pl
#!/usr/bin/perl
print “Imprimindo uma mensagem\n”;
$ perl hello.pl
Variáveis
O que são ?
Posições na memória do computador, que são usadas para guardarem valores
E0
E1
E2
E3
E4
$var
E0
E1
E2
E3
E4
6
#!/usr/bin/perl
$var = 6;
...
...
En
En
Sintaxe das variáveis
Tipo Caracter Exemplo É um nome para:
Escalar
$
$dna Um valor individual ( números ou string )
Array
@
@genes Uma lista de valores
Hash
%
%codons Um grupo de valores, indexado por string
Sintaxe das variáveis
Escalares :
$dna = 'ATGCTTATTGTT';
$hits = 5;
$evalue = 5e-120;
$directory = `pwd`;
Sintaxe das variáveis
Array:
@genes = ('BRCA1', 'NAT2' , 'MMP9' , 'MYC');
@cromossomos = (1,3,5,7,9,11,13,15,17,21,'X','Y’);
• Os valores são acessados pelos seus índices:
print “$gene[0]”;
# imprime BRCA1;
print “$cromossomos[3]”; # imprime 7;
• Tamanho do array
print “$#gene”;
# imprime 3;
• Acessando uma fatia do array
print join(“\t”,@cromossomos[3..5]) , “\n”; imprime 7 9 11
Sintaxe das variáveis
Hash:
%codons = (
'ATG'=>'M',
'CTT'=>'L',
'ATT'=>'I',
);
• Acessando o valor de uma chave do hash
print “$codons{'CTT'}\n”;
# imprime: L
•Acessando os valores de todas as chaves do hash
foreach my $key ( keys %codons ){
print “$key\t$codon{$key}\ n”;
}
# imprime:
# CTT
L
# ATT
I
# ATG
M
Controlando avisos e variáveis
➔
Variáveis em Perl são globais por default
use warnings;
use strict;
my $var = 10;
Operadores
Operador
Tipo
+ , - , * , / , % , ** , ++ , -Aritmético
< , <= , == , >= , > , != Comparação Numérica
&& , || , ! , and , or , not
Lógicos
lt , gt , le , ge , eq , ne Comparação de String
= , += , -= ,*= , .=
Atribuição
Operadores
➔Exemplos :
$x = 8;
$y = 2;
$z = $x * $y
$z == 16
$codonA = 'ACG';
$codonB = 'ACG';
$codonA ne $codonB
Instruções if e unless
If : A declaração será executada se a expressão lógica for verdadeira:
my $varA = 3;
my $varB = 5;
if ( $varA < $varB ) {
....
}
unless: A declaração não será executada se a expressão for verdadeira:
my $varA = „A‟;
unless ( $varA eq 'B' ) {
....
}
Instruções Interativas (looping)
@genes = ('BRCA1', 'NAT2' , 'MMP9' , 'MYC');
my $i = 0;
while ( $i <= $#genes ){
while (expr) bloco
print “$i : $genes[$i]\n”;
$i++;
}
foreach my $gene ( @genes ) {
foreach var (lista) bloco
print “$gene\n”;
}
for ( my $i =0 ; $i <= $#genes ; $i++ ) {
for(expr;expr;expr) bloco
print “$i : $genes[$i]\n”;
}
Formas especiais da instrução do
@genes = ('BRCA1', 'NAT2' , 'MMP9' , 'MYC');
do bloco while expr;
do bloco until expr;
my $i = 0;
do{
print “$genes[$i]\n”;
$i++;
}while ( $i <= $#genes );
my $i = 0;
do{
print “$genes[$i]\n”;
$i++;
}until ( $i > $#genes );
Desviando do caminho : next e last
@genes = ('BRCA1', 'NAT2' , 'MMP9' , 'MYC');
my $i = 0;
while ( $i <= $#genes ){
next;
next if ($genes[$i] =~ /A/);
print “$genes[$i]\n”;
$i++;
}
my $i = 0;
while ( $i <= $#genes ){
last;
last if ($genes[$i] eq „MYC‟);
print “$genes[$i]\n”;
$i++;
}
Um programa Perl
#!/usr/bin/perl
use strict;
use warnings;
my $dna;
my @array = ('a','c','g','g','a','g','c','t','c','g');
for (my $i =0; $i <= $#array; $i++) {
$dna .= $array[$i];
print “$dna\n”;
}
perl dna.pl
0a
1 ac
2 acg
3 acgg
4 acgga
5 acggag
6 acggagc
7 acggagct
8 acggagctc
9 acggagctcg
Referências
Referências são ponteiros para tipos de dados previamente definidos :
➔
my $var = 6;
my $ref_var = \$var;
E0
E1
E2
E3
E4
print $ref_var; # imprime E1
$var
$ref_var
E0
E1
E2
E3
E4
...
E1
...
print $$ref_var; # imprime 6
En
6
En
Referências
Referência
Definição
Escalar
$ref_var = \$var;
Array
$ref_array = \@genes;
Hash
$ref_hash = \%hash;
Valor
$$ref_var
$ref_array->[0]
$ref_hash->{'ATG'}
Expressões Regulares
Pesquisa
➔ A procura por grandes quantidades de dados de modo conveniente e eficaz é
realizada através da combinação de padrões
➔
expr =~ [ m ] /padrão/[g][i][m][o][v][x]
my $dna = 'ACGTTCCAACA';
if ( $dna =~ /aac/ ){
...
}
my $dna = 'ACGTTCCAACA';
if ( $dna =~ /aac/i ){
...
}
Expressões Regulares
Substituição
➔ Pesquisa uma string procurando um padrão e, se encontrado, troca aquele
padrão pelo texto de substituição
➔
$var =~ s/padrão/substituto/[e][g][i][m][o][s][x]
my $dna = 'acgtccatc--------------ccccatta';
$dna =~ s/\-//g;
print “$dna”; #imprime acgtccatcccccatta
my $dna = 'TCCTCCATCCG';
$dna =~ s/C/c/;
print “$dna”; #imprime TcCTCCATCCG
Sub-rotinas
A sub-rotina agrupa uma sequência de declarações e funções que
poderão ser reutilizadas pelo programa.
➔
#!/usr/bin/perl
#!/usr/bin/perl
use strict;
use warnings;
use strict;
use warnings;
my ($x,$y,$sum) = (5,9,0);
my ($x,$y,$sum) = (5,9,0);
$sum= &sum ($x,$y);
&sum ($x,$y,\$sum);
print “$x + $x = $sum\n”;
print “$x + $x = $sum\n”;
sub sum{
sub sum{
}
my ($var1,$var2) = @_;
my ($var1,$var2,$rS_sum) = @_;
my $sum = $var1 + $var2;
$$rS_sum = $var1 + $var2;
return $sum;
return;
}
Manipulação de Arquivos
...
open (IN,'arquivo.txt') or die $!;
while (<IN>){
print “$_”;
}
close (IN);
...
...
open (OUT,'>arquivo.txt') or die $!;
print OUT “$var\n”;
close (OUT);
...
Estruturas Avançadas
1
2
1
4
4
3
4
Hash de Array
BRCA1
IKZF2
FOXD3
WFS1
RUFY3
COLQ
NSUN7
#!/usr/bin/perl
use strict;
use warnings;
my %HoA;
my $fileIn = shift or die $!;
my @array;
open(IN,$fileIn) or die $!;
while(<IN>){
chomp;
@array = split(“\t”,$_);
push ( @ { $HoA{$array[0]} }, $array[1] );
1
MMP9
FOXD3
}
close(IN);
2
IKZF2
4
WFS1
3
RUFY3
NSUN7
foreach my $key ( keys %HoA ){
COLQ
print “$key\n\t”;
print join (“ \t”,@{$HoA{$key}} ) , “\n”;
}
Estruturas Avançadas
1
1
2
2
1
4
4
4
3
3
4
BRCA1
BRCA1
IKZF2
IKZF2
FOXD3
WFS1
RUFY3
RUFY3
COLQ
COLQ
NSUN7
NM_11
NM_32
NM_13
NM_14
NM_82
NM_54
NM_88
NM_89
NM_92
NM_93
NM_52
Hash de Hash de Array
#!/usr/bin/perl
use strict;
use warnings;
my %HoHoA;
my $fileIn = shift or die $!;
my @array;
open(IN,$fileIn) or die $!;
while(<IN>){
chomp;
@array = split(“\t”,$_);
push ( @ { $HoHoA{$array[0]}{$array[1]} }, $array[2] );
1
BRCA1
FOXD3
NM_11 NM_32
NM_82
WFS1
RUFY3
NSUN7
NM_54
NM_88 NM_89
NM_52
4
}
close(IN);
foreach my $ka ( keys %HoHoA ){
print “$ka\n”;
foreach my $kb ( keys %{$HoHoA{$ka}} ){
3
COLQ
NM_92 NM_93
IKZF2
NM_13 NM_14
print “$kb\t”;
print join (“ ”,@{$HoHoA{$ka}{$kb}} ) , “\n”;
2
}
}
Ordenação
BRCA1
MMP9
NAT2
NAD1
HOX
TP53
15
10
3
9
44
60
10
2
4
25
87
3
#!/usr/bin/perl
use strict;
use warnings;
my %HoA;
my $fileIn = shift or die $!;
my @array;
open(IN,$fileIn) or die $!;
while(<IN>){
TP53
HOX
BRCA1
MMP9
NAD1
NAT2
60
44
15
10
9
3
3
87
10
2
25
4
chomp;
@array = split(“\t”,$_);
push ( @ { $HoA{$array[0]} }, @array[1..2] );
}
close(IN);
foreach my $key ( sort { $HoA{$b}[0]  $HoA{$a}[0] } keys %HoA ){
print “$key\n”;
print join (“ ”,@{$HoA{$key}} ) , “\n”;
}
Funções PERL
split
• join
• sort
• substr
• length
• push
• pop
• chomp
• sqrt
• glob
• reverse
•
http://geekandpoke.typepad.com/geekandpoke/perl/
Vamos praticar ?
http://xavante.fmrp.usp.br/verao
Faça um script para traduzir uma sequência de nucleotídeos para uma ORF.
Dica :
 perldoc

split

join

reverse

substr

hash

rotina