python2to3

[BlackJack]

@Nobuddy: Sachliche Kritik: OMG ist das wieder ein gruseliger Code, bei dem man gar nicht weiss wo man anfangen soll. Anregung: Lass das mit dem Programmieren lieber sein. SCNR

[EyDu]

Das war sachliche Kritik. Warum noch einmal alles hinschreiben, wenn die Hinweise eh schon im ganzen Thread verteilt sind?

[Nobuddy]

Unter sachlicher Kritik verstehe ich, z.B. Zeile 102 bis 120 geht einfacher, schau Dir mal die xyz-Methode an, evtl. ein kleines Beispiel dazu (wie es mach Andere hier machen).

Ich sehe auch keinen Grund, das Programmieren sein zu lassen.
Es gibt für jede Umsetzung, bestimmt mehrere Möglichkeiten, so daß unter Euch 'Profiś' der Code auch nicht immer gleich ist.
Euer Vorteil ist wohl (trifft bestimmt nicht auf alle zu), eine gezielte schulische Laufbahn absolviert zu haben, welches Euch heute ermöglicht, die Dinge so zu sehen und zu verstehen. Es gibt aber auch Ausnahmen, die das Glück nicht hatten (bitte kein Mitleid). Aber haben die nicht auch das Recht, sich Ihre Ziele zu stecken und zu verwirklichen?
Keine Angst, ich werde nie mich beruflich zum Programmiere orientieren, dafür bin ich einfach schon zu alt und habe ein gesundheitliches Handicap.

[deets]

Das Problem mit sachlicher Kritik an deinem Code ist: sie verhallt nahezu ungehoert, bestenfalls verbessert sie eine Kleinigkeit fuer einen kurzen Moment, aber sofort verfaellst du wieder in alte Muster.

Und *das* ist das Problem. Es ist ok, von niedrigem Niveau zu starten. Und auch die Geschwindigkeit, in der man Fortschritte macht mag mal mehr, mal weniger hoch sein. Aber langsam kristallisiert sich eben heraus, dass es nichts fruchtet, deinen Code wieder und wieder mit denselben Problemen zu betrachten und dazu etwas auszufuehren.

Anders gesagt: du hast das Recht, zu programmieren was & wie du willst. Und wir haben das Recht, nichts dazu zu sagen

[snafu]

Nochmal was Konkretes zum Code: Guck dir unbedingt mal `range()` bzw `xrange()` (unter Python 2.x) an. Das erspart dir diese umständlichen "while-True-counter-+=1" Schleifen. Du gibst `range()` einfach einen Zielwert mit. `range()` fängt dann bei 0 an, zu zählen und hört auf, wenn es den Zielwert sieht. Dieser letzte Wert kommt nicht mehr in die Zählung rein. D.h. an Stellen, wo du ein `if counter == len(xyz) - 1: break` machst, kannst du es ersetzen durch ein `for index in range(len(xyz)):`. Wenn du bevorzugt `counter` statt `index` oder `i` verwendest, dann mach es halt so.

Im Übrigen ist selbst dies in Python eigentlich ein Anti-Pattern. Man iteriert bevorzugt über die Objekte an sich, anstatt eine Zählervariable zu benutzen - also: `for obj in xyz:`. Am Besten organisierst du deinen Code so um, dass du möglichst auf jegliche Counter verzichten kannst. Ausgenommen davon ist das Mitzählen von Zeilennummern via `enumerate()` (und wahrscheinlich noch ein paar andere Anwendungsfälle). Manchmal geht es halt nicht anders.

Und bitte überlege dir doch mal, ob du für wiederkehrende Aufgaben nicht doch lieber Hilfsfunktionen einführen möchte. Das würde den Quelltext wesentlich aufgeräumter erscheinen lassen und es macht damit meist mehr Spass, den Code zu lesen. Treffendere Funktionsbenennungen wären übrigens auch schön. Eine Funktion sollte idealerweise genau *einen* Handgriff (also eine Teilaufgabe) erledigen. Das fehlt mir bei dir noch viel zu sehr.

Und ohne dir jetzt groß was erzählen zu wollen, aber du musst nicht (übertrieben gesagt) dreimal am Tag eine neue Version deines Code abliefern. Man kann auch ruhig mal für längere Zeit daran herumschrauben und es *dann* präsentieren. Außer natürlich, du hast tatsächlich den Eindruck, dass jede von dir abgelieferte Version in etwa den Stand deiner aktuellen Fähigkeiten wiederspiegelt.

