Foro - Perl en Español

por **explorer** » 2013-04-21 09:49 @450

Ese módulo no se encuentra entre la lista de paquetes de software de Ubuntu (ni de Debian), así que debes usar entonces el comando cpan o cpanp para instalarlo. Mira en la guía cómo se hace. Yo lo he hecho en mi máquina (siendo root) con este comando:

cpanp i List::Util::WeightedChoice

Si solo tienes el comando cpan, será así:

cpan List::Util::WeightedChoice

frido escribiste:me dice: Can't locate List/Util/WeightedChoice.pm in @INC (@INC contains: /home/turko/Weighted /etc/perl /usr/local/lib/perl/5.14.2 /usr/local/share/perl/5.14.2 /usr/lib/perl5 /usr/share/perl5 /usr/lib/perl/5.14 /usr/share/perl/5.14 /usr/local/lib/site_perl .) at proteinadna.pl line 4. BEGIN failed--compilation aborted at proteinadna.pl line 4.

Lo he probado todo y no funciona.

El mensaje indica que el módulo no está bien instalado. Mira mi mensaje anterior.

He descubierto más fallos en el código: tienes dos entradas para la 'S'. Y las entradas deben separarse con comas. Algo así:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

my %seq_to_amino = (
    A => {
        secuencias => [qw (GCT GCC GCA GCG)],
        pesos      => [qw (  2   8  10  80)],
    },
    C => {
        secuencias => [qw (TGT TGC)],
        pesos      => [qw ( 15  85)],
    },
    D => {
        secuencias => [qw (GAT GAC)],
        pesos      => [qw ( 68  32)],
    },
# aquí, el resto. Observa las comas entre cada par de entradas
);
Coloreado en 0.003 segundos,  usando GeSHi 1.0.8.4

por **frido** » 2013-04-21 12:10 @549

El modulo ha sido instalado con éxito.
El programa esta así:

use strict;
use v5.14;
use List::Util::WeightedChoice qw( choose_weighted );
use warnings;
my %seq_to_amino = (
F => {
secuencias => [ qw (TTT TTC ) ],
pesos => [ qw ( 10 90 ) ],
},
L => {
secuencias => [ qw (TTA TTG CTT CTC CTA CTG ) ],
pesos => [ qw ( 10 20 5 5 30 30 ) ],
},
I => {
secuencias => [ qw (ATT ATC ATA ) ],
pesos => [ qw ( 10 40 50 ) ],
},
M => {
secuencias => [ qw (ATG ) ],
pesos => [ qw (100 ) ],
},
V => {
secuencias => [ qw (GTT GTC GTA GTG ) ],
pesos => [ qw ( 10 40 30 20 ) ],
},
S => {
secuencias => [ qw (TCT TCC TCA TCG AGT AGC) ],
pesos => [ qw ( 10 15 15 30 25 5 ) ],
},
P => {
secuencias => [ qw (CCT CCC CCA CCG ) ],
pesos => [ qw ( 10 10 50 30) ],
},
T => {
secuencias => [ qw (ACT ACC ACA ACG ) ],
pesos => [ qw ( 20 20 30 30) ],
},
A => {
secuencias => [ qw (GCT GCC GCA GCG ) ],
pesos => [ qw ( 2 8 10 80 ) ],
},
Y => {
secuencias => [ qw (TAT TAC ) ],
pesos => [ qw ( 25 75 ) ],
},
H => {
secuencias => [ qw (CAT CAC ) ],
pesos => [ qw ( 45 55 ) ],
},
Q => {
secuencias => [ qw (CAA CAG ) ],
pesos => [ qw ( 85 15 ) ],
},
N => {
secuencias => [ qw (AAT AAC ) ],
pesos => [ qw ( 35 65 ) ],
},
K => {
secuencias => [ qw (AAA AAG ) ],
pesos => [ qw ( 10 90 ) ],
},
D => {
secuencias => [ qw (GAT GAC ) ],
pesos => [ qw ( 68 32 ) ],
},

E => {
secuencias => [ qw (GAA GAG ) ],
pesos => [ qw ( 10 90 ) ],
},
C => {
secuencias => [ qw (TGT TGC ) ],
pesos => [ qw ( 15 85 ) ],
},
W => {
secuencias => [ qw (TGG ) ],
pesos => [ qw (100 ) ],
},
R => {
secuencias => [ qw (CGT CGC CGA CGG AGA AGG ) ],
pesos => [ qw ( 10 15 25 5 5 40 ) ],
},
G => {
secuencias => [ qw (GGT GGC GGA GGG ) ],
pesos => [ qw ( 10 20 30 40 ) ],
},

);
my $n=1;
my $seq;
my $secuencia_final;
my %seq_to_amino;
my $letra;
open (FHANDLE, "Fasta.txt") or die ("missatge d'error!");
while ($seq=<FHANDLE>)
{
chomp;

my $secuencia_final;
for (my $i = 0; $i < length $seq; $i++)
{
my $letra = substr $seq, $i, 1;
$secuencia_final .= choose_weighted ($seq_to_amino{$letra}{secuencias}, $seq_to_amino{$letra}{pesos});
print $secuencia_final;
}

}
close (FHANDLE);

