· 

PYTHON im NATO-Alphabet BUCHSTABIEREN lassen

Hotel, Alfa, Lima, Lima, Oscar. Und damit herzlich Willkommen zu diesem Artikel. Ich habe dir soeben das erste Wort meiner Begrüßung im NATO-Alphabet buchstabiert. Und genau um dieses Alphabet soll es in diesem Artikel gehen. Ich erkläre dir, wofür es gedacht ist, wie man darin buchstabiert und wie man sich mit Google Text-to-Speech (gTTS) in Python ein Programm schreiben kann, das einen eingegebenen Text im NATO-Alphabet vorliest.


Das NATO-Alphabet

Zunächst klären wir aber die Frage, was das NATO-Alphabet überhaupt ist. Es handelt sich um einen international anerkanntes Funkalphabet, das von Amateurfunkern, der Bundeswehr und den NATO-Partnern für den Sprechfunk eingesetzt wird. Primäre Anwendungsgebiete sind der Funk, Flug- und Schifffahrtsverkehr. 

Schön und gut, doch wieso behilft man sich nicht einfach mit eigenen Wortkreationen, wie

Hans

Andreas

Lukas

Lukas

Otto? 

Nun, das liegt auf der Hand: Bestimmte Wörter, die man ja eigentlich nur zum Verbalisieren des Anfangsbuchstabens verwendet, klingen in manchen Sprachen anders als in anderen. Wenn man undeutlich spricht und den Begriff Lotto verwendet, um den Buchstaben L per Sprechfunk zu übertragen, könnte es aufgrund von Störungen passieren, dass das "L" verschluckt wird und man dann versehentlich "Otto" (also "O") auf der anderen Seite versteht. Um solche phonetischen Verwechslungen zu minimieren, hat man das NATO-Alphabet so konzeptioniert, dass auch beim Verschlucken einzelner Bestandteile aus dem Rest immer noch rekonstruieren kann, welcher Buchstabe eigentlich gemeint war, ohne sie mit anderen zu verwechseln. Praktisch, oder? Wir haben mit dem NATO-Alphabet also einen robusten Code. Zudem hat es den Vorteil, dass man bei einem Standard eine gemeinsame Sprache spricht und man keine Denkzeit dafür verschwenden muss zu überlegen, was für ein Wort man z. B. für das X verwendet ... neben Xylophon oder CHYLOPHON oder XEILOPHONE oder RRYLOPHON fielen einem bestimmt noch weitere Verbalisierungen dieses Wortes in anderen Sprachen ein, was potentiell Verwirrungen auf der anderen Seite stiftet. Beim NATO-Alphabet weiß jeder, dass man mit X-RAY das X meint.

 

Schauen wir uns nun einmal die einzelnen Buchstaben samt ihren Repräsentanten im NATO-Alphabet an. Danach programmieren wir das Python-Skript, das diese Übersetzungsarbeit zukünftig für uns übernimmt.

 

A – ALPHA

B – BRAVO

C – CHARLIE

D – DELTA

E – ECHO

F – FOXTROT

G – GOLF

H – HOTEL

I – INDIA

J – JULIETT

K – KILO

L – LIMA

M – MIKE

N – NOVEMBER

O – OSCAR

P – PAPA

Q – QUEBEC

R – ROMEO

S – SIERRA

T – TANGO

U – UNIFORM

V – VICTOR

W -WHISKEY

X – XRAY

Y – YANKEE

 

Z – ZULU


Implementierung

Nachdem du nun das NATO-Alphabet kennengelernt hast, programmieren wir uns im nächsten Schritt ein Python-Skript, das einen gegebenen Text ins NATO-Alphabet übersetzen und auch aufsagen kann. Dieses Programm könntest du dann bspw. dazu nutzen, um das NATO-Alphabet zu lernen.

Zunächst benötigen wir einige Bibliotheken, die wir uns via PIP herunterladen. Diese sind 

gtts (also Google Text-to-Speech), pyttsx3 und playsound, womit wir Sound-Dateien über Python ausgeben lassen können. Wir importieren in unser Programm gtts und von playsound importieren wir uns playsound. Für die Implementierung brauchen wir später außerdem regex und time.

import gtts, re, time
from playsound import playsound

Beachte, dass es bei der Verwendung der Google Text-to-Speech API Beschränkungen bei der Anzahl an Zeichen gibt und du dir nach dem Aufbrauchen des kostenfreien Zeichenkontingents entsprechende Kapazitäten nachkaufen musst. Informationen dazu kannst du dir ergoogeln.

 

Als erstes definieren wir uns ein Dictionary alphabet, das die Buchstaben als Schlüssel und die Aussprache im NATO-Alphabet in Textform als Wert erhält.

