Introducción a Perl

Introducción

● PERL que significa "Practical Extraction and

Report Language”
● Es un lenguaje de programación creado por
Larry Wall en 1987, surge de otras
herramientas Unix.
 Introducción (Cont.)

● Principalmente sirve para labores de

procesamiento de texto.
● También sirve para la programación de software
de sistemas
● Y últimamente ha encontrado su aplicación en la
escritura de CGI o scripts ejecutados desde
páginas de la WWW.
● PERL es un lenguaje interpretado, aunque
internamente funciona como un compilador. Por eso
se habla de scripts, y no de programas.

● Existen actividades en las cuales PERL, no es la

solución más adecuada, por ejemplo: sistemas de
tiempo real, aplicaciones de memoria compartida de
procesos o aplicaciones extremadamente largas.
 Conociendo su sintaxis
● El típico ejemplo de hola mundo!!!
1: #!/usr/bin/perl
2: print ("Cual es tu nombre?");
3: $nombre=<STDIN>;
4: chop($nombre); # esto es un comentario
5: print "Hola, $nombre!\n";
● OBS.: en PERL no se necesita declarar la
variable se crea y se usa, podríamos haber
escrito un número igual lo mostraría.
 La primera linea ...

● La primera línea de un programa en Perl

contiene el shebang (par de caracteres
que identifica el texto que sigue), que le
indica al sistema operativo dónde
encontrar el intérprete de Perl.

#!/usr/bin/perl
 La instrucción print
● Esta instruccion envia información a la
pantalla o a un archivo. :
#!/usr/local/bin/perl
print "Hola Mundo!\n";
print "Esto se escribe en\ndos lineas.\n";
print "Pero esto",
"Se escribe en una sola linea.\n";
print '¿Porque aqui
no se ejecuta como
cambio de linea?.';
 Secuencias de escape

● Las siguientes secuencias de escape

pueden ser interpretadas en la instrucción
print o en la lectura de archivos:
− \n cambio de linea y retorno de carro
− \t tabulador horizontal
− \v tabulador vertical
− \a bell o beep (campanita)
 Strings

● a) Concatenación(.):
Ej:"Hola"."mundo" # "Holamundo”
"juan"." "."pedro" # "juan pedro”

● b) Operador de repetición de strings(x) :

Ej:"juan"x3 # "juanjuanjuan"
 Tipos de variables
● Escalares( scalars). Cualquier cosa: $escalar
● Arreglos o vectores o listas (arrays): @arreglo
● Tablas asociativas o diccionarios (hashes).
%hash.
(TiposVariables.pl)

● Declaración obligatoria con la directiva “my”

● use strict;
(TiposVariablesStrict.pl)
 Tipos de variables
1- Escalares:
Las variables de escalares empiezan por $
● $a = 5; $b ="xxx";
Las instrucciones terminan en punto y coma.
Un escalar puede tener números, strings u
otras cosas más complicadas como
referencias y descriptores.
● Ej:$a=123; $nombre=“hola2”;
 2- Arreglos
● Las variables tipo arreglos empiezan por @
@a = (95, 7, 'fff' );
print $a[2]; # imprime el tercer elemento: fff
print @a; # imprime: 95 7 fff separados por espacios.
● Los valores de los elementos pueden ser de distinto
tipo.
● El largo de un arreglo ( ej : @a ) queda guardado en
$#a.
Si uno accesa un elemento del arreglo más allá del
fin del arreglo el valor undef es retornado.

Asignar un valor a un elemento más allá del fin del

arreglo, lo que hace es agrandar el arreglo
poniendo undef a los valores intermedios.
 Ejemplo de arreglos
