PerlBasic SGB Jul2014 PDF

Perl Básico para Bioinformáticos
Del 7 al 11 de julio de 2014

¿Por qué Perl?
¿Por qué Perl?
Variedad de lenguajes reducida
Lenguaje rápido de programar

Lenguaje con funciones avanzadas
Lenguaje de nivel intermedio
Perl Básico para Bioinformáticos 3

Características de Perl
• Curva de aprendizaje baja y larga

• Trata la información de archivos de texto
• Manipula y procesa secuencias largas fácilmente
• Óptimo para escribir programas que controlan otros
programas
• Muy utilizado en laboratorios de biología molecular para
la creación de sitios Web dinámicos
• Un programa puede hacerse rápidamente
• Portable
• Velocidad: bueno pero no óptimo
• Mantenimiento fácil
Perl – Instalación
http://www.activestate.com/activeperl/downloads

Perl – Herramientas para programar
Intérprete de Perl instalado

– http://www.activestate.com/activeperl/downloads
Editor de texto
– Bloc de notas
– Notepad++ (http://notepad-plus-plus.org/)
– Sublime Text (http://www.sublimetext.com/)
Directorio de trabajo en el disco

“La competencia”
Python – Ruby
“Limitaciones” de Perl
Perl puede ser un lenguaje ofuscado
Lema de Perl “Hay más de una manera de

hacerlo”
Dificultades de Perl:
• Expresiones regulares
• Referencias a variables

Perl vs Python y Ruby
Python :
- POO o lenguaje imperativo
- Sintaxis limpia
Ruby:
- Basado en Perl y Python
- POO
- “Cuestión de gustos”
Estrategias de programación
Encuentro un programa
 NAR Database issue (January) y Web Server issue (July)
 PubMed
Links de páginas recursos bioinformática (Biocatalogue
http://www.biocatalogue.org/; http://bioinfouab.uab.cat )
 Buscadores generales
 Bio* proyectos (open bioinformatics projects): bioPerl,
bioJava, bioPython,… (Búsqueda de secuencias por similitud, Búsqueda de motivos
funcionales, Alineamiento múltiple de secuencias, Mapas de restricción, ensamblaje secuencia,
filogenias…)
No hay uno disponible  Escribo el programa (o

modifico unoPerlprevio!?)
Básico para Bioinformáticos 11
 Identificar los inputs requeridos (datos o información que debe

suministrar el usuario)
 Crear pseudocódigo:
 Efectuar un diseño general del programa, incluyendo el método o algoritmo
 Decidir como aparecerá el output (archivo, pantalla, tabla,
gráfico,…)
 Refinar el modelo previo en sus detalles (no olvidar los
comentarios)
 Escribir el programa con un lenguaje de programación, en
nuestro caso con código Perl
Pseudocódigo (planteamiento):
Solicitar los números a sumar
Realizar la suma
Mostrar el resultado
En Perl (sólo los comentarios):

#Solicitar los números a sumar
#Realizar la suma
#Mostrar el resultado
 Editar
 Ejecutar
 Revisar (errores, depuración -debugging)
 Guardar y Backups

¿Cómo funciona un programa?
• Intérprete y programa (script)

Escribimos en el editor y lo guardamos con el nombre primer.pl
#!/usr/bin/perl
print "Mi primer script de Perl\n";
• Ejecutar programas: vamos a DOS (línea de comandos) y escribimos

D:\>perl primer.pl
– O bien
D:\>primer.pl
– Resultado:
Mi primer script de Perl
D:\>_

¿Línea de comandos?

Cambiar de carpeta
cd nueva_carpeta

Cambiar de unidad de disco
C:

• Las instrucciones se ejecutan una tras otra, desde el principio
#!/usr/bin/perl
# ¡Empezamos!
print "Puedo calcular!\n";
#hacer cálculos
$suma = 3 + 4;
#mostrar el resultado
print "La suma de 3 + 4 es ".$suma."\n";
¡Pruébame!
El signo # sirve para introducir comentarios. Las líneas

que empiezan con este símbolo no son interpretadas

Tipos de variables en Perl
Tipos de datos
• Texto (o cadena de caracteres, string)

"cadena numero 1", 'cadena numero 2'
• Números
1, 49, 28.2, -109, 6.04E23
• Caracteres especiales
"Nueva linea\n<aqui y un tab\t<aqui.\n";
Nueva linea
<aqui y un tab <aqui.

Tipos de variables en Perl
• Variables escalares (scalars)
• Matrices (arrays)
Guapa
Enrollado
Lista
• Matrices asociativas (hashes)

Variables escalares
Proporcionan un lugar donde guardar datos

temporalmente
• Características de los nombres de variables:

$a; # sensibilidad a las mayúsculas
$A; # $a es distinto de $A
$nombreDeVariableLargo; # letras, números, líneas_subr

$nombre_de_variable_largo
$variable1 # correcto
$1variable # incorrecto
$l #nombre de variable poco intuitivo

$longitud_cadena # nombre de variable más descriptivo

Variables escalares
• Contenido de las variables:

• Nombre constante en el programa
• Contenido variable a lo largo del programa
• Asignar valores a las variables

$x = 42; # asignamos el valor 42 a $x
$x = 'DNA de cadena sencilla'; # cambiamos el valor de $x
$x = "DNA de cadena doble\n";
• Las comillas dobles interpretan los valores

\ nueva línea
\t tabulador
\\ ”escapamos” la \
Variables escalares
#!/usr/bin/perl
# programa3.pl
# programa que almacena una secuencia de DNA
# almacenamos una secuencia de DNA en una variable

$DNA = "ACGGGGAGGACGGGAAATTACTACGGGCATTAGC";
# Imprimos la secuencia en la pantalla

print $DNA;
# salimos del programa

exit; ¡Pruébame!
C:\>perl programa3.pl
ACGGGGAGGACGGGAAATTACTACGGGCATTAGC
C:\>_

Concatenación de variables escalares
# Primero almacenamos dos secuencias de DNA en dos variables

$DNA1 = "AGGAG";
$DNA2 = "TTCT";
# Podemos concatenar de distintas formas

"AGGAG"."TTCT" o $DNA1.$DNA2 #obtenemos AGGATTCT
"AGGAG".' '."TTCT" o $DNA1.' '.$DNA2 #obtenemos AGGAG TTCT
'AGGAG TTCT'."\n" o "$DNA1 $DNA2\n" #obtenemos AGGAG TTCT\n

Concatenación de variables escalares
#!/usr/bin/perl
# variables.pl
# Programa que concatena fragmentos de DNA
# Primero almacenamos dos secuencias de DNA en dos variables

$DNA1 = "ACGGGGAGGACGGGAAATTACTACGGGCATTAGC";
$DNA2 = "ATAGTGCCGTGCATGCGACGATTCTGGCATACATC";
# Imprimimos en pantalla las dos secuencias separadamente
print $DNA1. "\n";
print $DNA2. "\n\n";
# concatenamos ambas en una tercera variable que se imprime

$DNA3 = $DNA1 . $DNA2 ;
print "Concatenación de los dos fragmentos de DNA: \n\n";
print "$DNA3\n\n";
¡Pruébame!

Operadores
• Aritméticos:
+ suma
- resta
* multiplicación
/ división
** exponencial
() agrupación

Precedencia de operadores
• Ejemplo
$x = 4;
$y = 2;
$z = 3 + $x * $y; # $z es igual a 11
• No es lo mismo:
$z = 3 + $x * $y # $z es igual a 11
$z = (3 + 4) * 2 ¡Pruébame!
# $z es igual a 14

Función length
# Definimos las variables
$DNA1 = "ACGGGGAGGACGGGAAATTACTACGGGCATTAGC";
$DNA2 = "ATAGTGCCGTGCATGCGACGATTCTGGCATACATC";
$DNA3 = $DNA1 . $DNA2 ;
# función length para calcular la longitud de una cadena

$long_DNA1 = length ($DNA1);
# Valores de las nuevas variables

# $long_DNA1 contiene 34

Funciones uc y lc
# Definimos las variables
$DNA = "ACGGGGAGGACGGGAAATTACTACGGGCATTAGC";
# función lc para pasar de mayúsculas a minúsculas

$LC_DNA = lc ($DNA);
# $DNA = "ACGGGGAGGACGGGAAATTACTACGGGCATTAGC";
# $LC_DNA = "acggggaggacgggaaattactacgggcattagc";
# función uc para pasar de minúsculas a mayúsculas

$UC_DNA = uc ($LC_DNA);
# $LC_DNA = "acggggaggacgggaaattactacgggcattagc";
# $UC_DNA = "ACGGGGAGGACGGGAAATTACTACGGGCATTAGC";

Matrices (arrays)
Matrices = arrays = vectores
Variable que almacena múltiples valores

escalares
(Posiciones) Valores
0 A
1 C
2 G
3 T
Matrices (arrays)
# Guardamos las bases del DNA en variables escalares

$base1='A';
$base2='C';
$base3='G';
$base4='T'; # Esta es una mala solución
# Podemos guardar la misma información en una matriz

@bases = ('A','C','G','T'); # Solución más idónea
# porque puedo hacer este tipo de operaciones

@old_bases = @bases; # Copia la matriz entera
No puedes
probarme 

Operaciones con matrices
# operaciones con matrices
@bases = ('A','C','G','T');
# Accedemos a los datos almacenados en la matriz (usamos $)
$tercera_base = $bases[2]; # OJO! Empieza por 0 (cero)
# $tercera_base contiene la G
# cuenta el número de elementos de la matriz
$num_elementosA = @bases; # $num_elementosA es igual a 4
$num_elementosB = $#bases; # OJO! $num_elementosB es igual a 3
# invierte el orden de los elementos de la matriz
No puedes
@bases_invertida = reverse(@bases);
probarme 
# @bases_invertida contiene 'T','G','C','A'
# ordena los elementos de una matriz por orden alfabético
@bases_ordenadas = sort(@bases_invertida);
# @bases_ordenadas contiene 'A' 'C' 'G' 'T'

Funciones con matrices
...
# Elimina, y retorna, el último elemento

$ultima_base = pop(@bases);
# $ultima_base contiene 'T' y @bases ‘A','C','G'
# añade T al final = $bases[3]

push(@bases,'T'); # o:
push(@bases,$ultima_base);
No puedes
# Elimina, y retorna, el primer elemento probarme 
$primera = shift(@bases);
# $primera contiene 'A' y @bases 'C','G','T'
# añade un elemento al principio = $bases[0]

unshift(@bases,$primera);

Función split
• Transformar cadenas en matrices

# split.pl - operaciones con arrays
$linea="192a,UAB,GGGTTCC,CCTTAGG";
@campos = split(',',$linea);
# ESTRUCTURA: @matriz = split('SEPARADOR',$escalar);

# @campos contiene '192a' 'UAB' 'GGGTTCC' y 'CCTTAGG'
No puedes
probarme 

Función join
• Transformar matrices en cadenas

# join.pl - operaciones con arrays
@campos = ("192a","UAB","GGGTTCC","CCTTAGG");
$linea_tab = join("\t",@campos);
# ESTRUCTURA: $escalar = join("SEPARADOR",@matriz);

# $linea_tab contiene "192a UAB GGGTTCC CCTTAGG"
No puedes
probarme 

split/join
• Otras operaciones con join y split

# splitjoin.pl - operaciones con arrays
$linea = "192a,UAB,GGGTTCC,CCTTAGG";
($clone,$lab,$l_oligo,$r_oligo) = split (',',$linea);
# $clone contiene '192a'

# $lab contiene 'UAB'
# $l_oligo contiene 'GGGTTCC'
# $r_oligo contiene 'CCTTAGG'
$linea2 = join ("\t", $clone, $l_oligo, $r_oligo);

# $linea2 contiene '192a GGGTTCC CCTTAGG';

Matrices asociativas (hashes)
• Son similares a las matrices pero:

• Sus elementos tienen un ‘nombre’ (clave o Key)
• Su prefijo es el símbolo %
%hash
• Usa {} para acceder a sus valores $hash{'clave'}
Claves Valores
A adenina
C citosina
G guanina
T timina

Matrices asociativas (hashes)
# hash.pl - Declarar un hash

%purinas = ( 'A' => 'Adenina',
'G' => 'Guanina');
# alternativamente
%pirimidinas = ();
$pirimidinas{'C'}='Citosina';
$pirimidinas{'T'}='Timina'; No puedes
probarme 

Matrices asociativas (keys y values)
# (…) hashes-keys.pl
# Recuperar las claves o los valores en una matriz
%bases = ('A' => 'Adenina',
'C' => 'Citosina',
'G' => 'Guanina');
$bases{'T'} = 'Timina';
No puedes
probarme 
@claves = keys(%bases);
@datos = values(%bases);
# @claves contiene 'C' 'A' 'G' 'T'

# @datos contiene 'Citosina' 'Adenina' 'Guanina' 'Timina'
# el orden es aleatorio pero se conserva entre keys y values

Entrada y salida del programa
Entrada y salida del programa

Mostrar los datos
Función print
#!/usr/bin/perl
# ES.pl
print "Hola mundo!\nPuedo multiplicar: ";
print 6*2;
print "\n";
print "También puedo multiplicar así: ".(6*2)."\n";
C:\> perl ES.pl ¡Pruébame!

Hola mundo!
Puedo multiplicar: 12
También puedo multiplicar así: 12
C:\>_

Mostrar los datos
#!/usr/bin/perl
# ES.pl
$gen = "Adh";
print "podemos imprimir así: ".$gen."\n";
print "y también así: $gen\n";
¡Pruébame!
C:\> perl ES.pl
podemos imprimir así: Adh
y también así: Adh
C:\>_
Imagina más posibilidades de concatenar y

pruébalas
Interpretar los datos
#!/usr/bin/perl
# ES.pl '…'
$gen = " Adh";
print 'Los datos no se pueden interpretar: $gen\n';
C:\>perl ES.pl
Los datos no se pueden interpretar: $gen\n
C:\>_
#!/usr/bin/perl
# ES.pl
$gen = "Adh";
"…"
print "Los datos sí se pueden interpretar: $gen\n";
C:\>perl ES.pl
Los datos sí se pueden interpretar: Adh
¡Pruébame!
C:\>_
Variables de entrada
Entorno: @ARGV
#!/usr/bin/perl
# entorno.pl – Llamada entorno.pl Hola
print $ARGV[0]; # este el primer argumento
C:\>perl entorno.pl argumento1

argumento1
C:\>_
¡Pruébame!

Variables de entrada
Entorno: @ARGV
# (…) entorno.pl
print "1: $ARGV[0] – 2: $ARGV[1] – 3: $ARGV[2]\n";
print "nombre del programa: $0"; # nombre del script
C:\>perl entorno.pl podemos pasar multiples valores

1: podemos – 2: pasar – 3: multiples
nombre del programa: entorno.pl
C:\>_ ¡Pruébame!
Cambia el texto

Entrada desde teclado
Entrada desde teclado:

#!/usr/bin/perl
# ES.pl
print "entra tu edad\n";
$edad = <STDIN>;
print "tu edad en años de perro es ". ($edad/7). "\n";
C:\>perl ES.pl ¡Pruébame!

entra tu edad
Pon un número
21
tu edad en años de perro es 3
C:\>_

Ejercicio
1. Crea un programa que pida el nombre al

usuario y a continuación lo salude.

Entrada desde teclado
#!/usr/bin/perl
# chomp.pl
print "Entra tu nombre: ";
$nombre = <>; # <> equivale a <STDIN>
print "Hola $nombre!, encantado de conocerte.\n";
C:\>perl chomp.pl
Entra tu nombre: Raquel
Hola Raquel ¿Solución?
!, encantado de conocerte. Pon tu nombre
C:\>_

Entrada desde teclado: función chomp
#!/usr/bin/perl
# chomp.pl
print "Entra tu nombre: ";
$nombre = <>; # <> equivale a <STDIN>
chomp($nombre);
print "Hola $nombre!, encantado de conocerte.\n";
C:\>perl chomp.pl
Entra tu nombre: Raquel ¡Solución!
Hola Raquel!, encantado de conocerte. Pon tu nombre
C:\>_

Mostrar los datos con formato
Función printf
#!/usr/bin/perl
# printf.pl
$edad = <STDIN>;
print "tu edad en años de perro es ",$edad/7,"\n";
C:\> perl printf.pl

entra tu edad
25
tu edad en años de perro es 3.57142857142857
C:\>_

Función printf
#!/usr/bin/perl
# printf.pl
$edad = <STDIN>;
printf "tu edad en años de perro es %0.2f \n", $edad/7;
C:\> perl printf.pl ¡Pruébame!

entra tu edad Pon tu edad
25
tu edad en años de perro es 3.57
C:\>_

Función printf
%s -> cadena (string)
%d -> dígito (decimal)
%f -> dígito con decimales (float)
#!/usr/bin/perl
# printf.pl
$valor = 1;
printf "realizamos más de %d conversión en %3d %s\n",
$valor, $valor, 'línea'; # mismo número de conversiones!
C:\>perl printf.pl
realizamos más de 1 conversión en 1 línea
C:\>_

Lectura y escritura de ficheros
Ficheros
Para leer o escribir datos con ficheros, es

necesario el uso de filehandles
• Filehandle → nombre de la conexión
open(FICHERO,'datos.txt');
• FICHERO: filehandle
• ‘datos.txt’: nombre del fichero
open (FICH_DATOS,'c:\archivosperl\test\test01.dat');

Ficheros - ruta
open(FICHERO,'datos.txt');
# o
open(FICHERO,'c:/carpetas/datos.txt');
# o
open(FICHERO,'c:\carpetas\datos.txt');
# o
open(FICHERO,"c:/carpetas/datos.txt");
# o
open(FICHERO,"c:\\carpetas\\datos.txt");
# o
open(FICHERO,"../carpetasuperior/datos.txt");
Lectura de ficheros
#!/usr/bin/perl
# FileInArray.pl
open (MIFICHERO, "datos.txt");
@contenido = <MIFICHERO>;
# Cargamos el contenido del fichero en una matriz
close (MIFICHERO);
# (...)
chomp (@contenido); ¡Pruébame!
print "linea 1: $contenido[0]\n"; Imprime unas
print "linea 2: $contenido[1]\n"; cuantas líneas
# ...
Haz distintas pruebas y cambia la ruta del archivo

Escritura en ficheros
#!/usr/bin/perl
# EscrituraFicheros.pl
open (FICHERO, '>data.txt'); # Crear para escribir

# o
open (FICHERO, '>>data.txt'); # Añadir al final
print FICHERO "Hola mundo!\n";
close (FICHERO);

#!/usr/bin/perl
print FICHERO "Linea 1\n";
close (FICHERO);
Linea 1
#!/usr/bin/perl
open (FICHERO, '>>data.txt'); # Añade al final
close (FICHERO);
Linea 1
Linea 2
#!/usr/bin/perl
close (FICHERO);
Linea 3

Función die
Salvaguarda por si el fichero no está disponible
#!/usr/bin/perl
# FileOrDie.pl
open (FICHERO, "EsteFicheroNoExiste.xxx") or
die "No encuentro el fichero";
@lineas = <FICHERO>;
close FICHERO;
print "Hay ".@lineas." líneas";
¡Pruébame!
(sin y con die)
C:\>perl FileOrDie.pl
No encuentro el fichero at FileOrDie.pl line 4.
C:\>_

Control de flujo:
Instrucciones condicionales
Operadores
Bucles
Condiciones

Decisiones condicionales : if
#!/usr/bin/perl
# if1.pl
print "dime tu edad: "; ¡Pruébame!
$edad = <STDIN>; Con un número
if ($edad <=0) { negativo
print "error al leer la edad. \n";
exit;
}
print "tu edad es $edad\n";
C:\>perl if1.pl
dime tu edad: -20
error al leer la edad. ¡Pruébame!
Pon texto
C:\>_ Pon tu edad

#!/usr/bin/perl
# if1.pl
print "dime tu edad: ";
$edad = <STDIN>;
if ($edad <=0) {
exit;
}
C:\>perl if1.pl
dime tu edad: hola
error al leer la edad. ¡Pruébame!
Con texto
C:\>_

#!/usr/bin/perl
# if1.pl
print "dime tu edad: ";
$edad = <STDIN>;
if ($edad <=0) {
exit;
}
C:\>perl if1.pl
dime tu edad: 30
tu edad es 30 ¡Pruébame!
Con la edad
C:\>_

Comparadores numéricos
Comparadores numéricos:
== igualdad $a == $b
!= desigualdad
< menor
> mayor
<= menor o igual
>= mayor o igual

Comparadores para cadenas
Comparadores para cadenas:

eq igualdad $a eq $b
ne desigualdad
lt menor (less than)
gt mayor (greather than)
le menor o igual (less or equal to)
ge mayor o igual (greather or equal to)
=~ pattern matching $a =~ /gattc/
El símbolo ~ se consigue pulsando AltGr+4

Orden para cadenas
Atención al orden al comparar cadenas:
0, 1, 2 ,3, …, 9, A, …, Z, a, …, z
if ("TGCA" lt "acgt") devolverá CIERTO!!!

if – else
#!/usr/bin/perl
# if_else.pl
print "entra tu edad: ";
$edad = <>;
if ($edad <= 0){
print "error en la edad introducida.\n";
}
else {
}
C:\>perl if_else.pl
entra tu edad: -5
error en la edad introducida. ¡Pruébame!
Pon un número
negativo
C:\>_
if – else
#!/usr/bin/perl
# if_else.pl
$edad = <>;
if ($edad <= 0){
}
else {
}
C:\>perl if_else.pl
entra tu edad: 180
tu edad es 180 ¡Pruébame!
Pon un número
grande
C:\>_
if – else
#!/usr/bin/perl
# if_else.pl
$edad = <>;
if ( ($edad <= 0) or ($edad > 100) ) {
}
else {
}
C:\>perl if_else.pl
entra tu edad: 180
error en la edad introducida. ¡Pruébame!
Pon un número
grande
C:\>_
if – elsif – else
#!/usr/bin/perl
# if_elsif.pl
print "Entra tu edad: ";
$edad = <>;
if ( $edad <= 0 ) {
print "eres muy joven para usar un teclado";
}
elsif ( $edad > 100 ) {
print "¿estás seguro? ¡Qué bien te conservas!";
}
else {
} ¡Pruébame!
Cambia el valor

if: comparaciones
#!/usr/bin/perl
# if2.pl
$gen1 = 'X';
$gen2 = 'x';
if ( $gen1 eq $gen2 ) {
print "Son el mismo gen\n";
}
elsif ( $gen1 ne $gen2 ) {
print "Son distintos genes\n";
}
C:\>perl if2.pl
Son distintos genes
¡Pruébame!
C:\>_

Función exists
#!/usr/bin/perl
# exists.pl
%bases = ( 'A' => 'Adenina',
'C' => 'Citosina',
'G' => 'Guanina',
'T' => 'Timina');
$nucleotido='A';
if (exists($bases{$nucleotido})) {
print "$nucleotido es $bases{$nucleotido}";
}
else {
print "$nucleotido no es una base";
}
C:\>perl exists.pl ¡Pruébame!
A es Adenina
C:\>_
Función exists
#!/usr/bin/perl
# exists.pl
%bases = ( 'A' => 'Adenina',
'C' => 'Citosina',
'G' => 'Guanina',
'T' => 'Timina');
$nucleotido='Z';
if (exists($bases{$nucleotido})){
print "$nucleotido es $bases{$nucleotido}";
}
else {
print "$nucleotido no es una base";
}
C:\>perl exists.pl ¡Pruébame!
Z no es una base
C:\>_
Bucles

Bucle while
#!/usr/bin/perl
# while.pl
$cont = 1;
while ($cont <= 5) {
print "contador $cont\n";
$cont = $cont + 1;
}
C:\>perl while.pl
contador 1
contador 2
contador 3
contador 4
contador 5
¡Pruébame!
C:\>_
Bucle until
#!/usr/bin/perl
# until.pl
$cont = 1;
until ($cont > 5) {
print "contador $cont\n";
$cont = $cont + 1;
}
C:\>perl until.pl
contador 1
contador 2
contador 3
contador 4
contador 5 ¡Pruébame!
C:\>_
Bucle while y ficheros
#!/usr/bin/perl
# Whilefile.pl
$cont = 0;
open(DATOS, "datos.txt");
while (<DATOS>) {
$cont++;
}
close(DATOS);
print $cont."\n";
C:>\perl Whilefile.pl
4
¡Pruébame!
C:\>_

>secuencia1
ATAGCAGTCGTACCGTAGCCAGCGATCAGA
TGCGATCGTCTTCGACCAAGCTGACCTGA
#!/usr/bin/perl
# Whilefile.pl
open(ARCHIVO, "secuencias/seq.fa");
$cont=0;
while (<ARCHIVO>) {
$cont++;
print "Línea número $cont: $_ FIN\n";
}
close(ARCHIVO);
¡Pruébame!

#!/usr/bin/perl
# Whilefile.pl
$cont=0;
while (<ARCHIVO>) {
$cont++;
print "Línea número $cont: $_ FIN\n";
}
close(ARCHIVO);
Línea número 1: >secuencia1
FIN
Línea número 2: ATAGCAGTCGTACCGTAGCCAGCGATCAGA
FIN
Línea número 3: TGCGATCGTCTTCGACCAAGCTGACCTGAA
FIN
C:\>_
#!/usr/bin/perl
# Whilefile.pl
$cont=0;
while (<ARCHIVO>) {
$cont++;
chomp($_);
print "Línea número $cont: $_ FIN\n"; ¡Pruébame!
}
close(ARCHIVO);
Línea número 1: >secuencia1 FIN
Línea número 2: ATAGCAGTCGTACCGTAGCCAGCGATCAGA FIN
Línea número 3: TGCGATCGTCTTCGACCAAGCTGACCTGAA FIN
C:\>_
Bucle while y entrada desde teclado
#!/usr/bin/perl
# defined.pl
print "escribe algo: ";

while (defined ($linea = <>)) {
chomp ($linea);
print "has escrito '$linea'\n\n";
}
Paramos el programa con Control+C

¡Pruébame!

Bucle while y entrada desde teclado
#!/usr/bin/perl
# last.pl
print "escribe algo: (\"fin\" para acabar) \n";
while (defined ($linea = <>)) {
chomp $linea;
if ($linea eq 'fin') {
last;
}
print "has escrito '$linea'\n\n";
}
print "bye,bye!\n";
¡Pruébame!
last sale del bucle inmediatamente

Abreviando en Perl
# (…) versión abreviada

print "escribe algo. ('fin' para acabar) \n";
while (<>) { # while (defined($linea=<STDIN>))
chomp; # chomp($linea)
last if ($_ eq 'fin'); # if ($linea eq ‘fin’)
print "has escrito '$_'\n\n"; # {last;}
}
print "bye,bye!\n";
Valores por defecto: se utilizan, pero dificultan

la legibilidad y especialmente el mantenimiento
o la depuración
Abreviando en Perl

while y hashes
#!/usr/bin/perl
# whilehash.pl
%bases = ( 'A' => 'Adenina', 'C' => 'Citosina', Ya puedes
'G' => 'Guanina', 'T' => 'Timina'); probarme 
while ( ($key,$value) = each(%bases)){
print "$key es $value\n";
}
C:\>perl whilehash.pl
A es Adenina
T es Timina
C es Citosina
G es Guanina
¡Pruébame!
C:\>_

Bucle foreach
#!/usr/bin/perl
# foreach.pl Ya puedes
@bases = ('A','T','C','G'); probarme 
foreach $elemento(@bases) {
print "Una de las bases del DNA: $elemento\n";
}
C:\>perl foreach.pl
Una de las bases del DNA: A
Una de las bases del DNA: T
Una de las bases del DNA: C
Una de las bases del DNA: G
¡Pruébame!
C:\>_

Bucle foreach
#!/usr/bin/perl
# foreach.pl
%bases = ( 'A' => 'Adenina', 'C' => 'Citosina', Ya puedes
'G' => 'Guanina', 'T' => 'Timina'); probarme 
@bases=keys(%bases);
foreach $elemento (@bases) {
print "$elemento es $bases{$elemento}\n";
}
C:\>perl foreach.pl
A es Adenina
T es Timina
C es Citosina
G es Guanina ¡Pruébame!
C:\>_

Bucle foreach
#!/usr/bin/perl
# foreach.pl
%bases = ( 'A' => 'Adenina', 'C' => 'Citosina',
'G' => 'Guanina', 'T' => 'Timina');
@bases=keys(%bases);
@bases=sort(@bases); # ordenamos la matriz
foreach $elemento (@bases) {
print "$elemento es $bases{$elemento}\n";
}
C:\>perl foreach.pl
A es Adenina
C es Citosina
G es Guanina
T es Timina ¡Pruébame!
C:\>_
Bucle for
#!/usr/bin/perl
# for.pl
for ($i=0; $i<=5; $i++) {
print "Contador: $i\n";
}
C:\>perl for.pl
Contador: 0
Contador: 1
Contador: 2
Contador: 3
Contador: 4
Contador: 5
¡Pruébame!
C:\>_

Bucle for
#!/usr/bin/perl
# for.pl
for ($i=0; $i<=5; $i++) {
next if ($i==0);
print "Contador: $i\n";
}
C:\>perl for.pl
Contador: 1
Contador: 2
Contador: 3
Contador: 4
Contador: 5
¡Pruébame!
C:\>_

Bucle for
#!/usr/bin/perl
# for_codones.pl
$secuencia = 'ATGATCGTCAGTA'; # ATG ATC GTC AGT A
$num_codones=0;
for ($i=1; $i<=length($secuencia); $i+=3) {
$num_codones++;
}
print "Número de codones: $num_codones";
C:\>perl for_codones.pl
Número de codones: 5
C:\>_
¡Pruébame!

Bucle for
#!/usr/bin/perl
# for_codones2.pl
$secuencia = 'ATGATCGTCAGTA'; # ATG ATC GTC AGT A
$num_codones=0;
for ($i=1; $i<=length($secuencia); $i+=3) {
last if ((length($secuencia)-$i) < 2);
$num_codones++;
}
print "Número de codones: $num_codones";
C:\>perl for_codones2.pl
Número de codones: 4
C:\>_ ¡Pruébame!

Bucle for
#!/usr/bin/perl
# for_matriz.pl Ya puedes
@bases= ('A','T','G','C'); probarme 
for ($i=0; $i<=$#bases; $i++) {
print "Una base del DNA es $bases[$i]\n";
}
C:\>perl for_matriz.pl
Una base del DNA es A
Una base del DNA es T
Una base del DNA es G
Una base del DNA es C
¡Pruébame!
C:\>_

Expresiones regulares:
Búsqueda de patrones (pattern matching)

Metacaracteres
Extracción y substitución de patrones
$DNA =~ /ATG/;
=~: inicio de búsqueda de patrones

//: delimitadores de la búsqueda

Sustituir cadenas
Operador “s”:
$variable =~ s/A/B/g;
s: operador sustituir
A: patrón a sustituir
B: texto que reemplazará el patrón
g: modificador (en este caso global)

Búsqueda de patrones: modificadores
$DNA =~ /ATG/modificadores;
Modificadores:
g → global
i → insensible a mayúsculas
s →el ‘.’ también incluye ‘\n’

Ejercicios
1. A partir de una secuencia de DNA ya almacenada,

crea la correspondiente secuencia de RNA

crea su secuencia complementaria

pásala a minúsculas sin utilizar la función lc
¡A practicar!

Sustituir cadenas
#!/usr/bin/perl
# substitute.pl
$dna = 'ACGTACGGTACTAGCAT';
$rna = $dna;
$rna =~s/T/U/i;
print "$dna\n$rna";
C:\>perl substitute.pl
ACGTACGGTACTAGCAT
ACGUACGGTACTAGCAT
C:\>_
¿Solución?

Sustituir cadenas
#!/usr/bin/perl
# substitute.pl
$rna = $dna;
$rna =~s/T/U/ig;
print "$dna\n$rna";
ACGTACGGTACTAGCAT
ACGUACGGUACUAGCAU
C:\>_
¡Solución!

Sustituir cadenas
#!/usr/bin/perl
# substitute.pl
$complementaria = $dna;
$complementaria =~s/A/T/ig;
$complementaria =~s/T/A/ig;
$complementaria =~s/C/G/ig;
$complementaria =~s/G/C/ig;
print "$dna\n$complementaria";
ACGTACGGTACTAGCAT
ACCAACCCAACAACCAA
C:\>_
¿Solución?

Traducir cadenas
Operador “tr”:
$variable =~ tr/abcd/1234/;
tr: operador traducir

a→1
b→2
c→3
d→4

Traducir cadenas
#!/usr/bin/perl
# substitute.pl
$complementaria = $dna;
$complementaria =~tr/ATCG/TAGC/;
print "$dna\n$complementaria";
ACGTACGGTACTAGCAT
TGCATGCCATGATCGTA
C:\>_
¡Solución!

Traducir cadenas
#!/usr/bin/perl
# substitute.pl
$dna2 = $dna;
$dna2 =~tr/ATCG/atcg/;
print "$dna\n$dna2";
ACGTACGGTACTAGCAT
acgtacggtactagcat
C:\>_
¡Solución!

#!/usr/bin/perl
# patterns1.pl
$dna = 'GAGCTGGACATGATTCCACGACA';
if ($dna =~/GATTC/) {
print "EcoRI encontrado!";
}
C:\>perl patterns1.pl
EcoRI encontrado!
C:\>_
¡Pruébame!

#!/usr/bin/perl
# patterns1.pl
if ($dna =~/GATTC/) {
print "EcoRI encontrado!\n";
}
if ($dna =~/GGG[GATC]CCC/) { # GGG (G ó A ó T ó C) y CCC

print "segundo motivo encontrado\n";
}
¡Pruébame!
(el 2º patrón)

#!/usr/bin/perl
# patterns1.pl
# 3 if para buscar EcoR o Hind III
if (($dna =~/GAATTC/) or ($dna =~/AAGCTT/)) {
#EcoR ó Hind III
# podemos buscar ambas con 'and'
print "tercer motivo encontrado!\n";
}
if (($dna =~/GAATTC/) || ($dna =~/AAGCTT/)) {
#EcoR ó Hind III
# usaremos && para indicar Y ¡Pruébame!
print "tercer motivo encontrado!\n"; ¿Hay diferencias?
}
if ($dna =~/GAATTC|AAGCTT/) { # EcoR ó Hind III
print "tercer motivo encontrado!\n";
}
#!/usr/bin/perl
# grupos_de_caracteres.pl
($dna =~/ATG|ATC|ATA|ATT/)
# es equivalente a:
($dna =~/AT(G|C|A|T)/)
# y es equivalente a:
($dna =~/AT[GCAT]/)

#!/usr/bin/perl
# rangos.pl
/[0123456789]/
# es equivalente a:
/[0-9]/
# y es equivalente a:
/\d/

Metacaracteres
. (punto) Cualquier carácter excepto newline

^ Principio de línea
$ Final de línea
\w Cualquier carácter alfanumérico (word)
\W Cualquier carácter no-alfanumérico
\s Cualquier carácter espaciador
\S Cualquier carácter no-espaciador
\d Cualquier dígito
\D Cualquier carácter no-dígito

Cuantificadores
? 0 o 1 elementos
+ 1 o más elementos
* 0 o más elementos
{N,M} Entre N y M elementos
{N, } Como mínimo N elementos
{ , M} No más de M elementos
{N} N elementos exactamente

Ejemplos de patrones
Código postal . Cualquier carácter excepto newline
– $cp =~/\d\d\d\d\d/; ^
$
Principio de línea
Final de línea
– $cp =~/\d{5}/; \w
\W
Cualquier carácter alfanumérico
Cualquier carácter no-alfanum.
\s Cualquier carácter espaciador
\S Cualquier carácter no-espaciador
\d Cualquier dígito
\D Carácter no dígito
Identificadores de DNA ? 0 ó 1 elementos

+ 1 ó más elementos
como “M58200.2” * 0 ó más elementos
{N,M} Entre N y M elementos
– $idSecuencia =~ /\w+\.\d+/; {N,} Un mínimo de N elementos
{,M} No más de M elementos
{N} N elementos exactamente

Metacaracteres
Negar caracteres:
/^ATG/i # Busca el codón inicio al principio
/^[0-9]/ # Debe empezar por un dígito
/^[^0-9]/ # Empieza por cualquier carácter

EXCEPTO un dígito . Cualquier carácter excepto newline
? 0 ó 1 elementos $ Final de línea
+ 1 ó más elementos \w Cualquier carácter alfanumérico
* 0 ó más elementos \W Cualquier carácter no-alfanum.
{N,M} Entre N y M elementos \s Cualquier carácter espaciador
{N,} Un mínimo de N elementos \S Cualquier carácter no-espaciador
{,M} No más de M elementos \d Cualquier dígito
{N} N elementos exactamente \D Carácter no dígito

Ejercicios
1. Crea un programa que compruebe si una

determinada variable tiene como valor un
DNI o NIF (con o sin letra al final). Ten en
cuenta que si permites también los números
de identificación de extranjeros, tienen una
letra delante.
2. Crea un programa que compruebe si una

variable almacena sólo DNA.
¡A practicar!

Búsqueda de patrón (pattern matching)
#!/usr/bin/perl
# pattern.pl
$DNI='12345678A';
if ($DNI=~/^[\dXY]\d{7}[A-Z]?$/i) {
print '¡DNI correcto!';
}
C:\>perl pattern.pl
¡DNI correcto!
C:\>_ ¡Solución!

#!/usr/bin/perl
# pattern.pl
$secuencia='AGTCGACTACGA';
if ($secuencia=~/^[GACT]+$/i) {
print 'Es DNA';
}
C:\>perl pattern.pl
Es DNA
C:\>_ ¿Solución?

#!/usr/bin/perl
# pattern.pl
$secuencia='AGTCNGACTACGNA';
if ($secuencia=~/^[GACT]+$/i) {
print 'Es DNA';
}
C:\>perl pattern.pl
C:\>_
¿Solución?

#!/usr/bin/perl
# pattern.pl
$secuencia='ACGTACGGTAGAATTCCTAGCAT';
if ($dna =~/^[GATC]*(GAATTC|AAGCTT)[GATC]*$/) {
# EcoR ó Hind III
print "motivo encontrado!\n";
}
C:\>perl pattern.pl
motivo encontrado!
C:\>_
¡Pruébame!

>secuencia1
AGTCGGACTACGA
#!/usr/bin/perl
# pattern2.pl
open(FILE,'secuencia.fas');
while(<FILE>) {
if ($_=~/^>(\S+).*$/) {
$nombre_secuencia=$1;
print $nombre_secuencia;
}
}
close(FILE);
C:\>perl pattern2.pl ¡Pruébame!

secuencia1
C:\>_

#!/usr/bin/perl
# pattern.pl
@ids=('4725621','38273a','9362618','29753.2');
foreach $id (@ids) {
if ($id !~ /^\d+$/) {
print "el id $id no es válido\n";
}
}
C:\>perl pattern.pl
el id 38273a no es válido
el id 29753.2 no es válido
¡Pruébame!
C:\>_

Abreviando en Perl
1) if ($_ =~ /^[GATCNgatcn]+$/)}
{ $length = $length + length $_;
*no recomendado
2) if (/^[GATCNgatcn]+$/)
{ $length = $length + length $_;}
*si recomendado
3) if (/^[GATCN]+$/i)
{ $length = $length + length $_;}
indistinto
4) if (/^[GATCN]+$/i)
{ $length += length $_;}

