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": elif auswahl == "Primfaktorenzerlegung":
st.session_state.output_text = tools.primfaktoren(text) st.session_state.output_text = tools.primfaktoren(text)
st.session_state.map_data = None st.session_state.map_data = None
elif auswahl == "REPLACE": elif auswahl == "HEX -> DEZ,OCT,BIN":
st.session_state.output_text = tools.REPLACE(text) st.session_state.output_text = tools.hex_to_dez_oct_bin(text)
st.session_state.map_data = None st.session_state.map_data = None
elif auswahl == "REPLACE": elif auswahl == "DEZ -> HEX,OCT,BIN":
st.session_state.output_text = tools.REPLACE(text) 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 st.session_state.map_data = None
elif auswahl == "REPLACE": elif auswahl == "REPLACE":
st.session_state.output_text = tools.REPLACE(text) st.session_state.output_text = tools.REPLACE(text)
@@ -186,11 +204,14 @@ option = st.sidebar.radio("hidden_label",
"ist (n.te) Primzahl?", "ist (n.te) Primzahl?",
"zeige n.te Primzahl", "zeige n.te Primzahl",
"Primfaktorenzerlegung", "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', key='option',

260
app/tools.py
View File

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