Pero me da el error:

Parameter #1 (undef) to List::Util::WeightedChoice::choose_weighted was an 'undef', which is not one of the allowed types: arrayref
at /usr/local/share/perl/5.14.2/List/Util/WeightedChoice.pm line 37
List::Util::WeightedChoice::choose_weighted(undef, undef) called at proteinadna.pl line 103

Gracias por la ayuda y por tu tiempo.

por **explorer** » 2013-04-21 13:23 @599

En efecto, se puede hacer sin el módulo. De hecho, el código del módulo apenas son esas quince líneas.

Para aplicarlo a cada letra, debes llamar a este código por cada letra que leas de la secuencia. Como ya tienes guardada todas las secuencias y los pesos, solo tienes que modificar los valores de @porcentajes y @secuencias con los que el hash te devuelve para una letra en concreto.

Esta es una primera versión del programa:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl
#
# Generador de secuencias almacenadas en un archivo FASTA.
# 
# Lee un archivo FASTA multisecuencia, buscar la secuencia por el ID indicado como argumento,
# y mostrarla traducida a ADN así como su complementaria.
#
# Joaquin Ferrero. 20130421
#
 
use v5.14;
use autodie;
 
### Comprobar los argumentos ##################################################
@ARGV == 1
    or die "Uso: $0 <ID secuencia a mostrar>\n";
 
my $ID_a_mostrar = $ARGV[0];
 
 
### Leemos el archivo FASTA ###################################################
my %secuencias;
 
open my $FHANDLE, "Fasta.txt";
 
my $secuencia_leida;
my $ID;
 
while (my $linea = <$FHANDLE>) {
 
    my $c = substr $linea, 0, 1;                        # primera letra de la $linea
 
    if ($c eq '>'  or  eof $FHANDLE) {                  # llegamos a una nueva secuencia o fin de archivo
        chomp $linea;
 
        if (eof $FHANDLE) {                             # caso de fin de archivo
            $secuencia_leida .= $linea;                 # agregamos la última línea
        }
 
        if ($secuencia_leida) {                         # si hemos leído antes una secuencia
            $secuencias{$ID} = $secuencia_leida;        # la guardamos
            $secuencia_leida = '';                      # inicializamos almacén de la secuencia
        }
 
        $ID = (split /\|/, $linea)[1];                  # extraemos el nuevo ID
 
        next;                                           # leemos la siguiente línea
    }
 
    $secuencia_leida .= $linea;                         # vamos guardando las líneas
}
 
close $FHANDLE;
 
#use Data::Dumper;
#say Dumper \%secuencias;
 
### Comprobamos la existencia de la secuencia dentro del archivo ##############
if (not exists $secuencias{ $ID_a_mostrar }) {
    say "No existe la secuencia [$ID_a_mostrar]";
    say "Los posibles valores son:";
    say "\t", join "\n\t", sort keys %secuencias;
 
    exit 1;
}
 
