Foro - Perl en Español

por **otronovato** » 2013-08-31 13:04 @586

Tengo dos funciones: la primera genera los grupos de tres caracteres que hay en una cadena y la segunda calcula la frecuencia de cada uno de los grupos.

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

sub gen_trío{
 
#En este caso no voy a generar todos los tríos de caracteres posibles
#sino únicamente los que pueden aparecer en la cadena.
#Recibe la cadena con el cifrado y devuelve una referencia a un array
#con los grupos de tres caracteres existentes.
 
    my %frec_grupos;
    my @cadena = split //, $_[0];
    my @grupos;
 
    for(my $index = 0; $index <= $#cadena; $index++){
 
 
        if(($index + 2) <= $#cadena){
            $grupos[$index]=join '', @cadena[$index .. $index +2];
        }
    }
 
    @frec_grupos{@grupos} = 1;
 
    @grupos = sort keys %frec_grupos;
 
    return \@grupos;
}
 
sub frecuencia{
 
#Recibe una referencia a un array de cadenas de caracteres sin repetir y una cadena con
#el mensaje. Devuelve una referencia a un hash con las frecuencias.        
 
    my %frec; #Estructura a retornar
    @frec{@{$_[0]}}=0; #Iniciamos el hash con los valores a distribuir
 
 
    foreach(keys %frec){
 
        my @control;
 
        @control=$_[1] =~m/$_/g;
 
        $frec{$_}=@control;
    }
 
    return \%frec;
}
 
Coloreado en 0.004 segundos,  usando GeSHi 1.0.8.4

He estado mucho rato dándole vueltas a la sentencia que realiza el recuento en la segunda función:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

        @control=$_[1] =~m/$_/g;
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Nunca lo había pensado... ¿Cómo opera el modificador /g sobre el operador m//? Porque, de hecho, lo convierte en una función más que en un operador, y desde luego con una finalidad totalmente diferente. ¿No?

Tampoco entiendo que, existiendo m//g, no sea el propio operador "match" quien realice las tareas de las funciones index() y rindex(), (m//g me parece de mucho más "alto nivel"). De hecho, y cuanto más lo pienso, la labor realizada por m//g me parece más propia de una función que de un operador. A priori casi esperaría que la labor de index() la realizara el propio m// mediante el modificador correspondiente.

¿Razones histórica del desarrollo de Perl? ¿Peculiaridades sintácticas? ¿Es correcto lo que expongo?

Un saludo.

El problema de leer grupos de tres caracteres ya lo hemos tratado unas cuantas veces, sobre todo en el foro de Bioinformática. Allí se llaman "codones". Hay algunas expresiones regulares muy interesantes.

La línea 20 está mal: solo estás asignando un '1'. Debes realizar una operación de asignación de igual número de valores que scalar(@grupos). O meter esa instrucción dentro del bucle principal.

La línea 33 suele no ser necesaria: si no inicializas un hash, sus valores serán siempre indefinidos, por lo que valdrán '0' en las operaciones numéricas. Además, los valores que almacenas en la línea 33 quedan sobreescritos en la línea 42.

El modificador '/g' sirve para hacer una búsqueda "global": En contexto escalar, cada vez que se aplica la exp. reg., se recuerda la última posición de búsqueda, por lo que nos sirve para aplicar el mismo patrón, de forma repetida. En contexto de lista, devuelve una lista de elementos, con todos los grupos de captura encontrados, o de todo el patrón, si no hay grupos de captura.

Más información en tu propio ordenador en perldoc perlre, y en la Web (traducido al español). Explicación y ejemplos de '/g' en la subsección Global matching dentro de la sección Using regular expressions in Perl, dentro de perlretut.

La diferencia básica entre (r)index() y m//, es que los primeros no admiten exp. reg., solo cadenas literales, así que las búsquedas son mucho más rápidas. Por estos foros hay ejemplos de búsquedas repetidas con index().

