Hur man skapar en morsekodöversättare med Python

Introduktion till Morsealfabetet

Morsealfabetet är ett system för att överföra meddelanden genom en kombination av punkter, streck och mellanslag. Det används ofta för att förmedla hemliga budskap.

I många filmer har man sett hur morsealfabetet används i marina sammanhang för att kommunicera meddelanden. Det är samma system vi talar om här, men med skillnaden att vi ska skapa ett Python-program för att omvandla text från engelska till morsealfabetet och vice versa.

Vad är Morsealfabetet?

Morsealfabetet har unika mönster för varje bokstav i det engelska alfabetet, siffror, skiljetecken och icke-latinska tecken. När man väl känner till mönstren blir det enkelt att både koda och avkoda dem. Mer information om mönstren finns på Wikipedia-sidan för morsealfabetet.

I den här guiden kommer vi att lära oss hur man konverterar vanlig engelsk text till morsealfabetet och tillbaka. Vi kommer att fokusera på engelska bokstäver, siffror och vanliga skiljetecken. Skulle man vilja lägga till fler tecken, är det lätt att göra efter att man förstått grunderna i kodning och avkodning.

Det är viktigt att notera att både stora och små bokstäver har samma mönster i morsealfabetet. Detta beror på att det huvudsakligen används i kommunikation där skiftläget inte är relevant, som i vardagliga samtal.

Låt oss nu gå in på själva kodningen för att omvandla och avkoda morsealfabetet.

Från Engelska till Morsealfabetet

Algoritmen för att omvandla vanlig engelsk text till morsealfabetet är relativt enkel. Här är stegen vi kommer att följa:

1. Skapa en ordbok (dictionary) som kopplar ihop morsealfabetets mönster med engelska bokstäver, siffror och skiljetecken.
2. Gå igenom texten och lägg till motsvarande morsealfabetmönster för varje tecken till resultatet.
   • I morsealfabetet finns ett mellanslag efter varje tecken och ett dubbelt mellanslag efter varje ord.
   • När vi stöter på ett mellanslag i texten, som fungerar som ordavgränsare, ska vi därför lägga till ett dubbelt mellanslag i resultatet.
3. Den resulterande strängen blir vår omvandlade morsealfabettext.
4. Slutligen, returnera resultatet.

Försök gärna att skriva koden i Python, men oroa dig inte om du inte lyckas helt.

Låt oss nu ta en titt på hur koden ser ut för att omvandla vanlig engelsk text till morsealfabetet:

# ordbok för att koppla tecken till morsealfabetet
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 för att omvandla vanlig engelsk text till morsealfabetet
def to_morse_code(english_plain_text):
    morse_code=""
    for char in english_plain_text:
        # kollar efter mellanslag
        # lägger till ett enkelt mellanslag efter varje tecken och dubbelt mellanslag efter varje ord
        if char == ' ':
            morse_code += '  '
        else:
            # lägger till omvandlad morsealfabetkod till resultatet
            morse_code += CHARS_TO_MORSE_CODE_MAPPING[char.upper()] + ' '
    return morse_code

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

Resultatet av morsekoden visas nedan. Om du kör koden utan att ändra meddelandet, bör du se liknande utdata i din terminal.

--. . . -.- ..-. .-.. .- .-. .   .--. .-. --- -.. ..- -.-. . ...   .... .. --. .... -.-. --.- ..- .- .-.. .. - -.--   - . -.-. .... -. --- .-.. --- --. -.--   .-...   ..-. .. -. .- -. -.-. .   .- .-. - .. -.-. .-.. . ... --..--   -- .- -.- . ...   - --- --- .-.. ... --..--   .- -. -..   .- .--. .. ...   - ---   .... . .-.. .--.   -... ..- ... .. -. . ... ... . ...   .- -. -..   .--. . --- .--. .-.. .   --. .-. --- .-- .-.-.- 

Bra jobbat! Nu har vi genererat morsekoden. Nu vet du vad nästa steg är.

Innan vi går in på avkodningsprogrammet, stanna upp en stund och fundera på hur vi ska skriva koden för att avkoda morsekoden.

