Python Programm (Liste)

[criscros]

Hallo ihr lieben,
Ich habe ein kleines Problem beim Programmieren.
Ich möchte ein Programm programmieren, welches ein Input eines Textfeldes verändert und weiterverarbeitet.
Das ist der Input (mit zahlen halt):
[x,y,z]+t*[d,e,f]

Die Werte aus dieser Zeile
x,y,z,t,d,e,f sollen in die untere eingesetzt werden
E:\;\overrightarrow{x}=\left(\begin{array}{c}x\\y\\z\end{array}\right)+t\left(\begin{array}{c}d\\e\\f\end{array}\right)\;t\mathbb{\epsilon R}

Ich bin mir an dieser stelle aber nicht sicher wie ich die liste so bereinigen kann, dass nurnoch die Zahlen überbleiben.
Das ist mein aktueller Code.
Ich hoffe mir kann jemand Helfen.

Code: Alles auswählen

a = []
b = []
c = []
i = 0
j = 0
def Einlesen():
    global i
    global a
    global b
    global j
    global c
    a = e1.get()
    
    while j < len(a):
        b.append(a[j])
        print(b[j])
        j = j + 1
    
    print(b)
    
    while i < len(b):
        print(b[i])
           
        try:
            b[i] = int(b[i])
        except ValueError as verr:
            c.append(b[i])
            b.remove(b[i])
        except Exception as ex:
            pass
        

           
        
        
        
        print(b)
        i = i + 1
        
    

[__blackjack__]

@criscros: Das Problem habe ich nicht verstanden, aber der Code ist furchtbar.

Vergiss das es ``global`` gibt. Das ist keine Lösung für irgend etwas. Insbesondere da ich mal stark vermute, dass es sich um ein GUI-Programm handelt, man also mit objektorientierter Programmierung (OOP) zu tun hat. Die braucht man für jedes nicht-triviale GUI-Programm.

Funktionen und Methoden sollten alles was sie ausser Konstanten benötigen als Argumente übergeben bekommen.

Einbuchstabige Namen sind selten eine gute Idee. `i` und `j` für Indexvariablen geht noch, wobei man Indizes in Python relativ selten benötigt, die sind also oft ein Zeichen das man etwas falsch macht.

Namen werden in Python klein_mit_unterstrichen geschrieben. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (MixedCase).

`i` und `j` ausserhalb der ”Funktion” zu definieren ist keine gute Idee weil die Funktion dann ja nur einmal durchlaufen kann. Die starten beim nächsten Aufruf ja nicht auf magische Weise wieder bei 0. Überhaupt ist das definieren aller Variablen in einem Block etwas das man früher mal gemacht hat, als einen ein Compiler dazu *gezwungen* hat. Variablen sollte man erst definieren wenn sie benötigt werden.

`a` wird an eine Liste gebunden, innerhalb der ”Funktion” dann aber an eine Zeichenkette. Das ist verwirrend.

Du solltest dringend ``for``-Schleifen kennenlernen. Schauen wir uns mal die erste Schleife an:

Code: Alles auswählen

    a = e1.get()
    b = []
    j = 0
    while j < len(a):
        b.append(a[j])
        j = j + 1

Als erstes kann man die Initialisierung von `j` vor der Schleife und das manuelle hochzählen am Ende des Schleifenkörpers ganz einfach durch eine ``for``-Schleife loswerden:

Code: Alles auswählen

    a = e1.get()
    b = []
    for j in range(len(a)):
        b.append(a[j])

Dann habe ich ja schon gesagt das Indexvariablen in Python selten sind. Man kann direkt über die Elemente von Sequenzen iterieren, ohne den Umweg über einen Laufindex:

Code: Alles auswählen

    b = []
    for character in e1.get():
        b.append(character)

Um alle Elemente aus einem iterierbaren Objekt in eine Liste zu bekommen kann man auch einfach die `list()`-Funktion verwenden, dann bleibt von dem Ausgangscode für die ``while``-Schleife nur noch diese Zeile übrig:

Code: Alles auswählen

    b = list(e1.get())

Bei der zweiten Schleife wird es dann abenteuerlich. Du entfernst Elemente aus der Liste über die Du gerade iterierst, zählst den Index hoch wo doch beim Entfernen eines Elements alle folgenden eine Position nach vorne rücken. Das `remove()` ist auch ineffizient weil das Element ja von vorne in der Liste gesucht wird, obwohl man den Index des Elements bereits kennt (wenn man den Index richtig verwalten würde).

Aber auch hier sind Indexwerte wieder überflüssig. Statt eine neue Liste zu erstellen und Werte aus der alten zu löschen, erstellt man in Python einfach neue Listen in die man nur die Werte steckt, die man haben möchte.

Das zweite ``except`` ist falsch. Es ist keine gute Idee einfach alle Ausnahmen zu ignorieren. Wenn da irgendwo ein Fehler ist, dann kann man da teilweise sehr lange nach suchen.

Letztlich lässt sich der ganze Code durch diese zwei Zeilen ersetzen:

Code: Alles auswählen

def einlesen(entry):
    c = [character.isdigit() for character in entry.get()]

Allerdings ist hier das Problem das `c` natürlich nicht ausserhalb der Funktion zur Verfügung steht und bei einer GUI der Wert auch nicht an den Aufrufer zurückgegeben werden kann, wenn der Aufrufer die Hauptschleife des GUI-Rahmenwerks ist. Da wären wir dann bei objektorientierter Programmierung.

Ich weiss auch nicht ob das beschränken auf Ziffern wirklich sinnvoll ist. Ich vermute mal nicht.