alphabet = {
   "a" : "alfa",
   "b" : "bravo",
   "c" : "charlie",
   "d" : "delta",
   "e" : "echo",
   "f" : "foxtrot",
   "g" : "golf",
   "h" : "hotel",
   "i" : "india",
   "j" : "juliett",
   "k" : "kilo",
   "l" : "lima",
   "m" : "mike",
   "n" : "november",
   "o" : "oscar",
   "p" : "papa",
   "q" : "quebec",
   "r" : "romeo",
   "s" : "sierra",
   "t" : "tango",
   "u" : "uniform",
   "v" : "victor",
   "w" : "whiskey",
   "x" : "x-ray",
   "y" : "yankee",
   "z" : "zulu"
}

Wir werden mithilfe von Google Text-to-Speech die Aussprache jedes einzelnen Buchstabens im NATO-Alphabet als separate MP3-Datei speichern. Dazu schreiben wir eine Funktion generate_alphabet.

def generate_alphabet():

In einer for-Schleife laufen wir über alle Buchstaben in unserem Alphabet-Dictionary und rufen auf ggts den Konstruktor gTTS auf. Diesem übergeben wir den Wert des jeweiligen Schlüssels in unserem Dictionary, also die rechte Seite (hinter dem Doppelpunkt). Das soll unser Programm später sagen. Wir speichern mithilfe der Methode save, der wir den Dateinamen übergeben, die Sprachausgabe der Google API als .mp3-Datei. 

   for letter in alphabet:
      gtts.gTTS(alphabet[letter]).save("sounds/" + letter + ".mp3")

Die Datei heißt einfach so wie der jeweilige Buchstabe. Da wir so 26 einzelne Dateien erzeugen, speichern wir sie aus Gründen der Übersichtlichkeit in einem Ordner sounds. Für das y erhalten wir dann z. B. YANKEEE und für das u UNIFORM.

 

Jetzt definieren wir uns eine Funktion spell_letters, die einen Text erhält, dessen einzelnen Buchstaben im NATO-Alphabet übertragen werden sollen.

def spell_letters(msg):

Zuerst bereinigen wir den eingegebenen Text aber, indem wir auf Regex die Funktion sub aufrufen. Wir sorgen dafür, dass alles bis auf Groß-, Kleinbuchstaben  und Leerzeichen entfernt wird. Dahinter steckt die Idee, dass wir Kommata, Doppelpunkte, Semikola etc. nicht im NATO-Alphabet verbalisieren können. Um die einzelnen Buchstaben der bereinigten Nachricht später suchen zu können, verwenden wir noch die Funktion lower, die alles in Kleinbuchstaben umwandelt (denn unsere Schlüssel im alphabet-Dictionary sind schließlich Kleinbuchstaben).

   msg = re.sub("[^a-zA-Z ]+", "", msg).lower()

Nun gehen wir nacheinander alle Buchstaben unserer Nachricht durch. Wenn wir ein Leerzeichen erwischen (und also zwischen zwei Wörtern befinden) bauen wir eine einsekündige Pause ein, um anzudeuten, dass nun ein neues Wort beginnt. Andernfalls rufen wir die Funktion playsound auf und suchen in unserem sounds-Ordner nach dem entsprechenden Buchstaben, der gerade in der for-Schleife eingelesen wurde. 

   for letter in msg:
      if letter == " ":
         time.sleep(1)
      else:
         playsound("sounds/" + letter + ".mp3")

Quellcode

Hier kannst du dir den gesamten Quellcode des Python-Programms kostenlos herunterladen bzw. kopieren.

# pip3 install gTTS pyttsx3 playsound
import gtts, re, time
from playsound import playsound

alphabet = {
   "a" : "alfa",
   "b" : "bravo",
   "c" : "charlie",
   "d" : "delta",
   "e" : "echo",
   "f" : "foxtrot",
   "g" : "golf",
   "h" : "hotel",
   "i" : "india",
   "j" : "juliett",
   "k" : "kilo",
   "l" : "lima",
   "m" : "mike",
   "n" : "november",
   "o" : "oscar",
   "p" : "papa",
   "q" : "quebec",
   "r" : "romeo",
   "s" : "sierra",
   "t" : "tango",
   "u" : "uniform",
   "v" : "victor",
   "w" : "whiskey",
   "x" : "x-ray",
   "y" : "yankee",
   "z" : "zulu"
}

def generate_alphabet():
   for letter in alphabet:
      gtts.gTTS(alphabet[letter]).save("sounds/" + letter + ".mp3")
        
def spell_letters(msg):
   msg = re.sub("[^a-zA-Z ]+", "", msg).lower()
   for letter in msg:
      if letter == " ":
         time.sleep(1)
      else:
         playsound("sounds/" + letter + ".mp3")

def generate_nato(msg):
   msg = re.sub("[^a-zA-Z ]+", "", msg).lower()
   res = ""
   for letter in msg:
      if letter == " ":
         res += "... "
      else:
         res += alphabet[letter] + " "
   return res

def spell_text(msg):
   gtts.gTTS(text=generate_nato(msg)).save("yyy.mp3")
    
print(generate_nato("Das freut mich wirklich sehr Doppelpunkt Klammer zu"))