Abreviaturas de los operadores
+= Sumar un número a variable

–= Restar un número de una variable
*= Multiplicar un número por una variable
/= Dividir una variable por un número
.= Añadir una cadena a una variable

#!/usr/bin/perl
#patterns3.pl -- FASTA con varias secuencias: patterns3-data.fa
$id = ''; # seq. ID de la seq. actual
$longi = 0; # contador de longitud a cero
$total_longi = 0; # longitud todas las secuenc.
while (<>){
chomp;
if (/^>(\S+).*$/){ # descripcion encontrada
$id = $1;
if (length($id) > 0) {print "id: $id \n"};
$longi = 0;
}else{
$longi += length;
$total_longi += length;
}
}
print "Longitud total= $total_longi\n";
Sustraer cadenas
Función substr:
$fragmento = substr($cadena,$pos_inicial,$longitud);
#!OJO! La primera posición es 0
#!/usr/bin/perl
# substr.pl
$cadena_larga='Hola mundo!';
$fragmento = substr($cadena_larga,2,2);
print "la subcadena '$cadena_larga' es '$fragmento'";
C:\>perl substr.pl
¡Pruébame!
la subcadena de 'Hola mundo!' es 'la' Cambia los números
C:\>_ y usa negativos

Sustraer cadenas
Función substr:
$fragmento = substr($cadena,$pos_inicial,$longitud);
# La primera posición es 0
# $pos_inicial < 0 -> cuenta desde el final
# $longitud < 0 -> indica cuántas posiciones dejará

