7.3 Implementierung des Taschenrechners

Für die Implementierung bleiben folgende Fragen zu klären:

• Welche Operatoren sind erlaubt? Wie werden diese erkannt und wie wird die korrekte Funktionalität in Python ausgelöst?

• Welche Zahlen-Datentypen werden akzeptiert? Wie wird mit Eingaben, die nicht in eine Zahl umgewandelt werden können, umgegangen?

Recheninteraktion¶

Eine Recheninteraktion soll wie folgt gestaltet sein:

1. Es wird ein mathematischer Operator abgefragt.

2. Es wird mindestens ein Operand abgefragt.

3. Das Ergebnis der Berechnung wird ausgegeben.

“naive” Implementierung¶

Nehmen wir zuerst einmal an, dass die Nutzer*innen keine Fehler machen und wir nur Eingaben erhalten, die unserem Design entsprechen. Nehmen wir weiter an, dass die Addition von zwei Operanden durchgeführt werden soll.

Wir implementieren die Funktion calculate(), die drei Nutzer*innen-Eingaben einliest und das Ergebnis der Berechnung zurück gibt.

Dabei orientieren wir uns an dieser Beispielinteraktion:

> +
>> 3
>> 4
>> 
7

Ob alles funktioniert hat können Sie mit dem nachfolgenden Code testen. Das assert-Statement überprüft, ob der erste Ausdruck wahr ist. Wenn nein, dann wird der zweite Ausdruck als AssertionError() ausgegeben.

Diese Implementierung ignoriert aktuell die Eingabe des Operators. Dann werden zwei Zahlen eingelesen und als Ganzzahl interpretiert. Es folgt das einlesen einer leeren Zeile, welche das Ende der Operanden-Eingabe signalisiert und es wird - hart codiert - das Ergebnis der Berechnung zurückgegeben.

Korrekte Behandlung der Operanden¶

Bisher gehen wir immer von genau 2 Operanden (und einer leeren Eingabe) aus. Der nächste Schritt ist es, eine variable Anzahl von Operanden einzulesen.

Konzeptionell wollen wir also:

1. eine Eingabe der Nutzer*in einlesen,

2. überprüfen, ob diese leer ist und ggf. das einlesen beenden

3. ansonsten die Eingabe in eine Zahl umwandeln und

4. zwischenspeichern, bis alle Zahlen eingelesen sind.

Um mehrere Werte in einer Variablen zu speichern lernen wir einen neuen Datentyp kennen: die Liste (list(), []). Eine Liste kann mehrere Werte enthalten und es können Werte am Ende hinzugefügt werden. Dann kann die Liste durchlaufen werden und mit jedem Wert etwas getan werden.

Verkleinern wir das Problem noch weiter, so wollen wir diese Interaktion ermöglichen:

>> 1
>> 2
>> 3
>>

Am Ende dieser Eingaben sollten die Werte 1, 2 und 3 in einer Liste gespeichert sein. Das kann beispielsweise so aussehen:

Nun haben wir es fast geschafft. Es fehlt nur noch die korrekte Behandlung mehrerer Operanden bei der Berechnung des Ergebnisses.

Verkleinern wir das Problem wieder, so können wir eine Variable erstellen, welche am Schluss das Ergebnis beinhalten soll und anschließend können wir für alle Operanden das Ergebnis mit dem Operanden verrechnen. Am einfachsten geht das mit der sogenannten for-Schleife:

Die Programmschleife¶

Die Programmschleife soll in jedem Schritt:

1. die Recheninteraktions-Funktion aus dem vorherigen Abschnitt aufrufen und

2. das Rechenergebnis ausgeben, falls vorhanden

3. die Schleife soll beendet werden, wenn kein Operator übergeben wurde

Für die Lösung dieses Problems lernen wir noch ein weiteres sehr nützliches Syntaxelement von Python kennen – den sogenannten Walross-Operator :=.

Dieser erlaubt es in den Bedingungen von if, while, usw. das Ergebnis der Bedingung in einer Variablen abzuspeichern. Dadurch kann unsere Programmschleife wie folgt aussehen:

Gestaltung als Skript¶

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#! /usr/bin/env python3

def calculate():
    # handle the operator
    operator = input("> ")
    if operator != "+":
        # print("ERROR: Unknown operator.")
        return None

    # read in the operands
    numbers = []
    while True:
        text = input(">> ")
        if "" == text:
            break
        numbers.append(int(text))

    # calculate result
    if operator == "+":
        result = 0
        for number in numbers:
            result += number

    return result

if __name__ == "__main__":
    while result := calculate():
        print(result)

!echo "Testing the script automatically with the input: + 3 4"
!chmod u+x ../solutions/020/taschenrechner.py
print('Simulate user interaction by running command in terminal:\n$ echo "+\\n3\\n4\\n\\n" | ./taschenrechner.py')
!echo "+\n3\n4\n\n" | ../solutions/020/taschenrechner.py

Testing the script automatically with the input: + 3 4

Simulate user interaction by running command in terminal:
$ echo "+\n3\n4\n\n" | ./taschenrechner.py
>