Ich persönlich mag es auch nicht so sehr, wenn die hier mitschreibenden Anfänger einen (bzw das Forum) zu sehr als eine Art Mentor ansehen. Nachfragen auf einem völlig neuem Gebiet sind ja nicht das Problem, aber etwas Eigeninitiative (vor allem in Form von eigener Recherche) sollte schon drin sein. Ich will nicht sagen, dass ich nicht auch mal klein angefangen hab und auch nicht den Eindruck vermitteln, dass Fragen von Anfängern grundsätzlich zu dumm sind, als dass sie hier gestellt werden dürften (auf dass sich am Ende keiner mehr traut, den Mund aufzumachen), aber ab einem gewissen Punkt, geht man - guter Wille hin oder her - den Leuten zunehmend auf die Nerven.

Eine gute Herangehensweise wäre es wohl, wenn du uns nicht einfach Code zum Fraß vorwirfst, sondern konretere Fragen zu bestimmten Code-Stücken stellst. Aber ich gebe zu, das ist manchmal sehr leicht dahergeredet. Gewissermaßen muss bei dir erst noch eine Art Knoten platzen, aber ich könnte diesen Knoten nicht mal präzise beschreiben. Oder wie man ihn zum Platzen bringt. Ich weiß nur, dass sehr viele Leute diesen Knoten irgendwann nicht mehr haben. Und diejenigen, die ihn nicht loswerden können, hören vermutlich irgendwann mit dem Programmieren auf...

[Nobuddy]

Hallo snafu,
Danke für Deine Unterstützung und Deinem Input!

Die '.join()'-Methode vereinfacht vieles, werde mir das genauer anschauen und zukünftig dieses Werkzeug verwenden.
Das mit meinem 'counter', hat mich selbst sehr gestört, da ist die 'range'-Methode wirklich das richtige Instrument.
Da ich in Python3 jetzt programmiere, gibt es 'xrange' nicht mehr, nur noch 'range'.
Mit 'range' konnte ich den Code deutlich vereinfachen und benötige 'counter' nicht mehr!
Beispiel:

Code: Alles auswählen

        # Maximale Zeichenbreite von resmax mit headmax vergleichen
        rowmax = dict()
        for i in range(len(headmax)):
            if headmax[i] and i == 0:
                rowmax[i] = headmax[i] + 4
            elif headmax[i] and i > 0:
                rowmax[i] = max(headmax[i], resmax[i - 1]) + 4

        headline = list()
        for i in range(len(headinfo)):
            if i == 0:
                headline.append((headinfo[0] + ': ').rjust(rowmax.get(i)))
            else:
                headline.append(headinfo[i].ljust(rowmax.get(i)))
        separateline = (sum([rowmax.get(i) for i in range(len(rowmax))]) - 2) * '-'
        headprint = '\n'.join([separateline, ('').join(headline), separateline])

        # Index erstellen und zeilenweise einlesen der einzelnen Spalten
        # Zuweisen der maximalen Zeichenbreite für Printausgabe.
        # Einheitliches, spaltenbezogenes Printlayout
        dataline = dict()
        printline = list()
        for index, row in enumerate(result):
            data = list()
            printdata = list()
            data.append(index + 1)
            printdata.append((str(index + 1) + ': ').rjust(rowmax.get(0)))
            printdata.append(row[0].ljust(rowmax.get(1)))
            for i in range(1, len(row)):
                data.append(row[i])
                if rowmax.get(i + 1):
                    printdata.append(row[i].ljust(rowmax.get(i + 1)))
            dataline[data[0]] = [row[0:]]
            printline.append(printdata)

Bei 'Hilfsfunktionen für wiederkehrende Aufgaben', daran muß ich noch arbeiten.
Vielleicht kannst Du mir ein Beispiel nennen, welches Du als 'wiederkehrende Aufgaben' betrachtest?
Sehe manchmal den Wald vor lauter Bäumen nicht ....

Nachtrag: Warte mal ab, mir ist da ein Licht aufgegangen!