contando desde la derecha

Sustraer cadenas
Función index:
$posición = index($cadena_larga,$fragmento);
#!OJO! La primera posición es 0
#!/usr/bin/perl
# index.pl
$abcd='abcdefgh';
$letra='e';
$posicion = index($abcd,$letra);
print "'$letra' empieza en la posición '$posicion'";
C:\>perl index.pl
'e' empieza en la posición '4' ¡Pruébame!
C:\>_

Sustraer cadenas
#!/usr/bin/perl
# index.pl
$abcd='abcdefgh';
$letras='efg';
$posicion = index($abcd,$letras);
print "'$letras' empieza en la posición '$posicion'";
C:\>perl index.pl
'efg' empieza en la posición '4'
C:\>_ ¡Pruébame!

Sustraer cadenas
#!/usr/bin/perl
# index.pl
$abcd='abcdefgh';
$letras='eg';
$posicion = index($abcd,$letras);
print "'$letras' empieza en la posición '$posicion'";
C:\>perl index.pl
'eg' empieza en la posición '-1'
C:\>_
¡Pruébame!

Ejercicios
1. Combina las funciones index y substr para

comprobar si una determinada variable tiene
un codón inicio. En caso que sí contenga el
codón inicio, sustrae desde esa posición
hasta el final el gen putativo.
¡A
practicar!

