kenny + primzahlen

app/app.py

@@ -93,11 +93,32 @@ def auswahl_verarbeiten():
     elif auswahl == "BIN->ASCII-Text":
         st.session_state.output_text = tools.bin_to_ascii(text)
         st.session_state.map_data = None
-    elif auswahl == "REPLACE":
+    elif auswahl == "Zahlwortsuche-DE (0-12)":
-        st.session_state.output_text = tools.REPLACE(text)
+        st.session_state.output_text = tools.zahlwortsuche_de(text)
         st.session_state.map_data = None
-    elif auswahl == "REPLACE":
+    elif auswahl == "Zahlwortsuche-EN (0-15)":
-        st.session_state.output_text = tools.REPLACE(text)
+        st.session_state.output_text = tools.zahlwortsuche_en(text)
+        st.session_state.map_data = None
+    elif auswahl == "KENNYspeak kodieren":
+        st.session_state.output_text = tools.kenny_kodieren(text)
+        st.session_state.map_data = None
+    elif auswahl == "KENNYspeak dekodieren":
+        st.session_state.output_text = tools.kenny_dekodieren(text)
+        st.session_state.map_data = None
+    elif auswahl == "KENNYspeak raten":
+        st.session_state.output_text = tools.kenny_raten(text)
+        st.session_state.map_data = None
+    elif auswahl == "Primz.Alpha dekodieren":
+        st.session_state.output_text = tools.primzahlalphabet_dekodieren(text)
+        st.session_state.map_data = None
+    elif auswahl == "ist (n.te) Primzahl?":
+        st.session_state.output_text = tools.primzahlpruefen(text)
+        st.session_state.map_data = None
+    elif auswahl == "zeige n.te Primzahl":
+        st.session_state.output_text = tools.nte_primzahl(text)
+        st.session_state.map_data = None
+    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)
@@ -156,6 +177,15 @@ option = st.sidebar.radio("hidden_label",
                                    "HEX->ASCII-Text",
                                    "DEZ->ASCII-Text",
                                    "Octal->ASCII-Text",
+                                   "Zahlwortsuche-DE (0-12)",
+                                   "Zahlwortsuche-EN (0-15)",
+                                   "KENNYspeak kodieren",
+                                   "KENNYspeak dekodieren",
+                                   "KENNYspeak raten",
+                                   "Primz.Alpha dekodieren",
+                                   "ist (n.te) Primzahl?",
+                                   "zeige n.te Primzahl",
+                                   "Primfaktorenzerlegung",
                                    "",
                                    "",
                                    "",

app/helper.py

@@ -1,4 +1,6 @@
 import math
+from re import match  # für unkennify
+import streamlit as st
 
 # ***recursive quersummenfunktion***
 def q_sum(n):
@@ -20,6 +22,7 @@ def iq_sum(n):
 
 # ***produziert eine Liste mit Primzahlen kleiner als grenze***
 # ***nach dem Prinzip des "Sieb des Eratosthenes"***
+@st.cache_resource
 def primzahlliste(grenze):
     primes = []
     is_prime = [True] * grenze
@@ -36,6 +39,7 @@ def primzahlliste(grenze):
 
 
 # ***alle permutationen generieren***
+@st.cache_resource
 def all_perms(liste):
     if len(liste) <= 1:
         yield liste
@@ -154,3 +158,24 @@ def rwig_to_coords(a, b, c):
                 + (c % 100000 - c % 10000) / 100000000
                 + (b % 100000 - b % 10000) / 1000000000)
     return round(lat, 5), round(lon, 5)
+
+def unkennify(text):
+    # Funktion hier entnommen und angepasst: https://www.namesuppressed.com/software/kenny.py
+    decoded = ''
+    codemap = str.maketrans('MmPpFf', '001122')
+    n_len = len(text)
+    i = 0
+    while i + 3 <= n_len:
+        if match('[MmPpFf]{3,}', text[i:i + 3]):
+            num = int(text[i:i + 3].translate(codemap), 3)  # 'mpf' -> '012' -> 5
+            cypher = chr(num + ord('a'))  # 5 -> 'f'
+            if text[i].isupper():
+                cypher = cypher.upper()
+            decoded = decoded + cypher
+            i = i + 3
+        else:
+            decoded = decoded + text[i]
+            i = i + 1
+    if i < n_len:
+        decoded = decoded + text[i:]
+    return decoded

