Comment créer un traducteur de code morse en utilisant Python

Le code morse est une méthode d'encodage d'un message à l'aide de points, tiretset espaces. Il est largement utilisé pour communiquer des messages en secret.

Vous avez peut-être vu l'utilisation du code morse dans les scènes de la marine de nombreux films pour communiquer des messages. Nous parlons ici du même code morse mais la seule différence est que nous allons écrire un programme Python pour traduire de l'anglais au code morse et vice versa.

A propos du code Morse

Le code morse a des motifs différents pour chaque alphabet anglais, chaque chiffre, chaque ponctuation et chaque caractère non latin. Une fois que vous connaissez les modèles de code morse pour les différents caractères, il vous sera facile de les coder et de les décoder. Vous pouvez vous référer à Page Wikipédia du code morse pour plus de détails et de modèles.

Dans ce tutoriel, nous allons apprendre à coder un texte anglais en code morse et vice versa. Nous utiliserons les alphabets anglais, les chiffres et la ponctuation lors de l'encodage et du décodage. Si vous souhaitez ajouter d'autres types de caractères, vous pourrez facilement le faire une fois que vous aurez appris les bases de l'encodage et du décodage.

Une chose à retenir est que les alphabets majuscules et minuscules ont le même modèle de code morse. En effet, le code morse est principalement utilisé pour la communication qui ne tient pas compte des majuscules et des minuscules, comme c'est le cas dans les conversations quotidiennes.

Passons à la partie codage pour l'encodage et le décodage.

De l'anglais au code morse

L'algorithme permettant de convertir un texte anglais en code morse est simple. Vérifions l'algorithme.

Créez un dictionnaire avec les correspondances entre les motifs du code morse et les alphabets anglais, les chiffres et les ponctuations.
Il parcourt le texte et ajoute au résultat le motif de code morse de chaque caractère du texte.
- Le code morse contient un espace après chaque caractère et un double espace après chaque mot.
- Ainsi, lorsque nous rencontrons un espace dans le texte, qui est le séparateur de mots, nous devons ajouter un double espace au résultat.
La chaîne résultante sera le code morse dont nous avions besoin.
Enfin, renvoyer le résultat.

Essayez d'écrire le code en Python. Ne vous inquiétez pas, même si vous n'arrivez pas à l'écrire complètement.

Vérifions le code permettant d'encoder un texte anglais en code morse.

# dictionary for mapping characters to morse code
CHARS_TO_MORSE_CODE_MAPPING = {
    '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': '--..',
    '1': '.----',
    '2': '..---',
    '3': '...--',
    '4': '....-',
    '5': '.....',
    '6': '-....',
    '7': '--...',
    '8': '---..',
    '9': '----.',
    '0': '-----',
    '.': '.-.-.-',
    ',': '--..--',
    '?': '..--..',
    '\'': '· − − − − ·',
    '!': '− · − · − −',
    '/': '− · · − ·',
    '(': '− · − − ·',
    ')': '− · − − · −',
    '&': '· − · · ·',
    ':': '− − − · · ·',
    ';': '− · − · − ·',
    '=': '− · · · −',
    '+': '· − · − ·',
    '-': '− · · · · −',
    '_': '· · − − · −',
    '"': '· − · · − ·',
    '$': '· · · − · · −',
    '@': '· − − · − ·',
}

# function to encode plain English text to morse code
def to_morse_code(english_plain_text):
    morse_code = ''
    for char in english_plain_text:
        # checking for space
        # to add single space after every character and double space after every word
        if char == ' ':
            morse_code += '  '
        else:
            # adding encoded morse code to the result
            morse_code += CHARS_TO_MORSE_CODE_MAPPING[char.upper()] + ' '
    return morse_code

morse_code = to_morse_code(
    'Geekflare produces high-quality technology & finance articles, makes tools, and APIs to help businesses and people grow.'
)
print(morse_code)

Vous pouvez voir le code morse ci-dessous. Vous devriez également voir un code morse similaire dans votre terminal si vous n'avez pas modifié le message.

--. . . -.- ..-. .-.. .- .-. .   .--. .-. --- -.. ..- -.-. . ...   .... .. --. .... − · · · · − --.- ..- .- .-.. .. - -.--   - . -.-. .... -. --- .-.. --- --. -.--   · − · · ·   ..-. .. -. .- -. -.-. .   .- .-. - .. -.-. .-.. . ... --..--   -- .- -.- . ...   - --- --- .-.. ... --..--   .- -. -..   .- .--. .. ...   - ---   .... . .-.. .--.   -... ..- ... .. -. . ... ... . ...   .- -. -..   .--. . --- .--. .-.. .   --. .-. --- .-- .-.-.-

Hourra ! Nous avons le code morse. Vous savez ce qui vient après.

Avant de nous lancer dans le programme de décodage, arrêtons-nous un instant et réfléchissons à la manière d'écrire le code pour le décoder.

…