Sustraer cadenas
#!/usr/bin/perl
# indexsubstr.pl
$DNA = 'ATCGCTGACATGCTGGTTACCC';
$codon_inicio = 'ATG';
$posicion = index($DNA,$codon_inicio);
if ($posicion != -1) {
$gen_putativo = substr($DNA,$posicion);
print "posible gen: $gen_putativo";
}
C:\>perl indexsubstr.pl
posible gen: ATGCTGGTTACCC ¡Solución!
C:\>_

Sustraer cadenas
#!/usr/bin/perl
# substrbucle.pl
$DNA='ATGTCGCAGGCTCTAACCGAT';
for ($i=0; $i<=(length($DNA)-1); $i+=3) { # length base 1!
$codon = substr($DNA,$i,3); # substr base 0!
print "$codon – ";
}
¡Pruébame!
C:\>perl substrbucle.pl
ATG – TCG – CAG – GCT – CTA – ACC – GAT -
C:\>_
¿Se te ocurre alguna opción mejor para evitar el

problema que hay al combinar length con substr?
Extrayendo patrones
Descripción FASTA:
>M18580 Clone 305A4, complete sequence
/^>(\S+)\s*(.*)$/
$id = $1;
$descripcion = $2;
. Cualquier carácter excepto newline
? 0 ó 1 elementos $ Final de línea
+ 1 ó más elementos \w Cualquier carácter alfanumérico
* 0 ó más elementos \W Cualquier carácter no-alfanum.
{N,M} Entre N y M elementos \s Cualquier carácter espaciador
{N,} Un mínimo de N elementos \S Cualquier carácter no-espaciador
{,M} No más de M elementos \d Cualquier dígito
{N} N elementos exactamente \D Carácter no dígito

