22 nov 2010

Conversor de código Morse a texto en Python

Vamos a implementar una función llamada Demorse() de modo que cumpla con los siguientes requisitos:

Esta función se encargará de abrir un archivo existente con la extensión *.mrs, leer su contenido, traducirlo del código Morse y almacenar el resultado en un archivo nuevo que tenga el mismo nombre pero con la extensión *.txt



Condiciones:
  • El archivo origen debe existir y debe tener la extensión *.mrs.
  • Al ejecutar la función le pasaremos el nombre del archivo origen como parámetro.
  • La función creará el archivo nuevo con la extensión *.txt.
  • Los caracteres del código Morse serán líneas "-" y puntos ".".
  • Para poder diferenciar unas letras de otras se han añadido espacios en blanco después de cada letra del código Morse.
  • Junto los caracteres del código Morse se ha almacenado la información necesaria para identificar las letras mayúsculas.
  • Se deben respetar los espacios y los saltos de carro del archivo original

Propuesta:

F.3.1 Primera propuesta del código del programa.
 Descripción línea a línea de la propuesta para Demorse()
  1. Definimos la función e indicamos que habrá una parámetro de entrada.
  2. Si el nombre del archivo no termina en .mrs ...
  3.    ... le añadimos la extensión al nombre que nos han pasado por parámetro.
  4. Abrimos el archivo en modo lectura y lo asignamos a la variable origen.
  5. Calculamos la distancia a la que se encuentra el punto en el nombre del archivo, ya necesitamos el mismo nombre para el archivo de salida.
  6. Empezamos a construir el nombre del fichero que vamos a generar para almacenar el código descifrado. Sólo copiamos el nombre sin la extensión.
  7. Le añadimos la extensión .txt al nombre del archivo de salida.
  8. Abrimos el archivo de salida en modo escritura "a"
  9. Creamos un diccionario llamado nm donde le añadimos las claves y los valores correspondientes al código Morse.
  10. Para cada linea extraída del archivo de lectura ...
  11. ... vaciamos tres variables: líneadesalida: La vamos a utilizar para ir almacenando los caracteres hasta que se complete una línea. al empezar una línea nueva vaciamos su contenido. mayusculas: A medida que vayamos leyendo caracteres de la palabra mayu, las almacenamos en esta variable. letra: para almacenar los puntos y guiones hasta ea encontrar un espacio, es decir, hasta formar una letra.
  12. ... ponemos dos variables a 0, es decir, a falso: mayu: si cuando terminamos una letra la variable es verdadera ==1, hay que escribirla en mayúsculas. haciendoletra: Si estamos haciendo una letra y encontramos un espacio sabremos que dicho espacio significa el final de la letra, que no hay que escribirlo en la salida.
  13. para cada letra de la línea ...
  14. ... si se trata de una 'm', 'a', 'y' o una 'u'.
  15. ... ... añadimos el carácter a la variable mayusculas.
  16. ... ... si ya tenemos el texto completo en mayusculas ...
  17. ... ... ... activamos mayu. Ya sabemos que la próxima letra que venga la tendremos que escribir en mayúsculas.
  18. ... ... ... y vaciamos la variable mayusculas
  19. ... si se trata de un punto o de un guión...
  20. ... ... agregamos el símbolo a la letra.
  21. ... ... y reafirmamos que estamos haciendo una letra.
  22. ... si se trata de un espacio y estamos haciendo una letra y tenemos la marca mayu activada ...
  23. ... ... añadimos a la linea de salida lo que ya tenia + el simbolo correspondiente del diccionario en mayúsculas.
  24. ... ... borramos variables.
  25. ... ... borramos variables.
  26. ... si se trata de un espacio y estamos haciendo una letra y tenemos la marca mayu desactivada ...
  27. ... ... añadimos a la linea de salida lo que ya tenia + el simbolo correspondiente del diccionario .
  28. ... ... borramos variables
  29. ... ... borramos variables
  30. ... si no se trata de ninguna de las otras condiciones es que estamos antes una vocal acentuada, salto de carro, ...
  31. ... ... añadimos a la linea de salida lo que ya tenia + la letra tal cual la hemos leído.
  32.  ... ... borramos variables
  33. ... ... borramos variables
  34. Ya hemos leido todas las letras de una línea. Escribimos la linea entera en el archivo de salida.
  35. Cerramos el archivo de lectura.
  36. Cerramos el archivo de escritura.