Vous auriez dû penser à inverser la CHARS_TO_MORSE_CODE_MAPPING comme l'une des étapes. Le faire manuellement est fastidieux et doit être mis à jour chaque fois que le mappage d'origine est modifié. Ecrivons un code pour inverser le dictionnaire.

def reverse_mapping(mapping):
    reversed = {}
    for key, value in mapping.items():
        reversed[value] = key
    return reversed

Nous inversons simplement les paires clé-valeur du dictionnaire donné avec le code ci-dessus. Le dictionnaire résultant contiendra des valeurs comme nouvelles clés et des clés comme nouvelles valeurs.

Nous disposons de tous les éléments pour décoder le code morse en texte clair. Sans plus attendre, décodons le code morse.

Code morse vers l'anglais

Nous pouvons inverser le processus d'encodage du code morse pour obtenir l'algorithme de décodage. Voyons l'algorithme de décodage du code morse en texte anglais clair.

Inverser la CHARS_TO_MORSE_CODE_MAPPING à l'aide de la fonction util que nous avons écrite.
Itère sur le code morse et garde trace du caractère de code morse actuel.
- Si nous rencontrons un espace, cela signifie que nous avons un caractère morse complet à décoder.
  - Si le caractère morse actuel est vide et qu'il y a deux espaces consécutifs, il faut ajouter un séparateur de mots qui est un espace simple dans un texte en anglais.
  - Si la condition ci-dessus est fausse, le caractère décodé est extrait du dictionnaire et ajouté au résultat. Réinitialiser le caractère de code morse actuel.
- Si nous n'avons pas rencontré d'espace, ajoutez-le au caractère morse actuel.
Si le dernier caractère existe, il est ajouté au résultat après décodage à l'aide du dictionnaire.
Renvoyer le résultat à la fin.

Vérifions le code de l'algorithme ci-dessus.

def reverse_mapping(mapping):
    # add function code from the previous snippet...

CHARS_TO_MORSE_CODE_MAPPING = {} # add dictionary values 
MORSE_CODE_TO_CHARS_MAPPING = reverse_mapping(CHARS_TO_MORSE_CODE_MAPPING)

def to_english_plain_text(morse_code):
    english_plain_text = ''

    current_char_morse_code = ''
    i = 0
    while i < len(morse_code) - 1:
        # checking for each character
        if morse_code[i] == ' ':
            # checking for word
            if len(current_char_morse_code) == 0 and morse_code[i + 1] == ' ':
                english_plain_text += ' '
                i += 1
            else:
                # adding decoded character to the result
                english_plain_text += MORSE_CODE_TO_CHARS_MAPPING[
                    current_char_morse_code]
                current_char_morse_code = ''
        else:
            # adding morse code char to the current character
            current_char_morse_code += morse_code[i]
        i += 1

    # adding last character to the result
    if len(current_char_morse_code) > 0:
        english_plain_text += MORSE_CODE_TO_CHARS_MAPPING[
            current_char_morse_code]

    return english_plain_text

english_plain_text = to_english_plain_text(
    '--. . . -.- ..-. .-.. .- .-. .   .--. .-. --- -.. ..- -.-. . ...   .... .. --. .... − · · · · − --.- ..- .- .-.. .. - -.--   - . -.-. .... -. --- .-.. --- --. -.--   · − · · ·   ..-. .. -. .- -. -.-. .   .- .-. - .. -.-. .-.. . ... --..--   -- .- -.- . ...   - --- --- .-.. ... --..--   .- -. -..   .- .--. .. ...   - ---   .... . .-.. .--.   -... ..- ... .. -. . ... ... . ...   .- -. -..   .--. . --- .--. .-.. .   --. .-. --- .-- .-.-.- '
)
print(english_plain_text)

J'ai donné le code morse généré par la fonction d'encodage. Nous obtiendrons le résultat suivant si nous exécutons le programme ci-dessus.

GEEKFLARE PRODUCES HIGH-QUALITY TECHNOLOGY & FINANCE ARTICLES, MAKES TOOLS, AND APIS TO HELP BUSINESSES AND PEOPLE GROW.

Remarque : le résultat est en majuscules anglaises car nous avons utilisé l'alphabet majuscule pour le mappage dans le dictionnaire.

Dernières paroles

Nous avons vu que la sortie de la fonction de décodage est en majuscules. Vous pouvez améliorer le programme en rendant la sortie telle qu'elle est dans le temps imparti en suivant les majuscules et les minuscules de l'alphabet anglais. Cela n'a rien à voir avec le code morse, car les majuscules et les minuscules ont le même schéma. Essayez-le, c'est plus amusant de coder.

C'est tout pour ce tutoriel. Utilisez les programmes que nous avons écrits lorsque vous rencontrerez le code morse la prochaine fois.

Bon codage 👨‍💻

Vous pouvez maintenant voir comment créer un mot de passe aléatoire en Python.

Consultez également les documents suivants Traducteurs de l'anglais vers le code morse.