So erstellen Sie einen Morsecode-Übersetzer mit Python

von

Der Morsecode ist eine Methode zur Verschlüsselung einer Nachricht durch Punkte, Striche und Leerzeichen. Er wird oft verwendet, um Nachrichten geheim zu übertragen.

Vielleicht haben Sie die Anwendung des Morsecodes in maritimen Szenen vieler Filme beobachtet, wo er zur Kommunikation genutzt wird. Wir sprechen hier über denselben Morsecode, der aber hier durch ein Python-Programm in beide Richtungen – vom Englischen zum Morsecode und umgekehrt – übersetzt wird.

Der Morsecode

Der Morsecode verwendet unterschiedliche Muster für jeden Buchstaben des englischen Alphabets, jede Zahl, jedes Satzzeichen und andere nicht-lateinische Symbole. Hat man die Morsecode-Muster für unterschiedliche Symbole gelernt, ist es ein Leichtes, diese zu kodieren und zu dekodieren. Eine ausführliche Liste von Mustern finden Sie auf der Wikipedia-Seite zum Thema Morsecode.

In diesem Tutorial lernen wir, wie man einfachen englischen Text in Morsecode umwandelt und auch wieder zurück. Wir werden uns auf das englische Alphabet, Zahlen und Satzzeichen konzentrieren, wenn wir die Dekodierung programmieren. Wenn Sie weitere Zeichen hinzufügen möchten, ist dies möglich, sobald Sie die Grundlagen der Kodierung und Dekodierung verstanden haben.

Wichtig zu wissen ist, dass sowohl Groß- als auch Kleinbuchstaben im Morsecode dasselbe Muster besitzen. Dies liegt daran, dass der Morsecode hauptsächlich für die Kommunikation verwendet wird, bei der Groß- und Kleinschreibung keine Rolle spielt, wie zum Beispiel in alltäglichen Gesprächen.

Kommen wir nun zum praktischen Teil der Kodierung und Dekodierung.

Von Englisch zu Morsecode

Der Algorithmus zur Umwandlung von reinem englischen Text in Morsecode ist leicht nachvollziehbar. Schauen wir uns den Algorithmus einmal an:

  1. Erstellen Sie ein Wörterbuch, das den Morsecode-Mustern die entsprechenden englischen Buchstaben, Zahlen und Satzzeichen zuordnet.
  2. Gehen Sie den Text Zeichen für Zeichen durch und fügen Sie das entsprechende Morsecode-Muster zum Ergebnis hinzu.
    • Im Morsecode wird nach jedem Zeichen ein Leerzeichen gesetzt und nach jedem Wort ein doppeltes Leerzeichen.
    • Wenn wir also im Text auf ein Leerzeichen stoßen, welches als Trennzeichen für Wörter fungiert, müssen wir dem Ergebnis zwei Leerzeichen hinzufügen.
  3. Die resultierende Zeichenfolge ist der Morsecode, den wir benötigen.
  4. Geben Sie abschließend das Ergebnis aus.

Versuchen Sie, den Code in Python zu verfassen. Keine Sorge, falls Sie es nicht vollständig schaffen.

Betrachten wir nun den Python-Code zur Kodierung von reinem englischen Text in Morsecode:

# Dictionary zur Zuordnung von Zeichen zu Morsecode
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': '-----',
    '.': '.-.-.-',
    ',': '--..--',
    '?': '..--..',
    '\'': '· − − − − ·',
    '!': '− · − · − −',
    '/': '− · · − ·',
    '(': '− · − − ·',
    ')': '− · − − · −',
    '&': '· − · · ·',
    ':': '− − − · · ·',
    ';': '− · − · − ·',
    '=': '− · · · −',
    '+': '· − · − ·',
    '-': '− · · · · −',
    '_': '· · − − · −',
    '"': '· − · · − ·',
    '$': '· · · − · · −',
    '@': '· − − · − ·',
}

# Funktion zur Kodierung von normalem englischen Text in Morsecode
def to_morse_code(english_plain_text):
    morse_code=""
    for char in english_plain_text:
        # Überprüfung auf Leerzeichen
        # Füge ein Leerzeichen nach jedem Zeichen und ein doppeltes Leerzeichen nach jedem Wort hinzu
        if char == ' ':
            morse_code += '  '
        else:
            # Füge den kodierten Morsecode zum Ergebnis hinzu
            morse_code += CHARS_TO_MORSE_CODE_MAPPING[char.upper()] + ' '
    return morse_code

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

Die Morsecode-Ausgabe sehen Sie unten. Sie sollten einen ähnlichen Morsecode in Ihrem Terminal sehen, wenn Sie den Text nicht verändert haben.

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

Sehr gut! Wir haben den Morsecode. Sie wissen, was jetzt kommt.