Código para copiar:

#!/usr/bin/env python

def Demorse(nombre):                #1
    if not(nombre.endswith(".mrs")):    #2
        nombre = nombre+".mrs"        #3
    origen=open(nombre,"r")            #4
    pospunto = nombre.find('.')        #5
    nombresalida = nombre[:pospunto]    #6
    nombresalida = nombresalida+'.txt'    #7
    destino = open(nombresalida,"a")    #8
    nm = {'.-': 'a','-...': 'b','-.-.': 'c','-..': 'd','.': 'e','..-.': 'f',
        '--.': 'g','....': 'h','..': 'i','.---': 'j','-.-': 'k','.-..': 'l',
        '--': 'm','-.': 'n','---': 'o','.--.': 'p','--.-': 'q',    '.-.': 'r',
        '...': 's','-': 't','..-': 'u','...-': 'v','.--': 'w','-..-': 'x',
        '-.--': 'y','--..': 'z','-----': '0','.----': '1','..---': '2',
        '...--': '3','....-': '4','.....': '5','-....': '6','--...': '7',
        '---..': '8','----.': '9','.-.-.-': '.','--..--': ',',
        '..--..': '?','.-..-.': '\"','----------': '-',}        #9

    for linea in origen.readlines():        #10
        lineasalida = mayusculas = letra = ''    #11
        mayu = haciendoletra = 0        #12
        for i in linea:                #13
            if i=='m' or i=='a' or i=='y' or i=='u': #14
                mayusculas = mayusculas+i    #15
                if mayusculas == 'mayu':    #16
                    mayu=1            #17
                    mayusculas=''        #18
            elif i=='.' or i=='-':            #19
                letra=letra+i            #20
                haciendoletra=1            #21
            elif i==' ' and haciendoletra and mayu==1:        #22
                lineasalida = lineasalida+nm[letra].upper()    #23
                haciendoletra = mayu = 0            #24
                letra=''                    #25
            elif i==' ' and haciendoletra and mayu==0:        #26
                lineasalida = lineasalida+nm[letra]        #27
                haciendoletra=0                    #28
                letra=''                    #29
            else:                            #30
                lineasalida = lineasalida + i            #31
                haciendoletra = mayu = 0            #32
                mayusculas = letra = ''                #33
        destino.write(lineasalida)    #34
    origen.close()                #35
    destino.close()                #36


Muestra:

Al  introducir el texto generado con la función Morse() en la segunda entra de este blog se ha generado un archivo con el mismo contenido que teníamos antes de convertirlo por primera vez. 

Todos los programas contenidos en este blog han sido probados, pero podrían existir errores no detectados, se pueden mejorar para que funcionase de un modo más eficiente y elegante.

Os dejo este texto por si quereis descifrarlo con Demorse():

mayu.... .-  ... .. -.. ---  ..- -.  .--. .-.. .- -.-. . .-.  .... .- -... . .-.  -.-. --- -. ... . --. ..- .. -.. ---  . .-..  --- -... .--- . - .. ...- ---  .--. .-. --- .--. ..- . ... - --- .-.-.-  mayu. -.  . ... - .  -.-. .- ... ---  ... .  - .-. .- - .- ...- .-  -.. . :
.---- º) mayu.--. .- ... .- .-.  ..- -.  - . -..- - ---  .-  mayu-- --- .-. ... . .-.-.-
..--- º) mayu...- --- .-.. ...- . .-.  .-  .-. . -.-. ..- .--. . .-. .- .-.  . .-..  - . -..- - ---  --- .-. .. --. .. -. .- .-.. .-.-.-




Un saludo,
Luis

    No hay comentarios:

    Publicar un comentario