Las razones históricas del desarrollo de Perl, lo marcan los sucesivos añadidos de técnicas de programación, que se han desarrollado a lo largo de los años. Por ejemplo, el paso de Perl v4 a Perl v5 (o Perl v5.6, ya no recuerdo) fue la incorporación de las facilidades de la programación orientada a objetos (copiada de Python

). En los últimos años, han seguido haciendo lo mismo: tomar lo mejor de otros lenguajes e incorporarlos al lenguaje. Casi siempre, son técnicas no visibles para el usuario (programador) final, sino que solo importa a los desarrolladores del lenguaje, en C y C++, en el código fuente de Perl. Por ejemplo, en Perl v5.18, se ha cambiado la estrategia del orden de generación de las claves de los hash, para aumentar la seguridad.

En cada nueva versión, en los últimos años, las versiones estables incorporan novedades, como el caso de las funciones say() y fc(); los operadores '~~', '//' y '...'; todo el soporte de utf8, los identificadores given(), when(); activar el modo estricto por defecto en Perl v5.12; etc., etc. Todos los cambios están indicados en los sucesivos documentos perldelta y perlXXXXdelta (por ejemplo: perl5120delta).

por **otronovato** » 2013-08-31 15:33 @689

Sí... Pero como probando las dos funciones con este código de abajo me daban el resultado correcto, no he pensado más. :roll:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

print "Introduce la cadena a considerar\n";
my $cadena = <STDIN>;
chomp $cadena;
 
my $ref_tríos = &gen_trío($cadena);
my @tríos = @{$ref_tríos};
my $num_tríos = @tríos;
 
print "Hay $num_tríos tríos de caracteres, que son ", join ',',@tríos, "\n\n\n";
 
print "La frecuencia de cada uno de los tríos es:\n";
 
my $ref_frec = &frecuencia($ref_tríos, $cadena);
my %frecuencias = %{$ref_frec};
 
foreach(sort keys %frecuencias){
 
    print "Trío $_\t------>$frecuencias{$_}\n";
 
}
 
Coloreado en 0.002 segundos,  usando GeSHi 1.0.8.4

El resultado:

Sintáxis: [ Descargar ] [ Ocultar ]

xxxxx@xxxxxx:~/Escritorio/scripts_criptografía$ ./frec_calc.pl
Introduce la cadena a considerar
HOLAHOLACARACOLA
Hay 11 tríos de caracteres, que son ACA,ACO,AHO,ARA,CAR,COL,HOL,LAC,LAH,OLA,RAC,
La frecuencia de cada uno de los tríos es:
Trío ACA ------>1
Trío ACO ------>1
Trío AHO ------>1
Trío ARA ------>1
Trío CAR ------>1
Trío COL ------>1
Trío HOL ------>2
Trío LAC ------>1
Trío LAH ------>1
Trío OLA ------>3
Trío RAC ------>1

Pero si lo pienso, en efecto, la línea 20 debería ser:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

 %frec_grupos = map{$_,1}@grupos;
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Aunque, por lo que veo, la iniciación del hash era innecesaria, como bien explicabas.

La línea 33 suele no ser necesaria: si no inicializas un hash, sus valores serán siempre indefinidos, por lo que valdrán '0' en las operaciones numéricas. Además, los valores que almacenas en la línea 33 quedan sobreescritos en la línea 42.

La línea 33 debería ser:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

 %frec = map{$_,0}@{$_[0]};
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Respecto a los usos de index(), m//, etc... ¡Lo fácil que es hacer en Perl un programa que cubra necesidades "sencillas" y lo difícil que es ser capaz de sacarle todo el jugo y hacer un código óptimo!

Entiendo que si trabajara con cadenas muy largas merecería la pena comprobar la velocidad del algoritmo basado en m//g y en relación a la de otro basado en un bucle con index()... ¿Cómo se toma esa decisión? (Entiendo que no es una diferencia crítica para las cadenas de tamaño reducido con las que me muevo ahora mismo... ¿no?).

Gracias, explorer :wink:

por **explorer** » 2013-08-31 22:35 @983

otronovato escribiste:Respecto a los usos de index(), m//, etc... ¡Lo fácil que es hacer en Perl un programa que cubra necesidades "sencillas" y lo difícil que es ser capaz de sacarle todo el jugo y hacer un código óptimo!

Es lo mismo que hacer una casa... todos, más o menos, podemos hacernos una casa con ladrillos, y con un solo tipo de ladrillos. Será un poco fea, pero será una casa. Otra cosa es ser profesional del ladrillo, donde uno sabe que existen media docena de tipos de ladrillos.

