Euklidischen Algorithmus mit Rechenschritte

[eli]

Hallo, ich habe noch nicht sehr viele Erfahrungen, was die Programmierung mit Python betrifft.
Ich habe die Aufgabe ein Python-Programm zu programmieren, was mir den ggT (größten gemeinsamen Teiler) aus zwei Zahlen bestimmt. Das habe ich soweit geschafft, dazu gibt es auch schon genügend Einträge.
Problem ist nur, dass beim Output alle Rechenschritte mit ausgeworfen werden sollen.

Code: Alles auswählen

input_check = 0

while input_check == 0:
    num1 = input("Tell me your first number >0: ")
    num2 = input("Tell me your secound number >0: ")
  
    #Versuche Eingabe zu konvertieren
    try:
        num1_int = int(num1)
        num2_int = int(num2)
        if num1_int < 1 or num2_int < 1:
            print("Only natural numbers allowed! Pleas try again!")
        
    #Handling - Fehler
    except ValueError:
        print("Only natural numbers allowed! Pleas try again!")
        
    else:
        input_check = 1 
        
def euklid_rek(wert_1,wert_2):
    if wert_2 == 0:
        return wert_1
    else:
        print("rekrusiver Aufwand mit:", str(wert_1), str(wert_2))
        return euklid_rek(wert_2,(wert_1 % wert_2))
        
print("Der ggT ist " + str(euklid_rek(num1_int, num2_int)))

[__deets__]

Na dann zeig doch mal, was du hast. Bitte die Code-Tags nicht vergessen.

[__blackjack__]

@eli: Auf Modulebene sollte nur Code stehen, der Konstanten, Funktionen, und Klassen definiert. Hauptrogramm und Funktionsdefinitionen auf Modulebene mischen ist maximal unübersichtlich. Das Hauptrogramm steht üblicherweise in einer Funktion die `main()` heisst.

`input_check` kann nur die Werte 0 und 1 annehmen, ist also eigentlich gar keine Zahl sondern ein Wahrheitswert. Dafür hat Python einen eigenen Typ `bool` mit den Werten `True` und `False` die man da verwenden sollte, statt Zahlen zu missbrauchen.

Letztlich braucht man `input_check` aber auch gar nicht. Idiomatisches Python ist eine ”Endlosschleife”, die dann an der passenden Stelle mit ``break`` oder ``return`` verlassen wird.

Der Inhalt eines ``try``-Blocks sollte klein gehalten werden. Wenn man auf `ValueError` beim Umwandeln testen will, sollte im ``try``-Block auch nur die Umwandlung stehen, und nicht noch weitere Tests und Code wo vielleicht auch ein `ValueError` auftreten könnte.

Namen sollten nicht kryptisch abgekürzt werden. Wenn man `number` meint, sollte man nicht nur `num` schreiben.

Man nummeriert keine Namen. Man sich da entweder bessere Namen überlegen, oder keine Einzelnamen sondern eine Datenstruktur verwenden. Oft eine Liste.

Grunddatentypen haben in Namen nichts zu suchen. Und etwas das `number` oder so ähnlich heisst, sollte keine Zeichenkette sein. Das ist verwirrend.

`print()` wandelt Argumente für die Ausgabe selbst in Zeichenketten um, das muss man nicht selbst machen.

Zwischenstand (ungetestet):

Code: Alles auswählen

#!/usr/bin/env python3


def berechne_ggt_rekursiv(a, b):
    if b == 0:
        return a
    else:
        print("rekrusiver Aufruf mit:", a, b)
        return berechne_ggt_rekursiv(b, a % b)


def main():
    while True:
        try:
            first_number = int(input("Tell me your first number >0: "))
            second_number = int(input("Tell me your second number >0: "))
        except ValueError:
            print("Only natural numbers allowed! Please try again!")
        else:
            if first_number > 0 and second_number > 0:
                break
            print("Only numbers >0 allowed! Please try again!")

    print("Der ggT ist", berechne_ggt_rekursiv(first_number, second_number))


if __name__ == "__main__":
    main()

Für die Eingabe *einer* Zahl würde man besser eine Funktion schreiben, denn das man gezwungen ist bei einer korrekten und einer falschen Eingabe, *beide* noch mal zu machen, ist nicht so nutzerfreundlich.

Was ist denn jetzt das konkrete Problem? Die Schritte werden doch ausgegeben‽