Das mit den vielen Versionen in kurzer Zeit, ist wirklich nicht gut und ich denke, daß dies Eure Bemühungen auch sehr strapaziert. Daher ist es vernünftig, zielgerichtet mit einzelnen Codestücken zu arbeiten. Da fällt es dann auch Euch leichter, mich zu unterstützen.

Ich werde mich zukünftig bemühen, zielgerichtet meine Fragen zu stellen und vorher mehr nach eigenen Lösungen suchen.
Mit meinem Handicap mit der englischen Sprache, scheitere ich oft an der Python-Basisinformation.
Deutschsprachige Tutorials, sind oft auf das wesentliche beschränkt.
Vielleicht könnt Ihr mir da ein deutschsprachige Buch zu Python3 empfehlen, welches alles oder zumindest vieles beinhaltet?

[jens]

Bei der zweiten Schreife benutzt du enumerate(), warum nicht auch in der ersten?

und man kann enumerate auch einen startwert mitgeben, dann kannst du dir die vielen +1 sparen. Schau mal in die Doku.

[Nobuddy]

Hallo jens,
bei der ersten for-Schleife, sehe ich im Moment noch keinen Vorteil, ob ich range oder enumerate benutze.
Bei der zweiten for-Schleife, ermittle ich zeilenweise die Spalten und erstelle eine Spalte in der die maximale Zeichenbreite der jeweiligen Spalte zugewiesen wird. Dabei wird bei der Spalte 0 angefangen, die sich aber vom Layout zu den weiteren Spalten nicht identisch ist. Daher verwende ich auch range für die Spalten ab 1.

Vielleicht habe ich Dich auch nicht richtig verstanden und Du doch recht hast, bitte ich Dich etwas das konkreter darzulegen.

[BlackJack]

Die Frage ist eher warum `rowmax` ein Wörterbuch ist, denn da werden aufsteigende Indizes auf Werte abgebildet. Also eigentlich eine Aufgabe für eine Liste.

[snafu]

Du denkst immer noch viel zu kompliziert. Der Sinn deiner Funktion scheint ja zu sein, die Spaltenbreiten so anzupassen, dass sie ausreichend Platz für das größte Element einer Spalte bieten, eingeschlossen der Überschrift. Wieso dann also nicht einfach die Überschrift bei der Ermittlung des Maximums mit reinnehmen? Denn die Überschriften bilden im Grunde ja auch nur eine eigene Zeile. Sähe dann in etwa so aus:

Code: Alles auswählen

lines = [headings] + results
column_widths = [max(len(item) for item in column_items) for column_items in zip(*lines)]

Schon hast du die Bestimmung der Spaltenbreiten fertig.

Und dann hatte ich ja bei meinen Erklärungen zum String-Formatting schon anklingen lassen, dass sich "Schablonen" auch anfertigen lassen, ohne dass schon konkret ein String eingefügt werden muss. Kann man mithilfe von `.join()` für einen Spaltenabstand von 4 Einheiten in etwa so machen:

Code: Alles auswählen

>>> template = (4 * ' ').join('{{:{}}}'.format(width) for width in column_widths)
>>> template
'{:12}    {:14}    {:10}'

Das von mir erzeugte Template hat also aufgrund des jeweils längsten Elementes die maximalen Spaltenbreiten 12, 14 und 10. Der Zwischenraum für den Spaltenabstand wird bei mir einfach dazugesetzt. Dank `.join()` taucht er nur dort auf, wo er auch hin soll.

Abschließend setze ich noch die Strings ein, wieder mittels Unpacking:

Code: Alles auswählen

print '\n'.join(template.format(*line_items) for line_items in lines)

Und schon habe ich nett untereinander geordnete Spaltenelemente, ohne einen einzigen Indexzähler.

Der Ansatz hat zwar im Detail noch ein paar Schwächen, aber im Großen und Ganzen sollte die Grundidee der Aufgabe auf diesem Weg mit relativ wenig Code gelöst worden sein.

[Nobuddy]

Die Frage ist eher warum `rowmax` ein Wörterbuch ist, denn da werden aufsteigende Indizes auf Werte abgebildet. Also eigentlich eine Aufgabe für eine Liste.

'rowmax' ist spaltengebunden, daher habe ich gemeint, daß ein Dictionary am besten dafür geeignet ist.

Code: Alles auswählen

rowmax[spalte] = MaxZeilenbreite

[snafu]

