tebarius/Mysteryhelfer-web
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hex<->dez<->oct<->bin

Browse Source 
tomtom
slash and pipe
This commit is contained in:
Martin Kayser
2025-07-23 11:34:54 +02:00
parent 24de302dfb
commit a76dfde5a4
2 changed files with 128 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
app/app.py
View File

@@ -120,11 +120,29 @@ def auswahl_verarbeiten():
elif auswahl == "Primfaktorenzerlegung":
st.session_state.output_text = tools.primfaktoren(text)
st.session_state.map_data = None
elif auswahl == "REPLACE":
st.session_state.output_text = tools.REPLACE(text)
elif auswahl == "HEX -> DEZ,OCT,BIN":
st.session_state.output_text = tools.hex_to_dez_oct_bin(text)
st.session_state.map_data = None
elif auswahl == "REPLACE":
st.session_state.output_text = tools.REPLACE(text)
elif auswahl == "DEZ -> HEX,OCT,BIN":
st.session_state.output_text = tools.dez_to_hex_oct_bin(text)
st.session_state.map_data = None
elif auswahl == "OCT -> HEX,DEZ,BIN":
st.session_state.output_text = tools.oct_to_hex_dez_bin(text)
st.session_state.map_data = None
elif auswahl == "BIN -> HEX,DEZ,OCT":
st.session_state.output_text = tools.bin_to_hex_dez_oct(text)
st.session_state.map_data = None
elif auswahl == "Text->Tomtom":
st.session_state.output_text = tools.abc_to_tomtom(text)
st.session_state.map_data = None
elif auswahl == "Tomtom->Text":
st.session_state.output_text = tools.tomtom_to_abc(text)
st.session_state.map_data = None
elif auswahl == "Text->Slash and Pipe":
st.session_state.output_text = tools.text_to_slashpipe(text)
st.session_state.map_data = None
elif auswahl == "Slash and Pipe->Text":
st.session_state.output_text = tools.slashpipe_to_text(text)
st.session_state.map_data = None
elif auswahl == "REPLACE":
st.session_state.output_text = tools.REPLACE(text)
@@ -186,11 +204,14 @@ option = st.sidebar.radio("hidden_label",
"ist (n.te) Primzahl?",
"zeige n.te Primzahl",
"Primfaktorenzerlegung",
"",
"",
"",
"",
"",
"HEX -> DEZ,OCT,BIN",
"DEZ -> HEX,OCT,BIN",
"OCT -> HEX,DEZ,BIN",
"BIN -> HEX,DEZ,OCT",
"Text->Tomtom",
"Tomtom->Text",
"Text->Slash and Pipe",
"Slash and Pipe->Text",
"",
),
key='option',

260
app/tools.py
View File