Extrayendo patrones
#!/usr/bin/perl
# extraer.pl
$nombre='>M18580 Clone 305A4, complete sequence';
if ($nombre =~ /^>(\S+)\s*(.*)$/) {
$id = $1;
$descripcion = $2;
print "el id es '$id'";
}
C:\>perl extraer.pl
el id es 'M18580'
C:\>_
¡Pruébame!

Extrayendo patrones
#!/usr/bin/perl
# extraer.pl
$nombre='>M18580 Clone 305A4, complete sequence';
($id,$descripcion)=($nombre =~ /^>(\S+)\s*(.*)$/);
print "el id es '$id'";
C:\>perl extraer.pl
el id es 'M18580'
C:\>_
¡Pruébame!

Subrutinas y módulos
Variables globales vs variables locales
Variables globales → todo el programa
Variables locales → sólo se puede usar en la

parte del programa que se declara
my

my
#!/usr/bin/perl
# my.pl
$info='Adh - chr 2L';
if ($info =~/.*chr\s+(.+)/){
my $chr = $1;
print "cromosoma: $chr\n";
}
print "cromosoma: $chr\n";
C:\>perl my.pl
cromosoma: 2L
cromosoma: ¡Pruébame!
C:\>_

my
#!/usr/bin/perl
# my.pl
$i=5;
for (my $i=0; $i<=3;$i++) {
print "i dentro del bucle: $i\n";
last;
}
print "i fuera del bucle: $i\n";
C:\>perl my.pl
i dentro del bucle: 0
i fuera del bucle: 5
¡Pruébame!
C:\>_