Bevor wir uns dem Dekodierungsprogramm zuwenden, halten wir einen Moment inne und überlegen, wie wir den Code zur Dekodierung schreiben können.

…

Als einen der Schritte hätten Sie daran denken sollen, das CHARS_TO_MORSE_CODE_MAPPING-Wörterbuch umzukehren. Dies manuell zu tun ist mühsam und muss bei jeder Änderung der ursprünglichen Zuordnung aktualisiert werden. Schreiben wir Code, um das Wörterbuch umzukehren:

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

Der obige Code kehrt die Schlüssel-Wert-Paare des angegebenen Wörterbuchs einfach um. Das resultierende Wörterbuch enthält Werte als neue Schlüssel und Schlüssel als neue Werte.

Wir haben nun alle Bausteine, um den Morsecode in einfachen englischen Text zu dekodieren. Ohne Umschweife, lassen Sie uns den Morsecode entschlüsseln.

Morsecode zu Englisch

Wir können den Prozess der Morsecode-Kodierung umkehren, um den Dekodierungsalgorithmus zu erhalten. Sehen wir uns den Algorithmus zur Dekodierung von Morsecode in normalen englischen Text an:

  1. Kehren Sie das CHARS_TO_MORSE_CODE_MAPPING-Wörterbuch mit der von uns erstellten Hilfsfunktion um.
  2. Iterieren Sie durch den Morsecode und verfolgen Sie das aktuelle Morsecode-Zeichen.
    • Wenn wir auf ein Leerzeichen treffen, bedeutet dies, dass wir ein vollständiges Morsecode-Zeichen zu entschlüsseln haben.
      • Ist das aktuelle Morsecode-Zeichen leer und wir haben zwei aufeinanderfolgende Leerzeichen, fügen Sie ein Worttrennzeichen hinzu, das im reinen englischen Text ein einzelnes Leerzeichen ist.
      • Wenn die obige Bedingung nicht zutrifft, holen Sie sich das dekodierte Zeichen aus dem Wörterbuch und fügen es dem Ergebnis hinzu. Setzen Sie das aktuelle Morsecode-Zeichen zurück.
    • Wenn wir kein Leerzeichen finden, fügen Sie es zum aktuellen Morsecode-Zeichen hinzu.
  3. Wenn es ein letztes Zeichen gibt, fügen Sie es nach der Dekodierung über das Wörterbuch zum Ergebnis hinzu.
  4. Geben Sie am Ende das Ergebnis zurück.

Betrachten wir den Code für den oben genannten Algorithmus:

def reverse_mapping(mapping):
    # Füge den Funktionscode aus dem vorherigen Snippet ein...

CHARS_TO_MORSE_CODE_MAPPING = {} # Füge Wörterbuchwerte ein
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:
        # Überprüfung für jedes Zeichen
        if morse_code[i] == ' ':
            # Überprüfung für ein Wort
            if len(current_char_morse_code) == 0 and morse_code[i + 1] == ' ':
                english_plain_text += ' '
                i += 1
            else:
                # Füge das dekodierte Zeichen zum Ergebnis hinzu
                english_plain_text += MORSE_CODE_TO_CHARS_MAPPING[
                    current_char_morse_code]
                current_char_morse_code=""
        else:
            # Füge das Morsecode-Zeichen zum aktuellen Zeichen hinzu
            current_char_morse_code += morse_code[i]
        i += 1

    # Füge das letzte Zeichen zum Ergebnis hinzu
    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)

Ich habe den Morsecode angegeben, der von der Kodierungsfunktion generiert wird. Wir erhalten die folgende Ausgabe, wenn wir das obige Programm ausführen.

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

Anmerkung: Die Ausgabe erfolgt in englischen Großbuchstaben, da wir das Großbuchstaben-Alphabet für die Zuordnung im Wörterbuch verwendet haben.

Abschließende Worte

Wir haben gesehen, dass die Ausgabe der Dekodierungsfunktion in Großbuchstaben erfolgt. Sie können das Programm verbessern, indem Sie die Ausgabe so gestalten, wie sie zur Eingabezeit war, indem Sie die Groß- und Kleinschreibung des englischen Alphabets beibehalten. Das hat nichts mit dem Morsecode zu tun, da sowohl Groß- als auch Kleinbuchstaben das gleiche Muster haben. Probieren Sie es aus, da Programmieren Spaß macht.

Das war’s für dieses Tutorial. Verwenden Sie die Programme, die wir geschrieben haben, wenn Sie das nächste Mal auf Morsezeichen stoßen.

Viel Spaß beim Programmieren 👨‍💻

Sie können sich auch ansehen, wie Sie in Python ein zufälliges Passwort erstellen.