Mal eine Zwischenfrage. Soll die Ausgabe nach wie vor in dieser Form sein:

Code: Alles auswählen

Nr.: 1, py2: Tkinter,            py3: tkinter,                  info: Namensänderung von Modul Tkinter, neuer Modulnamen ist tkinter. Statt 'from Tkinter import tkinter' gilt nun 'import tkinter'
Nr.: 2, py2: tkFont,             py3: tkinter.font,             info: Namensänderung von Modul tkFont, neuer Modulnamen ist tkinter.font
Nr.: 3, py2: tkMessageBox,       py3: tkinter.messagebox,       info: Namensänderung von Modul tkMessageBox, neuer Modulnamen ist tkinter.messagebox
Nr.: 4, py2: tkSimpleDialog,     py3: tkinter.simpledialog,     info: Namensänderung von Modul tkSimpleDialog, neuer Modulnamen ist tkinter.simpledialog

Oder hat sich die Anforderung geändert? Ich blicke nämlich inzwischen nicht mehr so recht durch, auf was du genau hinaus willst...

Zeig doch mal ein Muster von der Ausgabe, die du (momentan) erwartest.

[Nobuddy]

snafu, nein nicht in dieser Form, sondern so:

Code: Alles auswählen

Die Suche ergab folgende Ergebnisse:
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  Nummer: Python2           Python3                 Info                                                                                                                             
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
       1: Tkinter           tkinter                 Namensänderung von Modul Tkinter, neuer Modulnamen ist tkinter. Statt 'from Tkinter import tkinter' gilt nun 'import tkinter'    
       2: tkFont            tkinter.font            Namensänderung von Modul tkFont, neuer Modulnamen ist tkinter.font                                                               
       3: tkMessageBox      tkinter.messagebox      Namensänderung von Modul tkMessageBox, neuer Modulnamen ist tkinter.messagebox                                                   
       4: tkSimpleDialog    tkinter.simpledialog    Namensänderung von Modul tkSimpleDialog, neuer Modulnamen ist tkinter.simpledialog                                               
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Dieses Format funktioniert gut und ist schön übersichtlich.
Bei größeren Datenmengen in der Ausgabe, habe ich mir schon überlegt, z.B. ca. alle 10 bis 20 Zeilen, die Kopfzeile einzufügen, damit man immer die Spaltenbenennung vor Augen hat. Das ist für mich kein Problem, das bekomme ich schon hin.
Wo ich mir auch Gedanken gemacht habe, z.B. bei der letzten Spalte.
Nehmen wir einmal an, daß es in dieser Spalte eine Zeile gibt, bei der ein oder sogar mehrmals ein automatischer Zeilenumbruch notwendig ist. So kann das Gesamtformat etwas unübersichtlich werden.
Hier wäre es ideal, wenn der Zeilenumbruch nur innerhalb der Format-Spalte sich abspielen würde.
Weiter wäre es auch ideal, die maximale Fensterbreite des aktiven Konsolen/Terminal-Fensters zu ermitteln, um evtl. so das Ausgabeformat immer beibehalten zu können.
Aber ob dies überhaupt möglich wäre, entzieht sich meiner Kenntnis.

Es hat sich inzwischen, Dank Eures Input schon einiges getan.
Ich poste mal hier ein Auszug meiner Fortschritte, denkt aber nicht daß ich damit schon komplett fertig bin!

Code: Alles auswählen

def maxsign(headlist, datalist):
    headmax = ([max(len(item) for item in column_items) for column_items in zip(*headlist)])
    resmax = ([max(len(item) for item in column_items) for column_items in zip(*datalist)])

    # Maximale Zeichenbreite von resmax mit headmax vergleichen
    rowmax = dict()
    for i in range(len(headmax)):
        if headmax[i] and i == 0:
            rowmax[i] = headmax[i] + 4
        elif headmax[i] and i > 0:
            rowmax[i] = max(headmax[i], resmax[i - 1]) + 4
    return rowmax


def headline(rowmax):
    headlist = list()
    for i in range(len(headinfo)):
        if i == 0:
            headlist.append((headinfo[0] + ': ').rjust(rowmax.get(i)))
        else:
            headlist.append(headinfo[i].ljust(rowmax.get(i)))
    separateline = (sum([rowmax.get(i) for i in range(len(rowmax))]) - 2) * '-'
    headprint = '\n'.join([separateline, ('').join(headlist), separateline])
    return separateline, headprint