my
#!/usr/bin/perl
# my.pl
$dna='ATGCGAGGCCT';
if ($dna =~/.*CG[AT]GG.*/) {
my $motivo = 'si';
}
else {
my $motivo = 'no';
}
print "motivo $motivo encontrado";
C:\>perl my.pl
motivo encontrado
¡Pruébame!
C:\>_

strict
use strict;
Obliga a declarar las variables

my → variables locales
our → variables globales
Controlamos los errores tipográficos
Sólo aplicable a nuevas variables, no aplicable a

las variables por defecto de Perl
strict
#!/usr/bin/perl
# strict.pl
use strict;
$contador1=0;
for ($i=0; $i<=3;$i++) {
$comtador1++;
}
print "$contador1";
¡Pruébame!
C:\>perl strict.pl
Global symbol "$contador1" requires explicit package name at prueba.pl line 4.
Global symbol "$i" requires explicit package name at prueba.pl line 5.
Global symbol "$comtador1" requires explicit package name at prueba.pl line 7.
Global symbol "$contador1" requires explicit package name at prueba.pl line 9.
Execution of prueba.pl aborted due to compilation errors.
C:\>_

strict
#!/usr/bin/perl
# strict.pl
use strict;
my $contador1=0;
for (my $i=0; $i<=3;$i++) {
$comtador1++;
}
print "$contador1";
¡Pruébame!
C:\>perl strict.pl
Global symbol "$comtador1" requires explicit package name at prueba.pl line 7.
Execution of prueba.pl aborted due to compilation errors.
C:\>_

