python2to3

[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...

[BlackJack]

Die ganze Funktion erscheint mir merkwürdig. Was sollen die eckigen Klammern bei der Ersetzung? Gibt die jemand tatsächlich ein, also zum Beispiel 'L[ö]we aus [Ö]sterreich' und die Funktion macht dann 'LÖWE AUS [Ö]STERREICH' daraus‽ Wenn man einfach nur alles in Gross- oder Kleinbuchstaben wandeln möchte, dann reicht es auch tatsächlich mit *Zeichen* zu arbeiten, also `unicode` und `upper()` oder `lower()` aufzurufen:

Code: Alles auswählen

In [68]: print s
Löwe aus Österreich

In [69]: print s.upper()
LÖWE AUS ÖSTERREICH

In [70]: print s.lower()
löwe aus österreich

Das `spelling` aus diesem komischen `privatparam`-Modul ist auch eigenartig. Da könnte man sich mindestens mal an die Konvention halten Konstanten in GROSSBUCHSTABEN zu schreiben.

[Nobuddy]

Hallo Hyperion, hallo BlackJack,
5 Sekunden, hey da habe ich mich ja schon gesteigert, vorher war die Zeit ja noch kürzer.
Nein ehrlich, freue mich über Eure Kritik und daß Ihr mich noch nicht ganz aufgegeben habt!

Daß 'ä, ö, ü' auch bei upper/lower berücksichtigt werden, wußte ich nicht.
Ist ein klarer Vorteil für unicode und kürzt den Code bei 'spellings' erheblich.

Code: Alles auswählen

def spellings(entry):
    if spelling == 1:
        entry = entry.upper()
    elif spelling == 2:
        entry = entry.lower()
    return entry

Mit der Umsetzung der Funktion 'spellings', bin ich nicht ganz glücklich, ist momentan ein Kompromiss.
Ideal bei der Suche wäre die zu durchsuchenden Daten, in Kleinschreibung umzuwandeln. So könnte man die Sucheingabe selbst auch in Kleinschreibung eingeben und müßte nicht überlegen, wie evtl. das Datenoriginal aussieht.
Das lässt sich bestimmt umsetzen, muß mir noch überlegen, wie man das am Einfachsten machen kann.

Beim Stichwort 'Datenstrukturen', habe ich wohl noch einiges zu lernen.
Vielleicht ein kurzes Beispiel dafür?

Die Konstanten bei privatparam.py, habe ich entsprechend geändert (DATAPOOL, HEADINGS, HEADDISTANCE, LISTFILTER, SPELLING).
Das 'komische `privatparam`-Modul', soll dem Benutzer die Möglichkeit geben, gewisse Einstellungen vornehmen zu können.
Der Grund ist der, da ich versuche den Code flexibel zu halten, wäre es unnötig das Modul menu anzufassen.
Ich hoffe, daß die Erklärungen in den DOC-Strings, verständlich sind.

Daß ich noch lange nicht im 'grünen Bereich' bin, ist mir selbst klar.
Ich habe aber zumindest mal die Anzahl der Codezeilen, um einiges reduzieren können und hoffe daß der Code auch ein wenig besser ist.

Nachtrag:
Diese Funktion

Code: Alles auswählen

def fileclean(filename):
    try:
        os.remove(filename)
    except OSError:
        pass

habe ich durch diese Zeile

Code: Alles auswählen

            if os.path.exists(os.path.join(os.getcwd(), chance)):
                os.remove(chance)

in der Funktion 'handle_menu' ersetzt.

[BlackJack]

@Nobuddy: Das ein Pfad existiert heisst nicht, dass man ihn problemlos löschen kann.

[Nobuddy]

@BlackJack: Ich überprüfe ja, ob die Datei 'chance' in diesem Pfad existiert. Ich lösche ja nicht den Pfad sondern die Datei, wenn vorhanden und ich die notwendigen Zugriffsrechte auf diesen Pfad und Datei habe.

Die Funktion spellings habe ich entfernt und in der Funktion 'search_entry' die Suchzeile geändert.
Die Auswahlmöglichkeit bei SPELLING, habe ich so geändert (DOC-String, privatparam.py)

Code: Alles auswählen

:param:SPELLING
0 = Groß-/Kleinschreibung wird beachtet!
1 = groß-/kleinschreibung wird nicht beachtet, alle eingaben erfolgen
    in kleinschreibung!

Jetzt wird nicht mehr die Sucheingabe beeinflusst, sondern direkt in der Suche selbst.

Code: Alles auswählen

def search_entry(menupoint, result):
    entry = input('\nSuchbegriff: ')
    if entry:
        print("\nListe wird nach Suchbegriff durchsucht!")
        if not type(result) == list:
            with open(DATAPOOL, 'r') as infile:
                reader = csv.reader(infile, delimiter="\t", quotechar="^")
                contents = [row for row in reader if any(entry in
                        {0: x, 1: x.lower()}[SPELLING] for x in row)]
        elif type(result) == list:
            contents = [row for row in result if any(entry in
                    {0: x, 1: x.lower()}[SPELLING] for x in row)]

Ich hoffe, daß der Code so einigermaßen für Dich akzeptabel ist.

Ach ja, jetzt habe ich schon 100 Zeilen weniger Code, statt 318 nur noch 218.

[snafu]

Die Idee mit dem Wahrheitswert bei `SPELLING` ist gut. Du kannst es dir aber noch einfacher machen und an der Stelle anstatt eines Wörterbuchs einfach `(x, x.lower())[SPELLING]` verwenden. Denn du brauchst ja grundsätzlich nur ein zwei-elementriges Container-Objekt (Liste, Tupel, Menge, ...) und musst dafür also nicht extra passende Schlüssel anlegen, sondern arbeitest dann einfach auf dem Indexwert.

Den Namen `SPELLING` solltest du übrigens - wie auch viele deiner anderen Bezeichnungen - nochmal überdenken. Was du wahrscheinlich meinst, nennt sich "case-sensitive".

Zudem würde ich von einem Wert "0" erwarten, dass er für "Falsch" steht und von einer "1", dass sie für "Wahr" steht. Bei dir ist es aber umgekehrt.