app/tools.py

@@ -1,3 +1,4 @@
+from itertools import chain
 import helper
 import pandas as pd
 
@@ -674,19 +675,13 @@ def bin_to_ascii(eingabetext):
             ausgabetext += atxt
             return ausgabetext
 
-'''
+def zahlwortsuche_de(eingabetext):
-def zahlwortsuche_de():
-   
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Zahlwortsuche DE 0-12]
+        return ("### Zahlwortsuche DE 0-12\n"
-Diese Funktion versucht deutsche Zahlworte
+                "Diese Funktion versucht deutsche Zahlworte zwischen 0 und 12 in einem Text aufzuspüren. Da alle "
-zwischen 0 und 12 in einem Text aufzuspüren.
+                "Zeichen ignoriert werden, welche keine Buchstaben sind, werden auch Zahlwörter gefunden welche sich "
-Da alle Zeichen ignoriert werden, welche
+                "z.B. über zwei Worte verteilen.")
-keine Buchstaben sind, werden auch Zahlwörter
-gefunden welche sich z.B. über zwei Worte
-verteilen.""" + "\n\n")
     else:
         zahlen = ["null", "eins", "zwei", "drei", "vier", "fünf", "fuenf", "sechs", "sieben", "acht",
                   "neun", "zehn", "elf", "zwölf", "zwoelf", "zwanzig", "hundert", "tausend"]
@@ -711,26 +706,21 @@ verteilen.""" + "\n\n")
             if tt:
                 atxt = atxt + b
         if atxt == "":
-            Ausgabe.insert(1.0, "Leider keine Zahlwörter gefunden!\n", "re")
+            return "Leider keine Zahlwörter gefunden!"
         else:
-            Ausgabe.insert(1.0, ntxt + "\n")
+            ausgabetext = "_Gefundene Zahlwörter:_  \n"
-            Ausgabe.insert(1.0, "Eingangstext:", "bu")
+            ausgabetext += atxt + "  \n"
-            Ausgabe.insert(1.0, atxt + "\n\n")
+            ausgabetext += "_Eingangstext:_  \n"
-            Ausgabe.insert(1.0, "Gefundene Zahlwörter:", "bu")
+            ausgabetext += ntxt
+            return ausgabetext
 
-
+def zahlwortsuche_en(eingabetext):
-def zahlwortsuche_en():
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Zahlwortsuche EN 0-15]
+        return ("### Zahlwortsuche EN 0-15\n"
-Diese Funktion versucht englische Zahlworte
+                "Diese Funktion versucht englische Zahlworte zwischen 0 und 15 in einem Text aufzuspüren. "
-zwischen 0 und 15 in einem Text aufzuspüren.
+                "Da alle Zeichen ignoriert werden, welche keine Buchstaben sind, werden auch Zahlwörter gefunden "
-Da alle Zeichen ignoriert werden, welche
+                "welche sich z.B. über zwei Worte verteilen.")
-keine Buchstaben sind, werden auch Zahlwörter
-gefunden welche sich z.B. über zwei Worte
-verteilen.""" + "\n\n")
     else:
         zahlen = ["eleven", "twelve", "thirteen", "fourteen", "fifteen", "fourty", "sixty", "seventy",
                   "eighty", "ninety", "zero", "one", "two", "three", "four", "five", "six", "seven",
@@ -756,15 +746,15 @@ verteilen.""" + "\n\n")
             if tt:
                 atxt = atxt + b
         if atxt == "":
-            Ausgabe.insert(1.0, "Leider keine Zahlwörter gefunden!\n", "re")
+            return "Leider keine Zahlwörter gefunden!"
         else:
-            Ausgabe.insert(1.0, ntxt + "\n")
+            ausgabetext = "_Gefundene Zahlwörter:_  \n"
-            Ausgabe.insert(1.0, "Eingangstext:", "bu")
+            ausgabetext += atxt + "  \n"
-            Ausgabe.insert(1.0, atxt + "\n\n")
+            ausgabetext += "_Eingangstext:_  \n"
-            Ausgabe.insert(1.0, "Gefundene Zahlwörter:", "bu")
+            ausgabetext += ntxt
+            return ausgabetext
 
-
+def kenny_kodieren(eingabetext):
-def kenny_kodieren():
     alphabet = {"a": "mmm", "b": "mmp", "c": "mmf", "d": "mpm", "e": "mpp", "f": "mpf", "g": "mfm", "h": "mfp",
                 "i": "mff", "j": "pmm", "k": "pmp",
                 "l": "pmf", "m": "ppm", "n": "ppp", "o": "ppf", "p": "pfm", "q": "pfp", "r": "pff", "s": "fmm",
@@ -777,18 +767,12 @@ def kenny_kodieren():
                 "Y": "Ffm", "Z": "Ffp", "Ä": "Mmmmpp",
                 "Ö": "Ppfmpp", "Ü": "Fmfmpp"
                 }
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Kennyspeak codieren]
+        return ("### Kennyspeak kodieren\n"
-Hilfe sie haben Kenny getötet.. ach nee er kann
+                "Hilfe sie haben Kenny getötet.. ach nee er kann ja noch seine unverständlichen m p f -Laute von "
-ja noch seine unverständlichen m p f -Laute von
+                "sich geben und hier geht es darum normalen Text in genau diese Laute umzusetzen, wo jedem Buchstaben "
-sich geben und hier geht es darum normalen
+                "A-Z eine 3 Zeichen-Kombination zugeordnet ist die sich aus m,p,f zusammensetzt.(a=mmm h=mfp x=fpf)")
-Text in genau diese Laute umzusetzen, wo jedem
-Buchstaben A-Z eine 3 Zeichen-Kombination
-zugeordnet ist die sich aus m,p,f 
-zusammensetzt.(a=mmm h=mfp x=fpf)""" + "\n\n")
     else:
         atxt = ""
         for b in eingabetext:
@@ -796,65 +780,34 @@ zusammensetzt.(a=mmm h=mfp x=fpf)""" + "\n\n")
                 atxt = atxt + alphabet[b]
             else:
                 atxt = atxt + b
-        Ausgabe.insert(1.0, atxt + "\n")
+        return atxt
 
-
+def kenny_dekodieren(eingabetext):
-def unkennify(text):
-    # Funktion hier entnommen und angepasst: https://www.namesuppressed.com/software/kenny.py
-    decoded = ''
-    codemap = str.maketrans('MmPpFf', '001122')
-    n_len = len(text)
-    i = 0
-    while i + 3 <= n_len:
-        if match('[MmPpFf]{3,}', text[i:i + 3]):
-            num = int(text[i:i + 3].translate(codemap), 3)  # 'mpf' -> '012' -> 5
-            cypher = chr(num + ord('a'))  # 5 -> 'f'
-            if text[i].isupper():
-                cypher = cypher.upper()
-            decoded = decoded + cypher
-            i = i + 3
-        else:
-            decoded = decoded + text[i]
-            i = i + 1
-    if i < n_len:
-        decoded = decoded + text[i:]
-    return decoded
-
-
-def kenny_dekodieren():
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Kennyspeak decodieren]
+        return ("### Kennyspeak dekodieren\n"
-Wie? Du verstehst Kenny's mpf-Gebrabbel nicht?
+                "Wie? Du verstehst Kenny's mpf-Gebrabbel nicht? Na gut da kann ich helfen!! Nicht kennifiziertes "
-Na gut da kann ich helfen!!
+                "wird unverändert ausgegeben.")
-Nicht kennifiziertes wird unverändert ausgegeben.""" + "\n\n")
     else:
-        Ausgabe.insert(1.0, unkennify(eingabetext) + "\n")
+        return helper.unkennify(eingabetext)
 
-
+def kenny_raten(eingabetext):
-def kenny_raten():
     wbk = {"000": "a", "001": "b", "002": "c", "010": "d", "011": "e", "012": "f", "020": "g", "021": "h",
            "022": "i", "100": "j", "101": "k", "102": "l", "110": "m", "111": "n", "112": "o", "120": "p",
            "121": "q", "122": "r", "200": "s", "201": "t", "202": "u", "210": "v", "211": "w", "212": "x",
            "220": "y", "221": "z"
            }
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [KENNYspeak raten]
+        return ("### KENNYspeak raten\n"
-Diese Funktion dient zum dekodieren von kennyfizierten
+                "Diese Funktion dient zum dekodieren von kennyfizierten Texten, bei denen die 3 Buchstaben mpf "
-Texten, bei denen die 3 Buchstaben mpf vertauscht oder durch
+                "vertauscht oder durch andere Zeichen ersetzt wurden. Hierzu werden vor der Dekodierung die 3 "
-andere Zeichen ersetzt wurden. Hierzu werden vor der
+                "häufigsten Zeichen im Text ermittelt und alle anderen Zeichen entfernt bevor die 6 möglichen "
-Dekodierung die 3 häufigsten Zeichen im Text ermittelt und
+                "Lösungen ausgegeben werden. (Falls zum kodieren die Zahlen 0,1 oder 2 verwendet wurden, werden "
-alle anderen Zeichen entfernt bevor die 6 möglichen Lösungen
+                "sie durch Buchstaben a,b,c.. ersetzt)")
-ausgegeben werden.
-(Falls zum kodieren die Zahlen 0,1 oder 2 verwendet wurden,
-werden sie durch Buchstaben a,b,c.. ersetzt)""" + "\n\n")
     else:
         wtxt = ""
+        ausgabetext = ""
         for b in eingabetext:
             if b == chr(9) or b == chr(32) or b == chr(10):
                 continue  # erstmal leerzeichen, tab, linefeed raus
@@ -886,7 +839,7 @@ werden sie durch Buchstaben a,b,c.. ersetzt)""" + "\n\n")
                             cwtxt = cwtxt.replace(abc3[i], j)
                             abc3[i] = j
                             break
-        for p in all_perms(abc3):
+        for p in helper.all_perms(abc3):
             txt0 = cwtxt.replace(p[0], "0")
             txt1 = txt0.replace(p[1], "1")
             txt2 = txt1.replace(p[2], "2")
@@ -895,25 +848,20 @@ werden sie durch Buchstaben a,b,c.. ersetzt)""" + "\n\n")
                 tri = txt2[i:i + 3]
                 if tri in wbk:
                     atxt = atxt + wbk[tri]
-            Ausgabe.insert(1.0, "{}\n".format(atxt))
+            ausgabetext += f"_{p}_  \n"
-            Ausgabe.insert(1.0, "{}\n".format(p), "bu")
+            ausgabetext += f"{atxt}  \n"
+        return ausgabetext
 
-
+def primzahlalphabet_dekodieren(eingabetext):
-def primzahlalphabet_dekodieren():
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Primzahlalphabet dekodieren]
+        return ("### Primzahlalphabet dekodieren\n"
-Hier können Primzahlen kleiner als 1 Million
+                "Hier können Primzahlen kleiner als 1 Million in Buchstaben umgewandelt werden. Es wird dabei davon "
-in Buchstaben umgewandelt werden. Es wird dabei
+                "ausgegangen, daß den Primzahlen wiederholend die Buchstaben A-Z zugeordnet werden,2=A 3=B 5=C 7=D "
-davon ausgegangen, daß den Primzahlen 
+                "11=E ... 97=Y 101=Z 103=A 107=B ... usw.")
-wiederholend die Buchstaben A-Z zugeordnet
-werden,2=A 3=B 5=C 7=D 11=E.......
-....97=Y 101=Z 103=A 107=B ... usw.""" + "\n\n")
     else:
         grenze = 1000000
-        primes = primzahlliste(grenze)
+        primes = helper.primzahlliste(grenze)
         pdict = {}
         bz = 65
         for p in primes:
@@ -932,14 +880,14 @@ werden,2=A 3=B 5=C 7=D 11=E.......
             try:
                 ausz = int(eingabetext)
             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:
                 if ausz in pdict:
-                    Ausgabe.insert(1.0, pdict[ausz] + "\n")
+                    return pdict[ausz]
                 else:
-                    Ausgabe.insert(1.0, eingabetext + " ist keine Primzahl oder größer als 1 Million!\n")
+                    return eingabetext + " ist keine Primzahl oder größer als 1 Million!"
         else:
+            ausgabetext = ""
             txt = eingabetext.split(se)
             atxt = ""
             ignor = ""
@@ -953,111 +901,84 @@ werden,2=A 3=B 5=C 7=D 11=E.......
                         atxt = atxt + pdict[az]
                     else:
                         ignor = ignor + str(z) + " "
-            Ausgabe.insert(1.0, atxt + "\n")
-            Ausgabe.insert(1.0, "umgewandelte Zahlen:\n", "bu")
             if ignor != "":
-                Ausgabe.insert(1.0, ignor + "\n")
+                ausgabetext += "_ignoriert wurde:_  \n"
-                Ausgabe.insert(1.0, "ignoriert wurde:\n", "re")
+                ausgabetext += ignor + "  \n"
+            ausgabetext += "_umgewandelte Zahlen:_  \n"
+            ausgabetext += atxt
+            return ausgabetext
 
-
+def primzahlpruefen(eingabetext):
-def primzahlpruefen():
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Primzahl prüfen]
+        return ("### Primzahl prüfen\n"
-Für eine eingegebene Zahl wird überprüft,
+                "Für eine eingegebene Zahl wird überprüft, ob es sich um eine Primzahl handelt. Ist die eingegebene "
-ob es sich um eine Primzahl handelt.
+                "Zahl eine Primzahl wird auch informiert, die wievielte Primzahl es ist. Zahlen über 1299709 (der "
-Ist die eingegebene Zahl eine Primzahl
+                "100000. Primzahl) werden abgelehnt.")
-wird auch informiert, die wievielte
-Primzahl es ist.
-Zahlen über 1299709 (der 100000. Primzahl)
-werden abgelehnt.""" + "\n\n")
     else:
         try:
             ausz = int(eingabetext)
         except ValueError:
-            Ausgabe.insert(1.0, "Keine Zahl erkannt!\n", "re")
+            return "Keine Zahl erkannt!"
         else:
             if ausz > 1299709:
-                Ausgabe.insert(1.0,
+                return ("Sorry, aber ich mag nur die ersten 100000 Primzahlen, das sind Zahlen bis maximal "
-                               "Sorry, aber ich mag nur die ersten 100000 Primzahlen,\ndas sind Zahlen"
+                        "1299709 !")
-                               " bis maximal 1299709 !\n", "re")
+            primes = helper.primzahlliste(1299710)
-                return
-            primes = primzahlliste(1299710)
             if ausz not in primes:
-                Ausgabe.insert(1.0, "{} ist keine Primzahl\n".format(ausz))
+                return f"{ausz} ist keine Primzahl"
             else:
-                Ausgabe.insert(1.0, "{} ist die {}. Primzahl\n".format(ausz, primes.index(ausz) + 1))
+                return f"{ausz} ist die {primes.index(ausz) + 1}. Primzahl"
 
-
+def nte_primzahl(eingabetext):
-def nte_primzahl():
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [n.te Primzahl]
+        return ("### n.te Primzahl\n"
-Du willst wissen wie z.B. die 1000. Primzahl lautet,
+                "Du willst wissen wie z.B. die 1000. Primzahl lautet, dann bist du hier genau richtig. Die Funktion "
-dann bist du hier genau richtig.
+                "liefert maximal die 100000. Primzahl.")
-Die Funktion liefert maximal die 100000. Primzahl.
-""" + "\n\n")
     else:
         try:
             ausz = int(eingabetext)
         except ValueError:
-            Ausgabe.insert(1.0, "Keine Zahl erkannt!\n", "re")
+            return "Keine Zahl erkannt!"
+        if ausz > 100000:
+            return "Sorry, aber ich mag nur die ersten 100000 Primzahlen, das sind Zahlen bis maximal 1299709 !"
         else:
-            if ausz > 100000:
+            primes = helper.primzahlliste(1299710)
-                Ausgabe.insert(1.0,
+            return f"Die {ausz}. Primzahl lautet:{primes[ausz - 1]}"
-                               "Sorry, aber ich mag nur die ersten 100000 Primzahlen,\ndas sind Zahlen bis"
-                               " maximal 1299709 !\n", "re")
-                return
-            primes = primzahlliste(1299710)
-            Ausgabe.insert(1.0, "Die {}. Primzahl lautet:{}\n".format(ausz, primes[ausz - 1]))
 
-
+def primfaktoren(eingabetext):
-def primfaktoren():
-    hilfetext = """HILFE: [Primfaktorenzerlegung]
-Für die eingegebene Zahl werden die Primfaktoren ermittelt
-und ausgegeben. Sollte die Zahl einen Primfaktoren haben, welcher
-größer als 100 Millionen ist, wird die Suche abgebrochen, da die
-Suche sonst zu lange dauert.
-Die Funktion läßt sich damit also auch, bei Zahlen kleiner als 200 
-Millionen, dazu benutzen um festzustellen, ob die eingegebene Zahl eine
-Primzahl ist.
-"""
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, hilfetext + "\n")
+        return ("### Primfaktorenzerlegung\n"
+                "Für die eingegebene Zahl werden die Primfaktoren ermittelt und ausgegeben. Sollte die Zahl einen "
+                "Primfaktoren haben, welcher größer als 100 Millionen ist, wird die Suche abgebrochen, da die Suche "
+                "sonst zu lange dauert. Die Funktion läßt sich damit also auch, bei Zahlen kleiner als 200 Millionen, "
+                "dazu benutzen um festzustellen, ob die eingegebene Zahl eine Primzahl ist.")
     else:
         try:
             n = int(eingabetext)
         except ValueError:
-            Ausgabe.insert(1.0, "Es konnte leider keine Zahl erkannt werden.\n", "re")
+            return "Es konnte leider keine Zahl erkannt werden."
-            return
         faktoren = []
         for i in chain([2], range(3, n // 2 + 1, 2)):
             if i > 100000000:
-                Ausgabe.insert(1.0,
+                return ("Sorry, aber die Primfaktorensuche wurde abgebrochen, da mindestens 1 Faktor größer als "
-                               "Sorry, aber die Primfaktorensuche wurde abgebrochen,\nda mindestens 1 Faktor"
+                        "100 Millionen ist.")
-                               " größer als 100 Millionen ist.\n", "re")
-                return
             while n % i == 0:
                 faktoren.append(i)
                 n = n // i
             if i > n:
                 break
-        out = "Die Zahl {} hat folgende Primfaktoren:\n".format(eingabetext)
+        out = f"_Die Zahl {eingabetext} hat folgende Primfaktoren:_  \n"
         if not faktoren:
-            Ausgabe.insert(1.0, "Die Zahl {} ist eine Primzahl!!\n".format(eingabetext))
+            return f"Die Zahl {eingabetext} ist eine Primzahl!!"
         else:
             for z in faktoren:
                 out += str(z) + ", "
-        return Ausgabe.insert(1.0, out[:-2] + "\n")
+        return out[:-2]
-
 
+'''
 def deztohexoctbin():
     seperator = ("|,", "_", "/", ";", ",")