…

En av de första sakerna man bör tänka på är att vända på ordlistan CHARS_TO_MORSE_CODE_MAPPING. Att göra detta manuellt är omständligt och kräver uppdatering varje gång den ursprungliga kopplingen ändras. Låt oss skriva kod för att vända ordboken:

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

Denna funktion vänder helt enkelt på nyckel-värdeparen i den givna ordboken. Den resulterande ordboken får de gamla värdena som nya nycklar, och de gamla nycklarna som nya värden.

Nu har vi alla delar vi behöver för att avkoda morsekoden till vanlig engelsk text. Låt oss nu avkoda morsekoden.

Från Morsealfabetet till Engelska

Vi kan vända processen med morsekodning för att skapa en avkodningsalgoritm. Här är stegen vi kommer att följa för att avkoda morsealfabetet till vanlig engelsk text:

1. Vänd på CHARS_TO_MORSE_CODE_MAPPING-ordboken med hjälp av den funktion vi skrev tidigare.
2. Gå igenom morsekoden och håll koll på den aktuella morsekodstecknet.
   • När vi stöter på ett mellanslag, betyder det att vi har ett komplett morsekodstecken som ska avkodas.
     • Om den aktuella morsekoden är tom och vi har två mellanslag i följd, betyder det att vi har ett ordavbrott. Lägg till ett vanligt mellanslag till den resulterande engelska texten.
     • Om villkoret ovan inte uppfylls, hämta motsvarande tecken från den omvända ordboken och lägg till det i resultatet. Återställ den aktuella morsekoden.
   • Om vi inte stöter på ett mellanslag, lägg till det till det aktuella morsekodstecknet.
3. Om det finns ett sista tecken, lägg till det till resultatet efter att ha avkodat det med hjälp av ordboken.
4. Returnera resultatet.

Låt oss ta en titt på koden för ovanstående algoritm:

def reverse_mapping(mapping):
    # lägg till funktionskod från tidigare stycke...
    reversed = {}
    for key, value in mapping.items():
        reversed[value] = key
    return reversed
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': '-----',
    '.': '.-.-.-',
    ',': '--..--',
    '?': '..--..',
    '\'': '.----.',
    '!': '-.-.--',
    '/': '-..-.',
    '(': '-.--.',
    ')': '-.--.-',
    '&': '.-...',
    ':': '---...',
    ';': '-.-.-.',
    '=': '-...-',
    '+': '.-.-.',
    '-': '-....-',
    '_': '..--.-',
    '"': '.-..-.',
    '$': '...-..-',
    '@': '.--.-.',
} # lägg till ordbokens värden 
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:
        # kollar varje tecken
        if morse_code[i] == ' ':
            # kollar efter ord
            if len(current_char_morse_code) == 0 and morse_code[i + 1] == ' ':
                english_plain_text += ' '
                i += 1
            else:
                # lägger till avkodat tecken till resultatet
                english_plain_text += MORSE_CODE_TO_CHARS_MAPPING[
                    current_char_morse_code]
                current_char_morse_code=""
        else:
            # lägger till morsealfabetets tecken till det aktuella tecknet
            current_char_morse_code += morse_code[i]
        i += 1

    # lägger till sista tecknet till resultatet
    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)
  

Jag har matat in morsekoden som genererades av kodningsfunktionen. Om vi kör ovanstående program får vi följande utdata:

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

Notera: Utdata är i stora bokstäver eftersom vi använde stora bokstäver för kartläggningen i ordboken.

Slutsats

Vi har sett att utdata från avkodningsfunktionen är i stora bokstäver. Du kan förbättra programmet genom att bevara skiftläget i den engelska texten. Detta har inget med själva morsealfabetet att göra, eftersom stora och små bokstäver använder samma mönster. Utmana dig själv och testa detta, då det kan vara ett roligt sätt att utveckla dina kodningskunskaper.

Det var allt för den här guiden. Använd de program vi har skrivit nästa gång du stöter på morsealfabetet.

Lycka till med kodningen! 👨‍💻

Du kan också läsa om hur man genererar ett slumpmässigt lösenord i Python.