def selection(menupoint, result):
    if result:
        # Maximale Zeichenbreite
        rowmax = maxsign([headinfo], result)

        # Kopfzeile
        separateline, headprint = headline(rowmax)

        # Index erstellen und zeilenweise einlesen der einzelnen Spalten
        # Zuweisen der maximalen Zeichenbreite für Printausgabe.
        # Einheitliches, spaltenbezogenes Printlayout
        dataline = dict()
        printline = list()
        for index, row in enumerate(result):
            data = list()
            printdata = list()
            data.append(index + 1)
            printdata.append((str(index + 1) + ': ').rjust(rowmax.get(0)))
            printdata.append(row[0].ljust(rowmax.get(1)))
            for i in range(1, len(row)):
                data.append(row[i])
                if rowmax.get(i + 1):
                    printdata.append(row[i].ljust(rowmax.get(i + 1)))
            dataline[data[0]] = [row[0:]]
            printline.append(printdata)

        if len(result) == 1:
            print("\nDie Suche ergab folgendes Ergebnis:")
        else:
            print("\nDie Suche ergab folgende Ergebnisse:")

        # Ausgabe Konsole/Terminal
        print(headprint)
        for row in printline:
            print(''.join(row))
        print(separateline)

Da gibt es noch einiges für zu tun, hoffe aber daß dieser Code Euch schon ein bisschen näher kommt.

Bitte wartet noch ein wenig ab, möchte Euren Input aus den letzten Postś, soweit ich kann umsetzten!

[snafu]

Ah, jetzt verstehe ich, wieso du diese Sonderbehandlung bei der ersten Spalte hast. Der Text soll dort rechtsbündig erscheinen und in den anderen Spalten linksbündig. Das ist aber auch eine Sache, die wesentlich leichter zu lösen ist. Pythons String-Formatting bietet auch für eine rechtsbündige Ausrichtung eine spezielle Syntax. Ich muss jetzt gleich weg, werde dir am späteren Abend mal etwas dazu posten...

Aber ich will dir trotzdem mal für die Zukunft Slicing vorschlagen. Wenn du z.B. das erste Element einer Liste überspringen willst, dann geht das so:

Code: Alles auswählen

>>> items = "foo bar baz spam ham egg".split()
>>> items
['foo', 'bar', 'baz', 'spam', 'ham', 'egg']
>>> for item in items[1:]:
...     print item
... 
bar
baz
spam
ham
egg

Die Angabe vor dem Doppelpunkt ist der Start-Index (denke daran, dass Position = Index + 1) und hinter dem Doppelpunkt kann optional der End-Index folgen. Lässt man diese Angabe weg (so wie ich es getan habe), dann wird die Liste bis zum letzten Element durchlaufen.

Um jetzt vorher etwas mit dem ersten Element zu machen, genügt ein `items[0] = "was-auch-immer"`.

[Nobuddy]

snafu, bevor Du los legst, poste ich den aktuellen Stand meines Codes, damit Du nicht mit altem Code von mir herum hantierst!
https://gist.github.com/3516212

In privatparam.py habe ich die Spalte 'Nummer' herausgenommen, da der Benutzer nur hier bestimmte Parameter wie Datenquelle und Spaltenbenennung der Kopfzeile ändern soll.
Die Spalte 'Nummer' ist ja ein fester Bestandteil der Kopfzeile, dies habe ich in python2to3.py in die Funktion 'head()' gepackt.
In der Funktion 'selection(menupoint, result)' in python2to3.py, die gerade aktuell in Bearbeitung ist, habe ich ein paar Dinge in Funktionen ausgelagert und optimiert.

Mehr jetzt mal nicht, um Dich nicht aus dem Konzept zu bringen.

[snafu]

Hab jetzt einfach mal die komplette Formatierungs-Funktionalität geschrieben. Aufgrund der speziellen Anforderungen, die du an die Ausgabe stellst, sind es doch ein paar Zeilen mehr geworden. Manches kann man vermutlich noch besser machen, aber ich hoffe trotzdem, den Quelltext etwas verständlicher für die Allgemeinheit hinbekommen zu haben: https://gist.github.com/3527463