### Generamos la secuencia de ADN de forma aleatoria ##########################
my %seq_to_amino = (
    A => {
        secuencias => [qw (GCT GCC GCA GCG)],
        pesos      => [qw (  2   8  10  80)],
    },
    C => {
        secuencias => [qw (TGT TGC)],
        pesos      => [qw ( 15  85)],
    },
    D => {
        secuencias => [qw (GAT GAC)],
        pesos      => [qw ( 68  32)],
    },
    E => {
        secuencias => [qw (GAA GAG)],
        pesos      => [qw ( 10  90)],
    },
    F => {
        secuencias => [qw (TTT TTC)],
        pesos      => [qw ( 10  90)],
    },
    G => {
        secuencias => [qw (GGT GGC GGA GGG)],
        pesos      => [qw ( 10  20  30  40)],
    },
    H => {
        secuencias => [qw (CAT CAC)],
        pesos      => [qw ( 45  55)],
    },
    I => {
        secuencias => [qw (ATT ATC ATA)],
        pesos      => [qw ( 10  40  50)],
    },
    K => {
        secuencias => [qw (AAA AAG)],
        pesos      => [qw ( 10  90)],
    },
    L => {
        secuencias => [qw (TTA TTG CTT CTC CTA CTG)],
        pesos      => [qw ( 10  20   5   5  30  30)],
    },
    M => {
        secuencias => [qw (ATG)],
        pesos      => [qw (100)],
    },
    N => {
        secuencias => [qw (AAT AAC)],
        pesos      => [qw ( 35  65)],
    },
    P => {
        secuencias => [qw (CCT CCC CCA CCG)],
        pesos      => [qw ( 10  10  50  30)],
    },
    Q => {
        secuencias => [qw (CAA CAG)],
        pesos      => [qw ( 85  15)],
    },
    R => {
        secuencias => [qw (CGT CGC CGA CGG AGA AGG)],
        pesos      => [qw ( 10  15  25   5   5  40)],
    },
    S => {
        secuencias => [qw (TCT TCC TCA TCG)],
        pesos      => [qw ( 10  15  25  50)],
    },
    T => {
        secuencias => [qw (ACT ACC ACA ACG)],
        pesos      => [qw ( 20  20  30  30)],
    },
    V => {
        secuencias => [qw (GTT GTC GTA GTG)],
        pesos      => [qw ( 10  40  30  20)],
    },
    W => {
        secuencias => [qw (TGG)],
        pesos      => [qw (100)],
    },
    Y => {
        secuencias => [qw (TAT TAC)],
        pesos      => [qw ( 25  75)],
    },
);
 
my $secuencia = $secuencias{$ID_a_mostrar};
my $adn;
 
for my $linea (split /\n/, $secuencia) {                                # para todas las líneas
    for ( my $i = 0; $i < length $linea; $i++ ) {                       # por cada letra de la línea
        my $letra = substr $linea, $i, 1;
 
#        if (not exists $seq_to_amino{$letra}) {
#            die "ERROR: No hay traducción para la letra [$letra]\n";
#        }
                                                                        # generamos adn para esa letra
        $adn .= choose_weighted( $seq_to_amino{$letra}{secuencias}, $seq_to_amino{$letra}{pesos} );
    }
 
    $adn .= "\n";                                                       # fin de línea cosmético
}
chomp $adn;                                                             # el último sobra
 
my $adn_complementaria = $adn =~ tr/ACGT/TGCA/r;                        # transliteración
$adn_complementaria    = reverse $adn_complementaria;                   # inversión
 
### Salida del resultado ######################################################
say "Secuencia:\n$adn";
say "=" x 60;
say "Complementaria:\n$adn_complementaria";
 
 
### Subrutinas ################################################################
sub choose_weighted {
 
    my ($objects, $weights ) = @_;
    if ( @$objects != @$weights ) {
        die "No son de igual longitud, el número de secuencias y el de pesos\n";
    }
 
    my @ranges = ();            # actually upper bounds on ranges
    my $left = 0;
    
    for my $weight (@$weights){
        $weight = 0 if $weight < 0; # the world is hostile...
        $left += $weight;
        push @ranges, $left;
    }
 
    my $weightIndex = rand $left;
    for( my $i =0; $i< @$objects; $i++){
        return $objects->[$i] if $weightIndex < $ranges[$i];
    }
}
 