strict
#!/usr/bin/perl
# strict.pl
use strict;
my $contador1=0;
for (my $i=0; $i<=3;$i++) {
$contador1++;
}
print "$contador1";
¡Pruébame!
C:\>perl strict.pl
4
C:\>_

strict
#!/usr/bin/perl
# strict.pl
use strict;
my $file='C:/archivos_perl/genes.txt';
open(FILE,$file);
while(<FILE>) {
chomp($_); # no es necesario poner 'my'!!
print $_."\n";
}
close(FILE);

Subrutinas
Evitan repetir código en distintas partes del

programa o en distintos programas

Subrutinas
#!/usr/bin/perl
# subrutinas.pl
$result1 = suma(2,6);
print "resultado 1: $result1\nresultado2: $result2";
sub suma{
# variables que le hemos pasado a la subrutina
my ($valor1, $valor2) = @_;
# realizamos las operaciones ¡Pruébame!

$resultado = $valor1+$valor2;
# valor que retornamos al programa principal

return ($resultado);
}
Subrutinas
#!/usr/bin/perl
# PROGRAMA PRINCIPAL
# (VARIABLES DEVUELTAS POR LA SUBRUTINA) =
# NOMBRE_SUBRUTINA (VARIABLES QUE SE PASAN A LA
SUBRUTINA);
# SUBRUTINA:
# sub NOMBRE_SUBRUTINA {
# my (VARIABLES DE ENTRADA) = @_;
# OPERACIONES
# return(VARIABLES DE SALIDA);
# }

Ejemplo: ordenar por número
#!/usr/bin/perl
# sort.pl
@numeros=('4', '20', '17', '68', '5'); ¡!
(@num_ordenados) = sort(@numeros);
print "@num_ordenados";
C:\>perl sort.pl
17 20 4 5 68
C:\>_
¡Pruébame!

Ejemplo: ordenar por número
#!/usr/bin/perl
# sort_by_number.pl
@numeros=('4', '20', '17', '68', '5');
(@num_ordenados) = sort_by_number(@numeros);
¡!
print "@num_ordenados"; # 4 5 17 20 68
sub sort_by_number{
my (@array) = @_;
# realizamos las operaciones
my @array_sorted = sort {$a <=> $b}(@array);
return (@array_sorted);
} ¡Pruébame!

Ejemplo: leer secuencias FASTA
#!/usr/bin/perl
# subrutinas.pl
(%secuencias) = lee_fichero_fasta('secuencias.fas');
sub lee_fichero_fasta{
my ($fichero) = @_;
# … ¡Pruébame!
Continúa…
return (%secuencias);
}

Ejemplo: leer secuencias FASTA
# abrimos el fichero, guardamos el contenido y cerramos
open(ARCHIVO,$fichero);
@datos=<ARCHIVO>;
close(ARCHIVO);
# unimos los elementos del array y los separamos por '>'

$datos=join('',@datos);
@seq_prov=split('>',$datos);
foreach $seq_prov (@seq_prov) { # para cada secuencia:
if ($seq_prov ne '') { # la primera está vacía
@seq_frag=split('\n',$seq_prov); #separamos por '\n'
$nombre=shift(@seq_frag); #el primer elemento es el nombre,
lo eliminamos de la matriz y lo guardamos en otra variable
$secuencia=join('',@seq_frag); #el resto de la matriz es la sec
$secuencias{$nombre}=$secuencia; #guardamos nombre y seq en hash
}
}

Ejemplo: obtener secuencia aleatoria
#!/usr/bin/perl
# for_aleatorio.pl
$cadena='';
for ($i=0; $i<=100; $i++) {
$num_aleatorio=rand(); #rand(10) int(rand(10))
if ($num_aleatorio < 0.25) {$cadena.='A';}
elsif ($num_aleatorio < 0.5) {$cadena.='T';}
elsif ($num_aleatorio < 0.75) {$cadena.='C';}
else {$cadena.='G';}
}
print "Nueva cadena:\n$cadena\n";
¡Pruébame!
C:\>perl for_aleatorio.pl
Nueva cadena
ATCATAGCGATGTATGTATCGCGCTAGCATCGATCGACCTGATCGACCTGATAGC
CATAGCGTACGTACGTACCTTGACCTAGGCTCAGTCGACTAGCTA

Ejercicios
1. Transforma el código anterior para generar

una secuencia aleatoria en una subrutina.
2. Permite modificar la longitud total de la

cadena generada por la subrutina, pasándole
el valor deseado

sub seq_aleatoria {
my ($longitud) = @_;
my $cadena='';
for (my $i=0; $i<=$longitud; $i++) {
my $num_aleatorio=rand(); #rand(10) int(rand(10))
if ($num_aleatorio < 0.25) {$cadena.='A';}
elsif ($num_aleatorio < 0.5) {$cadena.='T';}
elsif ($num_aleatorio < 0.75) {$cadena.='C';}
else {$cadena.='G';}
}
¡Solución!
return($cadena);
}

#!/usr/bin/perl
# secuencias.pl
($secuenciaA) = seq_aleatoria('100');
($secuenciaB) = seq_aleatoria('50'); ¡Solución!
¡Pruébame!
print "Secuencia1:\n$secuenciaA
Secuencia2:\n$secuenciaB\n";
C:\>perl secuencias.pl
Secuencia1:
ATCATAGCGATGTATGTATCGCGCTAGCATCGATCGACCTGATCGACCTGATAGC
CATAGCGTACGTACGTACCTTGACCTAGGCTCAGTCGACTAGCTA
Secuencia2:
TGCTGCGTAGCTGACCGTAGCTACACACAGCTAGTGCTTTGATCGCAGTC
C:\>