@@ -978,24 +978,17 @@ def primfaktoren(eingabetext):
out += str(z) + ", "
return out[:-2]
'''
def dez_to_hex_oct_bin():
seperator = ("|,", "_", "/", ";", ",")
eingabetext = Eingabe.get(1.0, END)
def dez_to_hex_oct_bin(eingabetext):
seperator = ("|,", "_", "/", ";", ",")
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Dezimal zu HEX, Octal, Binär]
Die eingegebenen dezimalen Ganzzahlen werden in die
entsprechenden hexadezimalen, octalen und binären
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
return ("### Dezimal zu HEX, Octal, Binär\n"
"Die eingegebenen dezimalen Ganzzahlen werden in die entsprechenden hexadezimalen, octalen und "
"binären Zahlen umgerechnet. Als Trennungszeichen zwischen den Zahlen sind folgende Zeichen erlaubt: "
"| , _ / ; , und Leerzeichen. Bei Verwendung von Leerzeichen sollten möglichst nur 1 Leerzeichen "
"zwischen den Zahlen verwendet werden (überzählige Leerzeichen werden sonst als nicht erkannte "
"Zeichen behandelt).")
else:
se = ""
for s in seperator:
@@ -1007,11 +1000,11 @@ Zeichen behandelt).""" + "\n\n")
try:
ausz = int(eingabetext)
except ValueError:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
"re")
return "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
else:
Ausgabe.insert(1.0, "Dez: {0:} HEX:{0:X} OCT:{0:o} BIN:{0:b}\n".format(ausz))
return "Dez: {0:} HEX:{0:X} OCT:{0:o} BIN:{0:b}".format(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
for z in txt:
@@ -1024,36 +1017,25 @@ Zeichen behandelt).""" + "\n\n")
hextxt = hextxt + "{:X}".format(az) + "/"
octtxt = octtxt + "{:o}".format(az) + "/"
bintxt = bintxt + "{:b}".format(az) + "/"
Ausgabe.insert(1.0, bintxt[:-1] + "\n")
Ausgabe.insert(1.0, "BIN:", "bu")
Ausgabe.insert(1.0, octtxt[:-1] + "\n")
Ausgabe.insert(1.0, "OCT:", "bu")
Ausgabe.insert(1.0, hextxt[:-1] + "\n")
Ausgabe.insert(1.0, "HEX:", "bu")
Ausgabe.insert(1.0, deztxt[:-1] + "\n")
Ausgabe.insert(1.0, "DEZ:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")
ausgabetext += f"_Achtung nicht erkannte Zeichen:_ {ignor} \n"
ausgabetext += f"_DEZ:_ {deztxt[:-1]} \n"
ausgabetext += f"_HEX:_ {hextxt[:-1]} \n"
ausgabetext += f"_OCT:_ {octtxt[:-1]} \n"
ausgabetext += f"_BIN:_ {bintxt[:-1]} \n"
return ausgabetext
def hextodezoctbin():
def hex_to_dez_oct_bin(eingabetext):
seperator = ("|,", "_", "/", ";", ",")
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Hexadezimal zu Dezimal, Octal, Binär]
Die eingegebenen hexadezimalen Zahlen werden in die
entsprechenden dezimalen, octalen und binären
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
return ("### Hexadezimal zu Dezimal, Octal, Binär\n"
"Die eingegebenen hexadezimalen Zahlen werden in die entsprechenden dezimalen, octalen und binären "
"Zahlen umgerechnet. Als Trennungszeichen zwischen den Zahlen sind folgende Zeichen erlaubt: "
"| , _ / ; , und Leerzeichen. Bei Verwendung von Leerzeichen sollten möglichst nur 1 Leerzeichen "
"zwischen den Zahlen verwendet werden (überzählige Leerzeichen werden sonst als nicht erkannte "
"Zeichen behandelt).")
else:
se = ""
for s in seperator:
@@ -1065,11 +1047,11 @@ Zeichen behandelt).""" + "\n\n")
try:
ausz = int(eingabetext, 16)
except ValueError:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
"re")
return "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
else:
Ausgabe.insert(1.0, "HEX:{0:X} Dez: {0:} OCT:{0:o} BIN:{0:b}\n".format(ausz))
return "HEX:{0:X} Dez: {0:} OCT:{0:o} BIN:{0:b}".format(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
for z in txt:
@@ -1082,36 +1064,24 @@ Zeichen behandelt).""" + "\n\n")
hextxt = hextxt + "{:X}".format(az) + "/"
octtxt = octtxt + "{:o}".format(az) + "/"
bintxt = bintxt + "{:b}".format(az) + "/"
Ausgabe.insert(1.0, bintxt[:-1] + "\n")
Ausgabe.insert(1.0, "BIN:", "bu")
Ausgabe.insert(1.0, octtxt[:-1] + "\n")
Ausgabe.insert(1.0, "OCT:", "bu")
Ausgabe.insert(1.0, deztxt[:-1] + "\n")
Ausgabe.insert(1.0, "DEZ:", "bu")
Ausgabe.insert(1.0, hextxt[:-1] + "\n")
Ausgabe.insert(1.0, "HEX:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")
ausgabetext += f"_Achtung nicht erkannte Zeichen:_ {ignor} \n"
ausgabetext += f"_HEX:_ {hextxt[:-1]} \n"
ausgabetext += f"_DEZ:_ {deztxt[:-1]} \n"
ausgabetext += f"_OCT:_ {octtxt[:-1]} \n"
ausgabetext += f"_BIN:_ {bintxt[:-1]} \n"
return ausgabetext
def octtohexdezbin():
def oct_to_hex_dez_bin(eingabetext):
seperator = ("|,", "_", "/", ";", ",")
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Octal zu HEX, Dezimal, Binär]
Die eingegebenen octalen Zahlen werden in die
entsprechenden hexadezimalen, dezimalen und binären
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
return ("### Octal zu HEX, Dezimal, Binär\n"
"Die eingegebenen octalen Zahlen werden in die entsprechenden hexadezimalen, dezimalen und binären "
"Zahlen umgerechnet. Als Trennungszeichen zwischen den Zahlen sind folgende Zeichen erlaubt: "
"| , _ / ; , und Leerzeichen. Bei Verwendung von Leerzeichen sollten möglichst nur 1 Leerzeichen "
"zwischen den Zahlen verwendet werden (überzählige Leerzeichen werden sonst als nicht erkannte "
"Zeichen behandelt).")
else:
se = ""
for s in seperator:
@@ -1123,11 +1093,11 @@ Zeichen behandelt).""" + "\n\n")
try:
ausz = int(eingabetext, 8)
except ValueError:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
"re")
return "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
else:
Ausgabe.insert(1.0, "OCT:{0:o} HEX:{0:X} Dez: {0:} BIN:{0:b}\n".format(ausz))
return "OCT:{0:o} HEX:{0:X} Dez: {0:} BIN:{0:b}".format(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
for z in txt:
@@ -1140,36 +1110,24 @@ Zeichen behandelt).""" + "\n\n")
hextxt = hextxt + "{:X}".format(az) + "/"
octtxt = octtxt + "{:o}".format(az) + "/"
bintxt = bintxt + "{:b}".format(az) + "/"
Ausgabe.insert(1.0, bintxt[:-1] + "\n")
Ausgabe.insert(1.0, "BIN:", "bu")
Ausgabe.insert(1.0, deztxt[:-1] + "\n")
Ausgabe.insert(1.0, "DEZ:", "bu")
Ausgabe.insert(1.0, hextxt[:-1] + "\n")
Ausgabe.insert(1.0, "HEX:", "bu")
Ausgabe.insert(1.0, octtxt[:-1] + "\n")
Ausgabe.insert(1.0, "OCT:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")
ausgabetext += f"_Achtung nicht erkannte Zeichen:_ {ignor} \n"
ausgabetext += f"_OCT:_ {octtxt[:-1]} \n"
ausgabetext += f"_HEX:_ {hextxt[:-1]} \n"
ausgabetext += f"_DEZ:_ {deztxt[:-1]} \n"
ausgabetext += f"_BIN:_ {bintxt[:-1]} \n"
return ausgabetext
def bintohexdezoct():
def bin_to_hex_dez_oct(eingabetext):
seperator = ("|,", "_", "/", ";", ",")
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Binär zu HEX, Dezimal, Octal]
Die eingegebenen binären Zahlen werden in die
entsprechenden hexadezimalen, dezimalen und octalen
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
return ("### Binär zu HEX, Dezimal, Octal\n"
"Die eingegebenen binären Zahlen werden in die entsprechenden hexadezimalen, dezimalen und octalen "
"Zahlen umgerechnet. Als Trennungszeichen zwischen den Zahlen sind folgende Zeichen erlaubt: "
"| , _ / ; , und Leerzeichen. Bei Verwendung von Leerzeichen sollten möglichst nur 1 Leerzeichen "
"zwischen den Zahlen verwendet werden (überzählige Leerzeichen werden sonst als nicht erkannte "
"Zeichen behandelt).")
else:
se = ""
for s in seperator:
@@ -1181,11 +1139,11 @@ Zeichen behandelt).""" + "\n\n")
try:
ausz = int(eingabetext, 2)
except ValueError:
Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
"re")
return "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
else:
Ausgabe.insert(1.0, "BIN:{0:b} HEX:{0:X} Dez: {0:} OCT:{0:o}\n".format(ausz))
return "BIN:{0:b} HEX:{0:X} Dez: {0:} OCT:{0:o}".format(ausz)
else:
ausgabetext = ""
txt = eingabetext.split(se)
deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
for z in txt:
@@ -1198,20 +1156,15 @@ Zeichen behandelt).""" + "\n\n")
hextxt = hextxt + "{:X}".format(az) + "/"
octtxt = octtxt + "{:o}".format(az) + "/"
bintxt = bintxt + "{:b}".format(az) + "/"
Ausgabe.insert(1.0, octtxt[:-1] + "\n")
Ausgabe.insert(1.0, "OCT:", "bu")
Ausgabe.insert(1.0, deztxt[:-1] + "\n")
Ausgabe.insert(1.0, "DEZ:", "bu")
Ausgabe.insert(1.0, hextxt[:-1] + "\n")
Ausgabe.insert(1.0, "HEX:", "bu")
Ausgabe.insert(1.0, bintxt[:-1] + "\n")
Ausgabe.insert(1.0, "BIN:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")
ausgabetext += f"_Achtung nicht erkannte Zeichen:_ {ignor} \n"
ausgabetext += f"_BIN:_ {bintxt[:-1]} \n"
ausgabetext += f"_HEX:_ {hextxt[:-1]} \n"
ausgabetext += f"_DEZ:_ {deztxt[:-1]} \n"
ausgabetext += f"_OCT:_ {octtxt[:-1]} \n"
return ausgabetext
def abctotomtom():
def abc_to_tomtom(eingabetext):
alphabet = {"a": "/ ", "b": "// ", "c": "/// ", "d": "//// ", "e": "/\\ ", "f": "//\\ ", "g": "///\\ ",
"h": "/\\\\ ",
"i": "/\\\\\\ ", "j": "\\/ ", "k": "\\\\/ ", "l": "\\\\\\/ ", "m": "\\// ", "n": "\\/// ", "o": "/\\/ ",
@@ -1220,17 +1173,13 @@ def abctotomtom():
"w": "//\\\\ ",
"x": "\\\\// ", "y": "\\/\\/ ", "z": "/\\/\\ "
} # jweils doppelte backslashs da python sonst als versucht Escapecodes draus zu machen \\ = \
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Text zu Tomtom]
Beim Tomtom Code werden die einzelnen Buchstaben durch
Kombinationen von / und \\ dargestellt. Zwischen den
einzelnen Buchstaben steht ein Leerzeichen zwischen Worten
zwei Leerzeichen. Kodiert werden, können nur die
Buchstaben A-Z.""" + "\n\n")
return ("### Text zu Tomtom\n"
"Beim Tomtom Code werden die einzelnen Buchstaben durch Kombinationen von / und \\ dargestellt. "
"Zwischen den einzelnen Buchstaben steht ein Leerzeichen zwischen Worten zwei Leerzeichen. Kodiert "
"werden, können nur die Buchstaben A-Z.")
else:
ausgabetext = ""
atxt = ""
ignor = ""
for b in eingabetext:
@@ -1240,14 +1189,14 @@ Buchstaben A-Z.""" + "\n\n")
ignor = ignor + b + " "
else:
atxt = atxt + alphabet[b.lower()]
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "kodierter Text:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "ignorierte Zeichen:", "re")
ausgabetext += "_ignorierte Zeichen:_ \n"
ausgabetext += ignor + " \n"
ausgabetext += "_kodierter Text:_ \n"
ausgabetext += atxt
return ausgabetext
def tomtomtoabc():
def tomtom_to_abc(eingabetext):
alphabet = {'/': 'A', '//': 'B', '///': 'C', '////': 'D', '/\\': 'E', '//\\': 'F', '///\\': 'G', '/\\\\': 'H',
'/\\\\\\': 'I', '\\/': 'J',
'\\\\/': 'K', '\\\\\\/': 'L', '\\//': 'M', '\\///': 'N', '/\\/': 'O', '//\\/': 'P', '/\\\\/': 'Q',
@@ -1255,16 +1204,12 @@ def tomtomtoabc():
'\\\\/\\': 'T', '\\//\\': 'U', '\\/\\\\': 'V', '//\\\\': 'W', '\\\\//': 'X', '\\/\\/': 'Y',
'/\\/\\': 'Z'
} # jeweils doppelte backslashs da python sonst versucht Escapecodes draus zu machen \\ = \
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Tomtom zu Text]
Beim Tomtom Code werden die einzelnen Buchstaben durch
Kombinationen von / und \\ dargestellt. Zwischen den
einzelnen Buchstaben steht ein Leerzeichen zwischen Worten
zwei Leerzeichen. Kodiert werden, können nur die
Buchstaben A-Z.""" + "\n\n")
return ("### Tomtom zu Text\n"
"Beim Tomtom Code werden die einzelnen Buchstaben durch Kombinationen von / und \\ dargestellt. "
"Zwischen den einzelnen Buchstaben steht ein Leerzeichen zwischen Worten zwei Leerzeichen. Kodiert "
"werden, können nur die Buchstaben A-Z.")
else:
tomtom = eingabetext.replace(" ", " _ ")
tomtom = tomtom.split()
@@ -1276,27 +1221,23 @@ Buchstaben A-Z.""" + "\n\n")
atxt = atxt + "#"
else:
atxt = atxt + alphabet[sign]
Ausgabe.insert(1.0, atxt + "\n")
return atxt
def texttoslashpipe():
def text_to_slashpipe(eingabetext):
alphabet = {"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": "|||| "
} # jweils doppelte backslashs da python sonst versucht Escapecodes draus zu machen \\ = \
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Text zu Slash and Pipe]
Vergleichbar mit dem Tomtom-Code nur das hier für die
Buchstabenkodierung auch der | mit eingesetzt wird.
Zwischen den einzelnen Buchstaben steht ein Leerzeichen
zwischen Worten zwei Leerzeichen.
Kodiert werden, können nur die Buchstaben A-Z.""" + "\n\n")
return ("### Text zu Slash and Pipe\nVergleichbar mit dem Tomtom-Code nur das hier für die Buchstabenkodierung "
"auch | eingesetzt wird. Zwischen den einzelnen Buchstaben steht ein Leerzeichen zwischen Worten zwei "
"Leerzeichen. Kodiert werden, können nur die Buchstaben A-Z.")
else:
ausgabetext = ""
atxt = ""
ignor = ""
for b in eingabetext:
@@ -1306,29 +1247,24 @@ Kodiert werden, können nur die Buchstaben A-Z.""" + "\n\n")
ignor = ignor + b + " "
else:
atxt = atxt + alphabet[b.lower()]
Ausgabe.insert(1.0, atxt + "\n")
Ausgabe.insert(1.0, "kodierter Text:", "bu")
if ignor != "":
Ausgabe.insert(1.0, ignor + "\n")
Ausgabe.insert(1.0, "ignorierte Zeichen:", "re")
ausgabetext += "_ignorierte Zeichen:_ \n"
ausgabetext += ignor + " \n"
ausgabetext += "_kodierter Text:_ \n"
ausgabetext += atxt
return ausgabetext
def slashpipetotext():
def slashpipe_to_text(eingabetext):
alphabet = {'|': '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'}
# jeweils doppelte backslashs da python sonst versucht Escapecodes draus zu machen \\ = \
eingabetext = Eingabe.get(1.0, END)
eingabetext = eingabetext.rstrip()
if eingabetext == "":
Ausgabe.insert(1.0, """HILFE: [Slash and Pipe zu Text]
Vergleichbar mit dem Tomtom-Code nur das hier für die
Buchstabenkodierung auch der | mit eingesetzt wird.
Zwischen den einzelnen Buchstaben steht ein Leerzeichen
zwischen Worten zwei Leerzeichen.
Kodiert werden, können nur die Buchstaben A-Z.""" + "\n\n")
return ("### Slash and Pipe zu Text\nVergleichbar mit dem Tomtom-Code nur das hier für die Buchstabenkodierung "
"auch der | mit eingesetzt wird. Zwischen den einzelnen Buchstaben steht ein Leerzeichen zwischen "
"Worten zwei Leerzeichen. Dekodiert werden, können nur die Buchstaben A-Z.")
else:
tomtom = eingabetext.replace(" ", " _ ")
tomtom = tomtom.split()
@@ -1340,9 +1276,9 @@ Kodiert werden, können nur die Buchstaben A-Z.""" + "\n\n")
atxt = atxt + "#"
else:
atxt = atxt + alphabet[sign]
Ausgabe.insert(1.0, atxt + "\n")
return atxt
'''
def periodensystem():
seperator = ("|,", "_", ".", "-", "/", ";", ",")
pse = {1: "H", 2: "He", 3: "Li", 4: "Be", 5: "B", 6: "C", 7: "N", 8: "O", 9: "F", 10: "Ne", 11: "Na", 12: "Mg",