__END__
Coloreado en 0.006 segundos,  usando GeSHi 1.0.8.4

Lo que he hecho es copiar casi tal cual el código del módulo.

Ahora, si lo ejecuto como perl frido.pl P18460, sale:

Sintáxis: [ Descargar ] [ Ocultar ]

Using text Syntax Highlighting

Secuencia:

ATGCGTGCGGCGTGGGGGTCGGTATGGTGCTTGTGCCTAGCGGCGGCGGTCGGGGCCCTACCGGCGGCGCGCAGGCGTGGGGCGGAGCGCTCGGGAGGGCAAGCGGCAGAGTATTTGCGATCTGAGACAGCGTTCCTGGAAGAGCTGGTCTTCGGTTCGGGAGATACCATAGAGCTGTCG

TGCAACACACAATCTTCGTCGGTCTCGGTATTCTGGTTCAAGGACGGTATAGGGATTGCGCCATCGAACCGAACCCATATCGGACAAAAGCTATTAAAGATCATTAATGTGTCATATGATGACTCAGGGCTATATTCATGTAAGCCACGCCATTCCAATGAGGTACTAGGCAATTTCACT

GTACGTGTAACTGATTCGCCCTCATCCGGAGACGACGAGGATGACGATGACGAGTCGGAGGATACGGGGGTCCCATTCTGGACACGCCCAGATAAGATGGAAAAGAAGTTGCTAGCTGTGCCGGCGGCGAACACGGTCCGTTTCCGCTGCCCGGCAGGCGGGAATCCAACTCCTACGATC

TACTGGTTGAAGAACGGAAAGGAGTTCAAGGGAGAGCACAGGATCGGGGGAATCAAGCTCCGACATCAACAGTGGTCACTGGTAATGGAGTCGGTCGTCCCGTCCGATCGGGGCAACTACACATGCGTCGTCGAGAACAAGTACGGAAACATCAGGCATACCTACCAACTTGATGTTCTG

GAGCGATCGCCACACAGGCCAATCTTACAGGCAGGTCTGCCGGCGAACCAAACGGTAGTAGTTGGCTCGAACGTAGAGTTCCATTGCAAGGTTTACTCCGATGCGCAACCGCACATACAATGGCTTAAGCACGTAGAGGTAAACGGTTCGAAGTACGGACCGGATGGGACTCCATATGTC

ACGGTTCTGAAGACGGCGGGGGTAAACACGACTGATAAGGAGCTAGAAATACTATACCTAAGGAATGTGACTTTCGAGGATGCGGGGGAGTACACTTGCTTGGCGGGGAACTCCATTGGGTTCTCGCACCACTCAGCGTGGTTGACAGTTCTACCGGCAGAGGAGCTCATGGAGATGGAT

GATTCGGGTTCAGTATATGCGGGGATATTGTCGTATGGAACTGGCTTGGTCTTATTCATACTGGTATTGGTGATAGTAATCATTTGCAGGATGAAGATGCCAAACAAGAAGGCGATGAACACTACGACAGTCCAAAAGGTATCGAAGTTTCCTCTAAAGAGGCAACAAGTATCGCTGGAG

TCAAACTCATCGATGAATTCCAACACACCATTAGTTCGAATAACCCGACTGTCGTCGTCTGATGGCCCAATGTTAGCGAACGTCTCAGAGCTGGAGCTACCGCCGGATCCGAAGTGGGAGTTGGCGCGATCTCGACTAACGTTAGGGAAACCGCTGGGAGAGGGATGTTTCGGGCAAGTG

GTCATGGCAGAGGCAATTGGAATAGATAAGGACAAGCCGAACAAGGCGATCACAGTCGCGGTTAAAATGCTGAAGGATGATGCGACAGATAAAGACCTATCTGATCTAGTCTCGGAGATGGAGATGATGAAGATGATAGGCAAACACAAGAACATCATTAACCTGCTAGGGGCGTGCACA