Subrutinas
@_ almacena todos los valores que se le pasan a

la subrutina
– ($var1,$var2,…) = @_ → podemos separar las
variables escalares
– (@array)=@_ → todo el contenido de @_ lo
guardamos en @array
– ($var1,$var2,@array)=@_ → separamos las
variables escalares del resto de elementos de la
matriz
– (@array1,@array2)=@_ → no podemos separar
los elementos en distintas matrices!!! Funciones
avanzadas
Módulos
Las subrutinas se pueden guardar en un

fichero distinto que:
– Suele tener la extensión .pm (perl module)
– La última línea tiene que ser 1;

Módulos
ficheros.pm
sub abrir_fichero {
# …
}
sub lee_fichero_fasta {
# …
}
sub lee_fichero_genbank {
# …
}
1;

ficheros.pm
sub lee_fichero_fasta{
my ($fichero) = @_; # variables que le hemos pasado a la subrutina
my %secuencias=();
# abrimos el fichero llamando a otra subrutina
my (@datos) = abrir_fichero($fichero,'yes'); #nombre fichero y chomp ok
# unimos los elementos del array y los separamos por '>'
my $datos=join('',@datos);
my @seq_prov=split('>',$datos);
foreach my $seq_prov (@seq_prov) { # para cada secuencia:
if ($seq_prov ne '') { # la primera está vacía
my @seq_frag=split('\n',$seq_prov); #separamos por '\n'
my $nombre=shift(@seq_frag); #el primer elemento es el nombre
my $secuencia=join('',@seq_frag); #el resto de la matriz es la sec.
$secuencias{$nombre}=$secuencia; #guardamos nombre y seq en un hash
}
}
return (%secuencias);
}

ficheros.pm
sub abrir_fichero {
my ($fichero,$chomp) = @_;
open(FILE, $fichero);
my @lineas=<FILE>;
close(FILE);
if ($chomp eq 'yes') { #chomp se ejecuta sólo si se pide

chomp(@lineas);
}
return (@lineas);
}

Módulos
#!/usr/bin/perl
# sub_cliente.pl C:\>perl sub_cliente.pl
use minilib;
print "\nresultado: "; resultado: 8
print suma(2,6);
C:\>_
print "\n";
#!/usr/bin/perl
# minilib.pm
¡Pruébame!
sub suma{
my $valor1 = $_[0];
my $valor2 = $_[1];
return ($valor1 + $valor2);
}
1;

Paquetes (packages)
Los packages son un tipo de módulos que

obligan a especificar la subrutina que
queremos utilizar

Paquetes (packages)
#!/usr/bin/perl
#miniAN_cliente.pl
use DNA; use RNA;
$cadena = "AGC";
$comp = complementa($cadena); # equivale a
main::complementa
print DNA::complementa($cadena), "\n!";

print RNA::complementa($cadena), "\n!";
print DNA->complementa($cadena); # notación alternativa
#!/usr/bin/perl #!/usr/bin/perl
# DNA.pm # RNA.pm
Package DNA; Package RNA;
sub complementa{ sub complementa{
#(...) #(...)
} }
1; 1;
Ejercicio Integrador
Ejercicio integrador
Genera una secuencia aleatoria de al menos

1000 bases para buscar información biológica
en ella.

(A) Calcula el contenido en GC por ventanas.

• Define el window size y window step
(B) Busca posibles ORFs en la secuencia generada.

• Ten en cuenta que un codón inicio y un codón stop
deben estar en la misma pauta de lectura con una
separación mínima.
• Recuerda las distintas pautas de lectura.
• Supón que no hay intrones para simplificar el
algoritmo.
(C) Dadas una serie de enzimas de restricción,

comprueba si su diana está presente en la
secuencia generada.
• EcoRI (G*AATTC)
• BamI (G*GATCC)
• HindIII (A*AGCTT)
En caso que sí esté presente, cuenta cuántos

fragmentos produciría y de qué tamaño sería
cada uno de ellos.
(D) Modifica el programa para que interactúe

con el usuario y le pida si quiere buscar una
información u otra.
168
¿Cómo seguir avanzando
con Perl?
¿Cómo seguir avanzando?
¡Con nuestros cursos!
• Perl Avanzado: BioPerl Bio
• Perl Avanzado: Funciones Avanzadas
• Perl Avanzado: Acceso a bases de datos
• Perl Avanzado: CGI WWW

Perl
http://ww.perl.com
Beginners:
http://learn.perl.org
Perl programming documentation

http://perldoc.perl.org/


PerlBasic SGB Jul2014 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

PerlBasic SGB Jul2014 PDF

Cargado por

Copyright:

Formatos disponibles

Perl Básico para Bioinformáticos

Del 7 al 11 de julio de 2014

Variedad de lenguajes reducida

Lenguaje rápido de programar

Lenguaje de nivel intermedio

Perl Básico para Bioinformáticos 3

• Curva de aprendizaje baja y larga

Perl Básico para Bioinformáticos 5

Intérprete de Perl instalado

Directorio de trabajo en el disco

Perl Básico para Bioinformáticos 6

Perl puede ser un lenguaje ofuscado

Lema de Perl “Hay más de una manera de

Perl Básico para Bioinformáticos 8

No hay uno disponible  Escribo el programa (o

 Identificar los inputs requeridos (datos o información que debe

En Perl (sólo los comentarios):

 Revisar (errores, depuración -debugging)

Perl Básico para Bioinformáticos 14

• Intérprete y programa (script)

• Ejecutar programas: vamos a DOS (línea de comandos) y escribimos

Perl Básico para Bioinformáticos 16

Perl Básico para Bioinformáticos 17

Perl Básico para Bioinformáticos 18

Cambiar de unidad de disco

Perl Básico para Bioinformáticos 19

• Las instrucciones se ejecutan una tras otra, desde el principio

El signo # sirve para introducir comentarios. Las líneas

Perl Básico para Bioinformáticos 20

• Texto (o cadena de caracteres, string)

Perl Básico para Bioinformáticos 22

• Variables escalares (scalars)

Perl Básico para Bioinformáticos 23

Proporcionan un lugar donde guardar datos

• Características de los nombres de variables:

$nombreDeVariableLargo; # letras, números, líneas_subr

$l #nombre de variable poco intuitivo

Perl Básico para Bioinformáticos 24

• Contenido de las variables:

• Asignar valores a las variables

• Las comillas dobles interpretan los valores

# almacenamos una secuencia de DNA en una variable

# Imprimos la secuencia en la pantalla

# salimos del programa

Perl Básico para Bioinformáticos 26

# Primero almacenamos dos secuencias de DNA en dos variables

# Podemos concatenar de distintas formas

Perl Básico para Bioinformáticos 27

# Primero almacenamos dos secuencias de DNA en dos variables

# concatenamos ambas en una tercera variable que se imprime

Perl Básico para Bioinformáticos 28

Perl Básico para Bioinformáticos 29

Perl Básico para Bioinformáticos 30

# función length para calcular la longitud de una cadena

# Valores de las nuevas variables

Perl Básico para Bioinformáticos 31

# función lc para pasar de mayúsculas a minúsculas

# función uc para pasar de minúsculas a mayúsculas

Perl Básico para Bioinformáticos 32

Matrices = arrays = vectores

Variable que almacena múltiples valores

# Guardamos las bases del DNA en variables escalares

# Podemos guardar la misma información en una matriz