Wie du siehst, habe ich den Info-Text bei den Testdatensätzen stark gekürzt, damit das schon von dir genannte Problem der Überlänge nicht auftritt. Wobei man auch hier sein Terminal-Fenster im Vollbildmodus laufen lassen sollte.

Eine Implementierung mit passendem Zeilenumbruch kommt dann in der nächsten Maus (irgendwann).

//edit: MIr wird gerade bewusst, für die Leerzeilen hätte man genau so gut ein simples "\n" nehmen können...

[Nobuddy]

Hallo snafu,
boah ... da hast Du Dich aber ins Zeug gelegt, den Code muß ich erst mal in Ruhe studieren und testen.
Jetzt merke ich erst, in welchen Sphären Ihr schwebt, wenn ich Deinen Code so anschaue.
Kein Wunder, daß ich da immer einen auf den Deckel bekomme ...

Das mit den Leerzeilen und dem '\n', da hättest Du mich fragen können.

Ich war auch aktiv und habe an meinem Code weiter geschraubt.
Auch wenn dieser sich nicht mit Deinem Code vergleichen lässt, funktioniert er doch recht gut.
Ich habe diesen noch an einigen Stellen weiter gekürzt und mit zwei Funktionen erweitert.
- weitere Filtermöglichkeit der Suchergebnisse
Das ist besonders für mich wichtig, da ich als mit großen Datenmengen arbeite und ein Mehrfachfilter hier von Vorteil ist.
- Definition der Sucheingabe, berücksichtigen von Groß-/Kleinschreibung, oder die Umwandlung der Sucheingabe in Groß- oder Kleinbuchstaben
Da ich viel auch mit Dateien arbeite, wo nur Großschreibung besteht, ist dann das Arbeiten etwas einfacher. Ich gebe 'a' ein und 'A' wird gesucht.
Mit dieser Lösung, bin ich allerdings nicht ganz so glücklich. Besser wäre hier, wenn bei der Suche selbst Groß-/Kleinschreibung nicht berücksichtigt würde, also 'a = A, ä = Ä, ... usw.'
- Wiederholen der Kopfzeile alle x-Zeilen
Gerade bei größeren Datenmengen übersichtlicher.

Auch wenn mein Code nicht zu empfehlen ist, könnt Ihr Euch ein Bild machen, wie ich das eine oder andere (mit meinen Möglichkeiten) umgesetzt habe. https://gist.github.com/3531055

[Nobuddy]

Hallo snafu,
habe Deinen Code getestet, läuft wirklich prima.

Zum Testen, habe ich diesen Bereich für mich angepasst, um Suchergebnisse zu erhalten.

Code: Alles auswählen

def test():
    headings = headinfo
    entry = input('\nSuchbegriff: ')
    if entry:
        with open(datapool, 'r') as infile:
            reader = csv.reader(infile, delimiter="\t", quotechar="^")
            contents = [row for row in reader if any(entry in x for x in row)]
    if contents:
        print(get_formatted_table(headings, contents))

Werde Deinen Code noch weiter studieren, da noch nicht alles klar für mich ist.
Danach werde ich meine alten Code durch diesen ersetzen.

[Nobuddy]

Sodele, Dank snafuś Input der mich insperiert hat, habe ich meinen Code überarbeitet und ziemlich gekürzt.
Dabei habe ich dier Funktion 'get_formatted_table' von snafu, mit leichten Änderungen übernommen.

Poste hier mal die aktuelle Version: https://gist.github.com/3554990

Ich hoffe mal, daß für Euch meine Bemühungen, ein bisschen sichtbar sind.
Für Kritik und weiteren Input von Euch, freue ich mich!

[Hyperion]

5 Sekunden drauf geguckt und das hier gefunden:

Code: Alles auswählen

def spellings(entry):
    if spelling == 1:
        entry = entry.upper()
        entry = entry.replace('[ä]', 'Ä')
        entry = entry.replace('[ö]', 'Ö')
        entry = entry.replace('[ü]', 'Ü')
    elif spelling == 2:
        entry = entry.lower()
        entry = entry.replace('[Ä]', 'ä')
        entry = entry.replace('[Ö]', 'ö')
        entry = entry.replace('[Ü]', 'ü')
    return entry

Das geht doch auch eleganter... Stichwort Datenstrukturen! Im Moment reines Copy&Paste...