CAAGATGGGCCGCTGTACGTACTGGTTGAGTATGCGTCAAAGGGAAACCTAAGGGAGTATTTGAGGGCGAGACGCCCACCAGGCATGGATTATTCGTTCGATACATGCAAGCTACCAGAAGAGCAGTTGACGTTCAAGGACTTAGTCTCGTGCGCGTACCAAGTAGCGAGAGGGATGGAG

TACCTAGCGTCGCAAAAGTGCATACACCGCGATCTGGCGGCGCGTAACGTACTGGTCACGGAGGACAATGTCATGAAGATCGCCGATTTCGGGCTAGCGCGAGATGTCCACAATATCGATTACTACAAGAAGACTACTAACGGGCGACTACCCGTGAAGTGGATGGCGCCTGAGGCGTTA

TTCGACCGAGTATACACACACCAATCAGACGTGTGGTCATTCGGGGTTTTGTTGTGGGAGATCTTCACGCTAGGGGGATCTCCGTACCCGGGAATCCCAGTCGAGGAGTTATTCAAGCTATTGAAGGAGGGCCATAGGATGGATAAGCCGGCGAACTGCACCCATGATTTGTACATGATA

ATGAGGGAGTGCTGGCATGCAGTGCCCTCGCAACGCCCGACCTTCAAGCAACTGGTAGAGGATCTGGACCGAGTACTAACCATGACCTCGACAGATGAGTACCTAGATCTGTCGGTACCATTCGAGCAATACTCGCCCGCCGGGCAAGATACACACTCGACCTGCTCGTCGGGGGACGAT

TCGGTCTTCGCACACGATCTACTGCCAGATGAACCGTGCTTGCCCAAGCACGTTCCGTGCAATGGGGTCATCCGAACA

============================================================

Complementaria:

TGTTCGGATGACCCCATTGCACGGAACGTGCTTGGGCAAGCACGGTTCATCTGGCAGTAGATCGTGTGCGAAGACCGA

ATCGTCCCCCGACGAGCAGGTCGAGTGTGTATCTTGCCCGGCGGGCGAGTATTGCTCGAATGGTACCGACAGATCTAGGTACTCATCTGTCGAGGTCATGGTTAGTACTCGGTCCAGATCCTCTACCAGTTGCTTGAAGGTCGGGCGTTGCGAGGGCACTGCATGCCAGCACTCCCTCAT

TATCATGTACAAATCATGGGTGCAGTTCGCCGGCTTATCCATCCTATGGCCCTCCTTCAATAGCTTGAATAACTCCTCGACTGGGATTCCCGGGTACGGAGATCCCCCTAGCGTGAAGATCTCCCACAACAAAACCCCGAATGACCACACGTCTGATTGGTGTGTGTATACTCGGTCGAA

TAACGCCTCAGGCGCCATCCACTTCACGGGTAGTCGCCCGTTAGTAGTCTTCTTGTAGTAATCGATATTGTGGACATCTCGCGCTAGCCCGAAATCGGCGATCTTCATGACATTGTCCTCCGTGACCAGTACGTTACGCGCCGCCAGATCGCGGTGTATGCACTTTTGCGACGCTAGGTA

CTCCATCCCTCTCGCTACTTGGTACGCGCACGAGACTAAGTCCTTGAACGTCAACTGCTCTTCTGGTAGCTTGCATGTATCGAACGAATAATCCATGCCTGGTGGGCGTCTCGCCCTCAAATACTCCCTTAGGTTTCCCTTTGACGCATACTCAACCAGTACGTACAGCGGCCCATCTTG

TGTGCACGCCCCTAGCAGGTTAATGATGTTCTTGTGTTTGCCTATCATCTTCATCATCTCCATCTCCGAGACTAGATCAGATAGGTCTTTATCTGTCGCATCATCCTTCAGCATTTTAACCGCGACTGTGATCGCCTTGTTCGGCTTGTCCTTATCTATTCCAATTGCCTCTGCCATGAC