otronovato escribiste:Entiendo que si trabajara con cadenas muy largas merecería la pena comprobar la velocidad del algoritmo basado en m//g y en relación a la de otro basado en un bucle con index()... ¿Cómo se toma esa decisión? (Entiendo que no es una diferencia crítica para las cadenas de tamaño reducido con las que me muevo ahora mismo... ¿no?).

Sí, bueno, si son pocas ejecuciones, o cadenas pequeñas, no importa la solución que adoptes. Otra cosa es que tengas que procesar archivos log que van registrando actividad de una red de telefonía móvil, y van creciendo a razón de cien mil líneas por segundo. En esos casos, debes usar métodos de Benchmarking. En Perl está el módulo Benchmark, que creo que viene por defecto, con el que se pueden realizar mediciones de tiempo y velocidad de ejecución, para ver qué resultado es el más óptimo según lo que necesitemos.

Esta es mi versión de tu programa, por si te sirve para darte más ideas:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl
use v5.14;
use utf8::all;                  # Turn on UTF-8. All of it.
 
print "Introduce la cadena a considerar: ";
chomp(my $cadena = <STDIN>);
 
my %frecuencias;
 
$frecuencias{ substr $cadena, $_, 3 }++ for 0 .. length($cadena) - 3;
 
my @tríos = sort keys %frecuencias;
 
say 'Hay ', scalar( @tríos ), ' tríos de caracteres, que son: ', join ',', @tríos;
say 'La frecuencia de cada uno de los tríos es:';
say "\tTrío $_ --> $frecuencias{$_}" for @tríos;
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Humm... me estoy dando cuenta de que estoy empezando a abusar del estilo indirecto... Me estaré volviendo vago

por **otronovato** » 2013-09-01 17:47 @783

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

$frecuencias{ substr $cadena, $_, 3 }++ for 0 .. length($cadena) - 3;
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Me lo voy a escribir mil veces, como en el colegio, a ver si así...

Mientras tanto, he desarrollado por mi cuenta dos monstruosidades en forma de funciones que vienen a hacer, seguramente todavía mal, la tarea de esta línea de código. :oops:

Por lo menos, por lo que veo, el problema no se soluciona a través del operador match, cuyas características he estado mirando un buen rato. :lol:

Y lo peor es que, ahora que lo veo, y no es la primera vez... ¡Lo entiendo!

Gracias, explorer.

por **explorer** » 2013-09-01 19:16 @844

En efecto: no es necesario ni el operador de coincidencia ni el index().

El solo hecho de usar el trigrama como clave de un hash, ya nos posiciona en el valor relacionado con ese trigrama, así que solo nos queda sumarle una aparición más.

Es más... ni siquiera hace falta llevar las cuentas de aparición de cada trigrama: si guardamos las posiciones de aparición, eso ya es en sí mismo el número de veces que aparece.

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl
use v5.14;
use utf8::all;                  # Turn on UTF-8. All of it.
 
print "Introduce la cadena a considerar: ";
chomp(my $cadena = <STDIN>);
 
my %frecuencias;
 
for my $i (0 .. length($cadena) - 3) {
    push @{ $frecuencias{substr $cadena, $i, 3} }, $i; 
}
 
use Data::Dumper;
say Dumper \%frecuencias;
 
my @tríos = sort keys %frecuencias;
 
say 'Hay ', scalar( @tríos ), ' tríos de caracteres, que son: ', join ',', @tríos;
say 'La frecuencia de cada uno de los tríos es:';
for (@tríos) {
    my $pos = @{$frecuencias{$_}};
    say "\tTrío $_ --> ", scalar(@pos), " veces, en las posiciones: ", join(',', @pos);
}
__END__
Introduce la cadena a considerar: AAAAAAAACCCCCCCG
$VAR1 = {
          'AAC' => [
                     6
                   ],
          'CCC' => [
                     8,
                     9,
                     10,
                     11,
                     12
                   ],
          'ACC' => [
                     7
                   ],
          'CCG' => [
                     13
                   ],
          'AAA' => [
                     0,
                     1,
                     2,
                     3,
                     4,
                     5
                   ]
        };
 
