Schleife im Unterprogramm

[Erichmo]

Hallo zusammen,

ich habe eine schleife in einem Unterprogramm erstellt um die Koordinaten von Buchstaben eines Strings in einer Matrix zu bestimmen.
Das Unterprogramm soll 2 mal laufen um somit die Koordinaten der ersten beiden Buchstaben zu bestimmen. Leider läuft es einmal und beim zweiten mal bleibt es "hängen".
Kann mir jemand erklären woran das liegen könnte ?

Vielen Dank und beste Grüße,
Erichmo

Code: Alles auswählen

a = 0

y = 0

global enc
enc = list()

def koordinaten(a = y):

    while True: 
        global z  
        z = 0
        global s
        s = 0
        if text5[a] in Matrix[z][s]:
            enc.append(z)
            enc.append(s)
            print (enc)
            break
        else:
            z = z + 1
            if z > 4:
                z = 0
                s = s + 1
                if s > 4:
                    z = 0
                    s = 0
                    break

koordinaten(a = y)
y = y + 1
koordinaten(a = y)
y = y + 1

print (enc)

[sparrow]

Wenn das eine ernstegemeinte Frage und kein Gedankenexperiment ist, dann sorge dafür, dass es kein "global" mehr in deinem Code gibt.

Funktionen erhalten alle nötigen Informationen als Parameter (außer Konstanten) und liefern ein Ergebnis (per return, etc.) zurück.

In deinem Code erscheinen Variablen magisch in der Funktion und es werden auch Variablen außerhalb der Funktion beeinflusst. Das ist falsch, nicht wartbar und die Nebeneffekte fliegen dir jetzt schon um die Ohren.

[Erichmo]

Wenn das eine ernstegemeinte Frage und kein Gedankenexperiment ist, dann sorge dafür, dass es kein "global" mehr in deinem Code gibt.

Funktionen erhalten alle nötigen Informationen als Parameter (außer Konstanten) und liefern ein Ergebnis (per return, etc.) zurück.

In deinem Code erscheinen Variablen magisch in der Funktion und es werden auch Variablen außerhalb der Funktion beeinflusst. Das ist falsch, nicht wartbar und die Nebeneffekte fliegen dir jetzt schon um die Ohren.

Ich benutze das "global" da für mein Programm variablen außerhalb des Unterprogramms beeinflusst werden sollen.
Ich verstehe aber nicht wieso es im Unterprogramm hängen bleibt sobald "a" erhöht wird. Eigentlich ist doch alles so definiert das die variablen z und s so lang abgepasst werden bis die erste if Bedingung erfüllt ist und somit das Programm beendet wird oder nicht ?

[Erichmo]

Wenn das eine ernstegemeinte Frage und kein Gedankenexperiment ist, dann sorge dafür, dass es kein "global" mehr in deinem Code gibt.

Funktionen erhalten alle nötigen Informationen als Parameter (außer Konstanten) und liefern ein Ergebnis (per return, etc.) zurück.

In deinem Code erscheinen Variablen magisch in der Funktion und es werden auch Variablen außerhalb der Funktion beeinflusst. Das ist falsch, nicht wartbar und die Nebeneffekte fliegen dir jetzt schon um die Ohren.

Ich benutze das "global" da für mein Programm variablen außerhalb des Unterprogramms beeinflusst werden sollen.
Ich verstehe aber nicht wieso es im Unterprogramm hängen bleibt sobald "a" erhöht wird. Eigentlich ist doch alles so definiert das die variablen z und s so lang abgepasst werden bis die erste if Bedingung erfüllt ist und somit das Programm beendet wird oder nicht ?

Hab es jetzt so geschrieben:

Code: Alles auswählen

a = 0
y = 0
final = list()
enc = list()

def koordinaten(a = y):

    while True: 
        z = 0
        s = 0
        if text5[a] in Matrix[z][s]:
            enc.append(z)
            enc.append(s)
            print (enc)
            return(enc.append(s), enc.append(s))
        else:
            z = z + 1
            if z > 4:
                z = 0
                s = s + 1
                if s > 4:
                    z = 0
                    s = 0
                    break

koordinaten(a = y)
y = y + 1
koordinaten(a = y)
y = y + 1

Es bleibt immer noch hängen, das ist für mein Verständnis( bin absoluter Anfänger) nicht erklärbar...

[Sirius3]

Vergiß gleich wieder, dass es sowas wie global überhaupt gibt. In Deinem Programm erfüllt es auch überhaupt keinen Zweck. Funktionen erhalten alles was sie brauchen per Argumente und geben ihre Ergebnisse als Rückgabewert per return zurück.
`text5` und `Matrix` kommen aus dem Nichts und sind auch gar nicht definiert, so dass hier niemand Dein Programm ausführen kann, um mögliche Fehler zu entdecken.
Default-Argumente sind nur dann sinnvoll, wenn es auch einen sinnvollen Default gibt.
`a` wird definiert aber nie benutzt.
Listen sollten nicht unterschiedliche Elemente enthaltenen, wie Spalte und Zeile, benutze Tuple.

Um solche Fehler zu vermeiden, sollten auch aller ausführbarer Code in Funktionen stehen, wie hier z.b. in main:

Code: Alles auswählen

def koordinaten(text5, Matrix, a):
    while True: 
        z = 0
        s = 0
        if text5[a] in Matrix[z][s]:
            return z,s
        else:
            z = z + 1
            if z > 4:
                z = 0
                s = s + 1
                if s > 4:
                    z = 0
                    s = 0
                    break
    return None

def main():
    y = 0
    print(koordinaten(text5, Matrix, y))
    y = y + 1
    print(koordinaten(text5, Matrix, y))
    y = y + 1

if __name__ == '__main__':
    main()

Hier sieht man dann auch, dass nicht viel passiert. z und s sind beim Vergleich immer 0, also entweder ist die Bedingung mit der Matrix sofort wahr oder nie und man hat eine Endlosschleife.

[__blackjack__]

@Erichmo: Die Funktion bekommt auch komische/falsche Argumente. Eine Funktion die die Koordinate eines Buchstabens in dem Quadrat/der Matrix ermittelt braucht die Matrix und den Buchstaben als Argumente und nicht irgendeinen Text und einen Index statt des Buchstabens. Wo der Buchstabe her kommt ist nichts was diese Funktion interessieren müsste.

Dann ist die ``while``-Schleife und diese ganze Indexhampelei total unpythonisch – und wie man sieht auch fehleranfällig. Man will hier eine ``for``-Schleife über die Zeilen der Matrix und in dieser Schleife sucht man den Index des Buchstabens innerhalb der Zeile der Matrix – dafür gibt es auf Zeichenketten (oder auch auf Listen) eine Methode die den Index ermitteln oder eine Ausnahme auslöst falls das gesuchte Element nicht enthalten ist. Um den Index der Zeile zu ermitteln kann man `enumerate()` verwenden um in der äusseren ``for``-Schleife über die Zeilen auch gleich den Zeilenindex mit zu generieren.