CACTTGCCCGAAACATCCCTCTCCCAGCGGTTTCCCTAACGTTAGTCGAGATCGCGCCAACTCCCACTTCGGATCCGGCGGTAGCTCCAGCTCTGAGACGTTCGCTAACATTGGGCCATCAGACGACGACAGTCGGGTTATTCGAACTAATGGTGTGTTGGAATTCATCGATGAGTTTGA

CTCCAGCGATACTTGTTGCCTCTTTAGAGGAAACTTCGATACCTTTTGGACTGTCGTAGTGTTCATCGCCTTCTTGTTTGGCATCTTCATCCTGCAAATGATTACTATCACCAATACCAGTATGAATAAGACCAAGCCAGTTCCATACGACAATATCCCCGCATATACTGAACCCGAATC

ATCCATCTCCATGAGCTCCTCTGCCGGTAGAACTGTCAACCACGCTGAGTGGTGCGAGAACCCAATGGAGTTCCCCGCCAAGCAAGTGTACTCCCCCGCATCCTCGAAAGTCACATTCCTTAGGTATAGTATTTCTAGCTCCTTATCAGTCGTGTTTACCCCCGCCGTCTTCAGAACCGT

GACATATGGAGTCCCATCCGGTCCGTACTTCGAACCGTTTACCTCTACGTGCTTAAGCCATTGTATGTGCGGTTGCGCATCGGAGTAAACCTTGCAATGGAACTCTACGTTCGAGCCAACTACTACCGTTTGGTTCGCCGGCAGACCTGCCTGTAAGATTGGCCTGTGTGGCGATCGCTC

CAGAACATCAAGTTGGTAGGTATGCCTGATGTTTCCGTACTTGTTCTCGACGACGCATGTGTAGTTGCCCCGATCGGACGGGACGACCGACTCCATTACCAGTGACCACTGTTGATGTCGGAGCTTGATTCCCCCGATCCTGTGCTCTCCCTTGAACTCCTTTCCGTTCTTCAACCAGTA

GATCGTAGGAGTTGGATTCCCGCCTGCCGGGCAGCGGAAACGGACCGTGTTCGCCGCCGGCACAGCTAGCAACTTCTTTTCCATCTTATCTGGGCGTGTCCAGAATGGGACCCCCGTATCCTCCGACTCGTCATCGTCATCCTCGTCGTCTCCGGATGAGGGCGAATCAGTTACACGTAC

AGTGAAATTGCCTAGTACCTCATTGGAATGGCGTGGCTTACATGAATATAGCCCTGAGTCATCATATGACACATTAATGATCTTTAATAGCTTTTGTCCGATATGGGTTCGGTTCGATGGCGCAATCCCTATACCGTCCTTGAACCAGAATACCGAGACCGACGAAGATTGTGTGTTGCA

CGACAGCTCTATGGTATCTCCCGAACCGAAGACCAGCTCTTCCAGGAACGCTGTCTCAGATCGCAAATACTCTGCCGCTTGCCCTCCCGAGCGCTCCGCCCCACGCCTGCGCGCCGCCGGTAGGGCCCCGACCGCCGCCGCTAGGCACAAGCACCATACCGACCCCCACGCCGCACGCATColoreado en 0.001 segundos,  usando GeSHi 1.0.8.4

El error que te sale es del chomp; dentro del while(). Debe ser chomp $seq;

Edito: como ya has instalado el módulo, lo único que habría que hacer a esta versión es agregar la línea del 'use' y quitar la subrutina choose_weighted() del final, para que el programa use la del módulo.

por **frido** » 2013-04-21 16:12 @716

Muchas gracias, el programa que has hecho es lo que buscaba... Solo que quería que me saliera la ID conjuntamente con las cadenas de ADN. Pero bueno, ya no te molesto más.

Muchas gracias.

Foro - Perl en Español

Traducción de secuencia y su complementaria

Re: Traducción de secuencia y su complementaria

Publicidad

Re: Traducción de secuencia y su complementaria

Re: Traducción de secuencia y su complementaria

Re: Traducción de secuencia y su complementaria

Re: Traducción de secuencia y su complementaria

¿Quién está conectado?