Hay 5 tríos de caracteres, que son: AAA,AAC,ACC,CCC,CCG
La frecuencia de cada uno de los tríos es:
        Trío AAA --> 6 veces, en las posiciones: 0,1,2,3,4,5
        Trío AAC --> 1 veces, en las posiciones: 6
        Trío ACC --> 1 veces, en las posiciones: 7
        Trío CCC --> 5 veces, en las posiciones: 8,9,10,11,12
        Trío CCG --> 1 veces, en las posiciones: 13
Coloreado en 0.002 segundos,  usando GeSHi 1.0.8.4

por **otronovato** » 2013-09-02 06:39 @318

Evidentemente he optado por tomar el camino correcto, que me mostraste, sin apenas empeñarme en avanzar por el marasmo en que me había metido. Es un logro del que me siento orgulloso. :lol:

De paso he recordado un principio que me enseñaron hace muchos años: "Programa para un caso general". La existencia de una cadena del tipo 'AAAAAAAAGCCCCCC' no se me había pasado por la cabeza. (Y éso que sería una ocasión de primera, una secuencia así en un mensaje, para romper una cifra).

Otra cosa de la que me he percatado es que debo aprender a basar mis programas Perl en estructuras de alto nivel, complejas de entender y utilizar, pero poderosas. Programar como si sólo contara con los recursos básicos de stdio.h en C, es una mala idea.

Y naturalmente tengo unas cuantas preguntas:

La función 'say'. Sé cómo se utiliza, pero depende de use v5.14. ¿Puedo utilizar esa versión sin que haya otro tipo de efectos cruzados que entren en conflicto con otras especificidades del programa?

__END__ y __DATA__

Veo que __END__ simplemente marca el final del programa y no procesa el resto del fichero. Por el contrario, __DATA__ nos permite acceder a esos datos. ¿Pero para qué? ¿Es simplemente otro modo de pasar argumentos al programa?

Data::Dumper. Veo aquí http://perlenespanol.com/tutoriales/cgi ... _perl.html que se utiliza para ver la estructura interna de estructuras de datos complejas, pero que para grabar datos a disco se usa xml, por ejemplo. ¿Se pueden rehacer las estructuras en memoria a partir de su dump?

PS: La función ha quedado así, de manera que genera y procesa grupos de cualquier número de caracteres:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

sub frec_calc{
 
#Recibe una cadena de caracteres con el mensaje y un escalar con el número
#de caracteres de la subcadena a buscar. Retorna un hash con las subcadenas
#y sus posiciones en la cadena principal
 
    my %frecuencias;
    my $cadena = $_[0];
    my $lon_substr = $_[1];
 
    foreach my $i ( 0.. length( $cadena) - $lon_substr){
        push @{ $frecuencias{ substr $cadena, $i, $lon_substr}}, $i; #Gracias a explorer
    }
    return \%frecuencias
}
 
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Resulta que al final es ésta casi la única función que necesito...

por **explorer** » 2013-09-02 12:19 @555

otronovato escribiste:Programar como si sólo contara con los recursos básicos de stdio.h en C, es una mala idea.

Se ve muy claro cuando un programador de C o Java está empezando a programar en Perl... solo viendo que todos los bucles los escriben así:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

my $i;
my @array_aux;
for ($i = 0; $i <= 42; $i++) {
    my $x = $array[$i];
    $array_aux[$i] = $x * 2;
}
@array = @array_aux;
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Cuando pasan a

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

my @array_aux;
for my $i (0 .. 42) {
    my $x = $array[$i];
    $array_aux[$i] = $x * 2;
}
@array = @array_aux;
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

ya sabes que empiezan a soltarse. Y cuando pasan a

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

for my $a (@array) {
    $array_aux[$i] = $a * 2;
}
@array = @array_aux;
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

es que empiezan a entenderlo. Y cuando pasan a

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

push @array_aux, map { $_ * 2 } @array;
@array = @array_aux;
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

hay que empezar a avisarles de que echen el freno. Y sabes que lo han conseguido cuando ves

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

@array = map { $_ * 2 } @array;
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Finalmente, cuando ves

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