● Ej:@a=(1, "yo",3);
● @c=@a; # copia el arreglo @a en @c
● $d=$a[$#a]; # $d=3
● $b=$a[0]; # asigna 1 a $b
● $a[1]=5; # ahora @a es (1,5,3)
● $a[2]++;
# suma uno al tercer valor de @a siendo ahora (1,5,4)
● $b=$a[7];
# $b es 0 o "" ,dependiendo del contexto
● $a[6]="chao";
 3- Hashes o arreglos
asociativos
● Las variables de tipo hash empiezan por %
● Para crear un elemento de un hash se requiere
una lista de 2 valores
● El primer elemento es la clave y el segundo es el
valor
%a = ( 'x', 5, 'y', 3);
# llena 2 elementos del hash
print $a{'x'}; # imprime: 5
print $a{'y'}; # imprime: 3
● Una forma más clara de ver los pare sería:
%a = {'x'=> 5, 'y'=>3};

● Si es un string simple se puede omitir las

comillas simples.

● Operaciones especiales sobre hash ver:

Más sobre Hash
 Estructuras de control:
condicion
if(condicion){
~~
~~
} elsif{
~~
}else{
~~
~~
~~
}
Operadores de comparacion
● Perl tiene 4 importantes operadores,
para construir condiciones:
Num interpretación String
− < ``less than'' lt
− > ``greater than'' gt
− == ``equal to'' eq
− != ``not equal to'' ne
− <= ``less than or equal to,'' le
− >= ``greater than or equal to.” ge
 Estructuras de control:
ciclo while

while(condicion){

}
 Estructura de control:
ciclo for
● for(<inicio>;<condicion de paro>;<incremento>)
{bloque }
● Ejemplo:
for($i=0;$i<20;$i++) # ejecuta el bloque de código 20 veces
{
print “$i .- Hola”;
}
for.pl
 Estructura de control:
foreach

foreach $elemento (@arreglo)

# ciclo sobre cada uno de los elementos
de un @arreglo
{ # procesa cada $elemento
}
 Diversión con cadenas...
substr
● substr($a,$pos,$num) :
− Regresa una subcadena de la cadena $a,
desde la posición $pos, considerando $num
caracteres. Si $num no es especificado, se
considera el fin de la cadena como fin de la
subcadena. Ejemplo:
$cadena = "Bienvenidos a Perl!\n";
print substr($a, 0, 11);#"Bienvenidos"
print substr($a, 13); # " a Perl!\n“
SearchString.pl
 Trabajando con archivos

● open(FILEHANDLE,"Flatfile.txt"); Abre el
archivo Flatfile.txt para leerlo y lo asocia al
manejador FILEHANDLE.
● open (OVERWRITE, ">overwrite.txt"); Abre
el archivo overwrite.txt para escribir en él
y lo asocia al manejador OVERWRITE.
● open (APPEND, ">>append.txt"); Abre el
archivo append.txt para agregarle cosas y
lo asocia al manejador APPEND.
 Vive o muere...

● Que hacer en caso de que archivo no se

puede abrir?

open (FILEH, “flatfile.txt”) || die

“no se pudo abrir el archivo
flatfile.txt\n”;
Operadores Especiales sobre
ficheros...
● -r -w -x : comprueba si hay permiso
● -e : comprueba si el archivo exite
● -z : comprueba si el archivo tiene tamaño nulo
● -s : devuelve el tamaño del archivo
● -f -d : comprueban si el archivo es un fichero ó
directorio
if(-r 'flatfile.txt')
{
open(FILEHANDLE, “flatfile.txt”)|| die ...
}
 Leyendo a traves del archivo...
open(MIFICH,"fichero.txt")|| die "No puedo encontrar fichero.txt\n";
while(<MIFICH>) {
print $_; # $_ contiene la línea actual
}
close(MIFICH);
open(LOGFILE,”flatfile.txt”)|| die "no puedo abrir flatfile.txt\n";
$title = <LOGFILE>;
print "Report Title: $title";
for $line (<LOGFILE>) {
print $line;
}
close(LOGFILE);
 Escribiendo a traves de
archivos...

open(OUTF,“>fichero.txt")|| die "No puedo encontrar fichero.txt\n";

print OUTF “Nuevo contenido del archivo\n”;
close (OUTF);
 Expresiones regulares

● La consulta mas sencilla: =~

$user_location = "I see thirteen black cats under a ladder.";
if ($user_location =~ /thirteen/)
{ print "Eek, bad luck!\n"; }
 Metacaracteres...
● Un patrón está delimitado por dos barras
inclinadas, /patrón/
● Los símbolos más habituales en expresiones
regulares son:
● /./ # cualquier carácter excepto \n,(wildcard)
● /\s/ # es un espacio en blanco (space)
● /\t/ # es un tabulador
● /\w/ # es un carácter alfanumérico (word),
● /\W/ # no es un carácter alfanumérico (word)
● /\d/ # es un dígito
● /\D/ # no es un dígito
● /\A/ # es el principio de una cadena
● /\Z/ # es el final de una cadena
● /^/ # es el principio de una línea de archivo
● /$/ # es el final de una línea de archivo
 cuantificadores
● Los cuantificadores son:
− + una ó más veces
− ? cero ó una vez
− * cero ó más veces
− {n,m} mínimo y máximo de veces
● Los parentesis se usan:
- /(\d\s\w)/ # para agrupar varios símbolos en un solo
patrón
- /(A|B|C)/ # para definir un patrón formado por varias
alternativas: coincide con 'A', con 'B' o con 'C‘
- Tambien para guardar la “memoria de lo encontrado”
 Ejemplos:
● /ab+c/ encuentra “abc”, “abbc”,”abbbc''
y asi sucesivamente.
● /ab*c/ lo mismo que el anterior, pero
con “ac”.
● /^http:.+html$/. Localiza un URL
● /\d\d\d-\d\d\d\d/ . Un numero telefonico
● /ATG\w+/ La secuencia de un gen?
 Mas ejemplos...

● $string =“ATGTTGCCGCGATCCCGAAA";
$string =~ /(^ATG).+(C{3}).+(A{2,5})/;
@subcadenas = ($1, $2, $3);
● # Ejemplo escrito por Bruno Contreras en Julio de 2005

$RNA = "CAUACUAAGAUCGCGAUAUUAUUAGCGAUAUACGACU";
$stop1 = 'UAA'; $stop2 = 'UGA';
$stop3 = 'UAG';
($total1,$total2,$total3,$total) = (0,0,0,0);
while( $RNA =~ /$stop1/g ) {
$total1++;
}
while( $RNA =~ /$stop2/g ) {
$total2++;
}
while( $RNA =~ /$stop3/g ) {
$total3++;
}
while( $RNA =~ /($stop1|$stop2|$stop3)/g) { $total++;
}
print "$total1|$total2|$total3|$total\n";
 Subprogramas
● declaracion
sub analyze_string {
codigo
}
● Llamado:
&analyze_string;
O
analyze_string;
 Paso de parametros

($val1,$val2) = (8,7);
@arrg3 = (3,4,5);
mi_subrutina($val1,$val2,@arrg3);

sub mi_subrutina {
my($sarg1,$sarg2,@sarg3) = @_;
print "subrutina con parámetros\n";
}
 Ejemplo
$seq1 = “ATGGGCCGTGCTGA...UAA";
$seq2 = “ATGCGCTGTGATGA....UAG";
$ident= calculaIdentidad($seq1,$seq2);

sub calculaIdentidad {
my ($secA,$secB) = @_;
my $id = 0;
my $len =length($secA);
for($pos=0;$pos< $len;$pos++) {
if(substr($secA,$pos,1) eq substr($secB,$pos,1))
{ $id++; }
}
return $id/$len;
} Identidad.pl