for (@array) {
    $_ *= 2;
}
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

es que ya entienden lo que es Perl.

otronovato escribiste:La función 'say'. Sé cómo se utiliza, pero depende de use v5.14. ¿Puedo utilizar esa versión sin que haya otro tipo de efectos cruzados que entren en conflicto con otras especificidades del programa?

La función say() es conocida a partir de la v5.10. La versión mínima recomendada, hoy en día, es la v5.10.1 del 22 de agosto de 2009. La v5.14 salió en mayo del 2011. Yo en casa ya uso la v5.16.2, del 1 de noviembre del 2012. No sé a qué efectos cruzados te refieres. Perl suele ser bastante (extremo) compatible con las versiones anteriores. De hecho, las nuevas características no entran en efecto hasta que pones un 'use v5.10' en la parte de arriba.

otronovato escribiste:Veo que __END__ simplemente marca el final del programa y no procesa el resto del fichero. Por el contrario, __DATA__ nos permite acceder a esos datos. ¿Pero para qué? ¿Es simplemente otro modo de pasar argumentos al programa?

Hay muchas ocasiones en las que un programa debe venir acompañado de una serie de datos, por ejemplo, una relación de constantes físicas, o parámetros de funcionamiento de máquinas, o cadenas de caracteres con claves o nombres o referencias de productos, efemérides de objetos espaciales, documentos de identidad, certificados, claves, fechas... todo ese tipo de cosas, que normalmente pondrías en un archivo aparte, pues Perl te permite meterlo en el mismo código. Así, no tenemos un archivo más, y no se pierde

otronovato escribiste:Data::Dumper. Veo aquí http://perlenespanol.com/tutoriales/cgi ... _perl.html que se utiliza para ver la estructura interna de estructuras de datos complejas, pero que para grabar datos a disco se usa xml, por ejemplo. ¿Se pueden rehacer las estructuras en memoria a partir de su dump?

Depende. Si las estructuras están constituidas de estructuras básicas (escalares, arrays y hash), entonces, sí. Con la función eval{} lo puedes hacer.

El módulo Storable (incluido de base con Perl) tiene un método mejor de persistencia de las variables (busca Persistencia en los foros, para ver ejemplos).

por **otronovato** » 2013-09-02 12:45 @573

Gracias, otra vez.

Estoy trabajando en funciones para realizar distintos tipos de cifrados clásicos, desde el disco de Alberti a Enigma, y poder volcar a fichero los datos de configuración inicial de cada uno de ellos, y recuperarlos, me vendría muy bien. Veo que Storable es sencillo de utilizar, y de paso, ya está inventado. De todos modos, miraré estos días a ver si tengo narices de recuperar un dump mediante eval() como sugieres.

La función say() es conocida a partir de la v5.10. La versión mínima recomendada, hoy en día, es la v5.10.1 del 22 de agosto de 2009. La v5.14 salió en mayo del 2011. Yo en casa ya uso la v5.16.2, del 1 de noviembre del 2012.

Entonces puedo comenzar mis programas con 'use v5.14;' y, sin tener que corregir código ya escrito, puedo acceder a say, por ejemplo, y otras nuevas funciones.

Estoy pensando en terminar las funciones que quiero definir y luego reescribirlas en Perl "de verdad". Tengo curiosidad por ver si me va calando.

por **explorer** » 2013-09-02 16:55 @746

Aparte de eval{}, también se puede hacer con do() (ver perldoc -f do).

Foro - Perl en Español

Sentencia @control=$_[1] =~m/$_/g;

Sentencia @control=$_[1] =~m/$_/g;

Publicidad

Re: Sentencia @control=$_[1] =~m/$_/g;

Re: Sentencia @control=$_[1] =~m/$_/g;

Re: Sentencia @control=$_[1] =~m/$_/g;

Re: Sentencia @control=$_[1] =~m/$_/g;

Re: Sentencia @control=$_[1] =~m/$_/g;

Re: Sentencia @control=$_[1] =~m/$_/g;

Re: Sentencia @control=$_[1] =~m/$_/g;

Re: Sentencia @control=$_[1] =~m/$_/g;

Re: Sentencia @control=$_[1] =~m/$_/g;

¿Quién está conectado?