Fehler im Programm, Hilfe!

[Nat]

Guten Tag!

Erst dieses Semester habe ich angefangen, mit Python zu programmieren. Als Aufgabe müssen wir nun ein Programm schreiben, dass anhand von im Shell eingegebenen Preisen den Totalbeitrag und evtl. die entsprechenden Rabatte berechnet. Wenn ein x eingegeben wird, soll die Eingabe gestoppt und die Summe berechnet werden. Dafür habe ich das folgende Programm geschrieben:

Code: Alles auswählen

i = 0
preis1 = input("Bitte geben Sie den ersten Preis ein: ")
summe = 0
if i == 0 and preis1 != "x":
    preis2 = input("Bitte geben Sie den zweiten Preis ein: ")
    i = i+1
if i == 1 and preis2 != "x":
    preis3 = input ("Bitte geben Sie den dritten Preis ein: ")
    i = i+1
else:
    if int(preis1) < 100:
        summe = summe + int(preis1)
        print("Kein Rabatt. Gesamtpreis:", summe)
    elif int(preis1) > 100 and int(preis1) < 1000 or int(preis1) == 100:
        summe = summe + int(preis1) - ((int(preis1)*5)/100)
        print("5% Rabatt. Gesamtpreis:", summe)
    elif int(preis1) > 1000 or int(preis1) == 1000:
        summe = summe + int(preis1) - ((int(preis1)*10)/100)
        print("10% Rabatt. Gesamtpreis:", summe)
if i == 2 and preis3 != "x":
    if int(preis1)+int(preis2)+int(preis3) < 100:
        summe = summe + int(preis1)+ int(preis2)+int(preis3)
        print("Kein Rabatt. Gesamtpreis:", summe)
    elif int(preis1)+ int(preis2)+int(preis3) > 100 and int(preis1)+int(preis2)+int(preis3) < 1000 or int(preis1)+int(preis2)+int(preis3) == 100:
        summe = (summe + int(preis1)+ int(preis2)+int(preis3)) - (((int(preis1)+int(preis2)+int(preis3))*5)/100)
        print("5% Rabatt. Gesamtpreis:", summe)
    elif int(preis1)+int(preis2)+int(preis3) > 1000 or int(preis1)+int(preis2)+int(preis3) == 1000:
        summe = (summe + int(preis1)+int(preis2)+int(preis3)) - (((int(preis1)+int(preis2)+int(preis3))*10)/100)
        print("10% Rabatt. Gesamtpreis:", summe)
else:
    if int(preis1)+int(preis2) < 100:
        summe = summe + int(preis1)+ int(preis2)
        print("Kein Rabatt. Gesamtpreis:", summe)
    elif int(preis1)+ int(preis2) > 100 and int(preis1)+int(preis2) < 1000 or int(preis1)+int(preis2) == 100:
        summe = (summe + int(preis1)+ int(preis2)) - (((int(preis1)+int(preis2))*5)/100)
        print("5% Rabatt. Gesamtpreis:", summe)
    elif int(preis1)+int(preis2) > 1000 or int(preis1)+int(preis2) == 1000:
        summe = (summe + int(preis1)+int(preis2)) - (((int(preis1)+int(preis2))*10)/100)
        print("10% Rabatt. Gesamtpreis:", summe)

Und hier ist das Problem: wenn man alle Preise eingibt oder wenn man "x" im letzten Eingabefeld eingibt, funktioniert alles perfekt. Aber wenn man "x" z.B. im zweiten Feld eingibt, wird zwar die richtige Summe berechnet (also das Ergebnis ist korrekt), aber es erscheint die folgende Fehlermeldung:

Code: Alles auswählen

Bitte geben Sie den ersten Preis ein: 1
Bitte geben Sie den zweiten Preis ein: x
Kein Rabatt. Gesamtpreis: 1
Traceback (most recent call last):
  File "...", line 31, in <module>
    if int(preis1)+int(preis2) < 100:
ValueError: invalid literal for int() with base 10: 'x'

Meine Frage ist also: warum bezieht sich der Computer auf diese If-Anweisung, und nicht auf die Richtige: if int(preis1) < 100? Die Berechnung, die er eigentlich machen sollte, wäre: summe = summe + int(preis1), und ich verstehe nicht, weshalb er das nicht macht. Ich sehe nicht, wo der Fehler steht. Könnte jemand mir vielleicht einen Tipp geben? Ich danke euch im Voraus für eure Hilfe!

[BlackJack]

@Nat: Das Programm macht genau das was Du sagst. Schau Dir einfach die Bedingungen an, die zu dieser Zeile führen und Du wirst sehen, dass sie erfüllt sind. Das ``if`` wird ausgeführt wenn der ``else``-Zweig in Zeile 30 betreten wird. Und der wird ausgeführt, wenn die Bedingung beim ``if`` in Zeile 20 nicht zutrifft. Und da `i` an der Stelle nicht 2 ist, passiert das halt auch.

Letztlich ist das aber insgesamt alles ganz fürchterlich gelöst. Stell Dir mal vor Du willst das auf 4 oder 5 oder gar beliebig viele Eingaben erweitern, wie umfangreich und komplex der weitere Code dafür werden würde. Beziehungsweise kann man beliebig viele Eingaben auf dieses Weise gar nicht lösen wenn man jeden Fall einzeln statisch ausprogrammiert.

Wenn sich etwas wiederholen soll, dann schreibt man eine Schleife. In diesem Fall eine, die so lange Eingaben liest, bis der Benutzer ein x eingegeben hat. Die Eingaben wandelt man um und addiert sie auf. Und am Schluss, nach der Schleife, kann man dann den Rabatt berechnen. Für jede der Operationen — umwandeln in Zahl, addieren zum Gesamtergebnis, ermitteln der Rabatthöhe, und berechnen des Rabatts — muss man dann nur *einmal* den Quelltext schreiben. Und nicht wie bei Dir immer und immer wieder den im Grunde gleichen Quelltext. Ein wichtiges Prinzip beim Programmieren ist „Don't Repeat Yourself” oder DRY. Weder Daten noch nahezu identischen Code sollte man wiederholt im Programm haben. Das ist unnötige Arbeit, unnötige Fehlerquelle, und unnötig aufwändig zu pflegen oder zu verändern.

[Nat]

@BlackJack: Vielen Dank für deine schnelle Antwort. Ich habe mir überlegt, wie ich mein Programm mittels Schleifen programmieren könnte, und bin zum folgenden Teilergebnis gekommen:

Code: Alles auswählen

i = 0
summe = 0
def total(summe):
    if summe < 100:
        total = summe 
        print("Kein Rabatt. Gesamtpreis:", total)
    elif summe > 100 and summe < 1000 or summe == 100:
        total = summe - ((summe*5)/100)
        print("5% Rabatt. Gesamtpreis:", total)
    elif summe > 1000 or summe == 1000:
        total = summe - ((summe*10)/100)
        print("10% Rabatt. Gesamtpreis:", total)

preis = input("Bitte geben Sie den ersten Preis ein: ")

while preis != "x":
    i = i+1
    if i == 1:
        preis = input("Bitte geben Sie einen zweiten Preis ein: ")
    elif i == 2:
        preis = input("Bitte geben Sie einen dritten Preis ein: ")
    elif i == 3:
        preis = input("Bitte geben Sie einen vierten Preis ein: ")
        
if preis == "x":
    summe = summe + ???
    total(summe)

Hattest du so was gemeint? Mein Problem ist jetzt, dass ich nicht weiss, wie ich die Summe berechnen kann, da ich nicht jeder Eingabe einen unterschiedlichen Namen gegeben habe. Wie kann ich auf die einzelnen Eingaben zugreifen? Nach meinem Verständnis wird im oben stehenden Programm die Variable "preis" von jeder neuen Eingabe ersetzt. Ist es nicht so? Gibt es hier etwas, das ich übersehe?
Meine beste (fertige) Lösung für jetzt ist also die folgende (die gleiche Fehlermeldung wie früher kommt zwar immer noch. Diesbezüglich habe ich deine Erklärung nicht so gut verstanden: hat es damit zu tun, dass das Programm nicht weiss, dass er anhalten soll?):

Code: Alles auswählen

i = 0
summe = 0
def total(summe):
    if summe < 100:
        total = summe 
        print("Kein Rabatt. Gesamtpreis:", total)
    elif summe > 100 and summe < 1000 or summe == 100:
        total = summe - ((summe*5)/100)
        print("5% Rabatt. Gesamtpreis:", total)
    elif summe > 1000 or summe == 1000:
        total = summe - ((summe*10)/100)
        print("10% Rabatt. Gesamtpreis:", total)

preis1 = input("Bitte geben Sie den ersten Preis ein: ")

if preis1 != "x":
    preis2 = input("Bitte geben Sie den zweiten Preis ein: ")
if preis2 != "x":
    preis3 = input("Bitte geben Sie den dritten Preis ein: ")
else:
    summe = summe + int(preis1)
    total(summe)
if preis3 != "x":
    summe = int(preis1) + int(preis2) + int(preis3)
    total(summe)
else:
    summe = summe + int(preis1) + int(preis2)
    total(summe)

Was denkst du davon?
Ich wäre dir für zusätzliche Erläuterungen sehr dankbar.

[Sirius3]

Hallo Nat,

Deine Funktion total hat einen nichtsprechenden Namen.
Ich würde summe_ausgeben oder ähnliches vorschlagen.
Zum zweiten heißt die Funktion total, gleichzeitig wird aber
auch eine lokale Variable mit dem Namen total definiert.
Das ist nicht so gut, weil es die Funktion total versteckt und
verwirrend ist.
3. es gibt >= 100.
4. im ersten Programm hast Du immer noch 4x input.
Die while-Schleife bricht nach 4 Eingaben nicht mehr ab sondern
zählt i für immer hoch.
5. Zum zweiten Versuch: Geh einmal von Hand alle Fälle durch,
was passiert wenn preis1='x' ist, was wenn preis2='x' ist, usw.
Welche if-Abfragen sind erfüllt, und welche else-Zweige werden
durchlaufen?

Grüße
Sirius

[pixewakb]

Das ist gar kein perfekter Sourcecode, aber lauffähig:

Code: Alles auswählen

# Meine Variablen
eingabe = ""

warenkorb = []

# Dieser while-Block nimmt die Eingaben des Benutzers auf und packt alles in eine Liste,
# wenn es gerade kein x ist.
while eingabe != "x":

    eingabe = input("Bitte geben Sie den Preis ein: ")

    if eingabe != "x":
        warenkorb.append(float(eingabe))

print("Die Gesamtsumme Ihres Warenkorbs betraegt", sum(warenkorb), "€.")

if sum(warenkorb) >= 1000.0:
    print("10 % Rabatt.")
    print("Zu zahlen:",round(sum(warenkorb) * 0.9,2),"€.")
elif sum(warenkorb) >= 100.0:
    print("5 % Rabatt.")
    print("Zu zahlen:",round(sum(warenkorb) * 0.95,2),"€.")
else:
    print("Kein Rabatt.")
    print("Zu zahlen:",sum(warenkorb),"€.")

Ich denke, dass der Quellcode nicht (!) gut ist. Aber es war so schnell zu coden und es läuft.

[BlackJack]

@Nat: Das Aufsummieren kannst Du *in* der Schleife machen. Dann braucht auch nicht jede Eingabe ihren eigenen Namen, denn nach der Addition wird der Wert ja nicht mehr benötigt.

Ausserdem solltest Du überlegen die Frage zur Eingabe ohne deutsche Zahlworte zu machen, dann brauchst Du nur einmal `input()` in der Schleife. Die wievielte Eingabe es ist, kannst Du auch als Zahl ausdrücken.

Wie gesagt sollte man Wiederholungen von Daten oder Code vermeiden. Solche Schleifen sollte man deshalb so gestalten, dass nicht vor der Schleife eine Eingabe abgefragt wird, die in der Schleife dann noch mal, zumindest sehr ähnlich, steht. Das macht man in Python mit einer Endlosschleife (``while True``), die bei entsprechender Bedingung durch ein ``break`` verlassen wird.

In Fällen wo man weiss wie viele Schleifendurchläufe (maximal) gemacht werden, verwendet man allerdings statt einer ``while``-Schleife sowieso eine ``for``-Schleife. Wenn zum Beispiel die Zahlworte vorgeschrieben sind, dann wäre eine Liste mit denen ein prima Kandidat um darüber zu iterieren. Denn diese Worte sind ja letztlich das einzige was die Eingabeaufforderungen unterscheiden.

Ebenfalls in die DRY-Kategorie fällt das Umwandeln der Eingabe in eine Zahl. Das macht man *einmal* an der richtigen Stelle im Programmablauf.

Auch in der `total()`-Funktion sind Wiederholungen. Das Berechnen des Gesamtpreises und die Ausgabe stehen da drei mal. Wenn man den ersten Fall als Abzug von 0% ansieht, dann ist das bis auf den Prozentsatz drei mal exakt die selbe Rechnung.

Die Bedingungen dort könnte man auch einfacher formulieren. Überleg mal unter welchen Bedingungen die erste Bedingung beim ersten ``elif`` nicht wahr ist, also unter welchen Bedingungen die überhaupt Sinn machen würde.

Ähnlich beim letzten ``elif`` — auf welche `summe`-Werte trifft das an der Stelle nicht zu für den Fall dass der Code so weit ausgeführt wird?

@pixewakb:

[/me]

Was denkst du davon?

Sind dir Listen bekannt?

Damit könnte man so etwas bauen:

Code: Alles auswählen

def preise_eingeben():
    preise = []
    while True:
        preis = raw_input('Bitte geben Sie den Preis ein: ')
        if preis == 'x':
            break
        preise.append(int(preis))
    return preise

alle_preise = preise_eingeben()
print(alle_preise)
print(sum(alle_preise))

Die Funktion preise_eingeben erstellt zunächst eine leere Liste namens preise. Dann geht das Programm in eine Endlosschleife da while True immer wahr ist. In der Schleife wird der Preis eingegeben. Ist der eingegebene Wert 'x', dann wird die Schleife verlassen. Im anderen Fall wird der eingegebene Preis in einen Integer-Wert konvertiert und der Liste hinzugefügt. Nach der Schleife - also wenn sie durch Eingabe von x verlassen wurde - werden die gesammelten Werte an den Aufrufer zurückgegeben.

Etwas unschön ist es, dass das Programm bei Eingabe eines ungültigen Wertes wie beispielsweise a oder eines großen X unter Absingen schmutziger Lieder mit einem Fehler aussteigt: ValueError: invalid literal for int() with base 10: 'a'. Das Problem ist hier, dass das Programm versucht, den eingegebenen Wert in ein Integer zu konvertieren was natürlich nicht funktioniert. Da könnte man die Routine noch etwas robuster gestalten.

Code: Alles auswählen

def preise_eingeben():
    preise = []
    while True:
        preis = raw_input('Bitte geben Sie den Preis ein: ')
        if preis.lower() == 'x':
            break
        try:
            preise.append(int(preis))
        except ValueError:
            print('Der eingegebene Wert konnte nicht als Preis erkannt werden.')
    return preise

Durch das lower() vergleichen wir mit Kleinbuchstaben, so dass auch ein als Großbuchstabe eingegebenes X zum Abbruch der Schleife führt. Durch das try-except wird der Konvertierungsfehler abgefangen und eine entsprechende Fehlermeldung ausgegeben.

Ich würde wohl die Routine noch etwas mehr auseinander nehmen, aber für den Anfang sollte das erst einmal reichen.

[Sirius3]

Das mit dem Durchzählen geht natürlich so:

Code: Alles auswählen

from itertools import count

einer = ('','ein','zwei','drei','vier','fuenf','sechs','sieben','acht','neun','zehn',
    'elf','zwoelf','dreizehn','vierzehn','fuenfzehn','sechzehn','siebzehn','achzehn','neunzehn')
zehner = ('','zehn','zwanzig','dreissig','vierzig','fuenfzig','sechzig','siebzig','achzig','neunzig')
def trillion(grp):
    ergebnis = ('','mi','bi','tri','quadri','quin','sex','sept','okt')[grp//2]
    return ergebnis+('llionen','lliarden')[grp%2]

def zahlwort(num):
    gruppe = 0
    ergebnis = ""
    while num>0:
        n = num % 1000
        erg = ""
        if n>=100:
            erg += einer[n//100]+'hundert'
            n %= 100
        if n>=20:
            erg += einer[n%10]
            erg += einer[n%10]
            if n%10!=0:
                erg += 'und'
            erg += zehner[n//10]
        else:
            erg += einer[n]
        if erg=="":
            pass
        elif gruppe==0:
            ergebnis = erg
        elif gruppe==1:
            ergebnis = erg+'tausend'+ergebnis
        else:
            tr=trillion(gruppe)
            if erg=='ein':
                ergebnis = 'eine'+tr[:-2+(gruppe%2)]+ergebnis
            else:
                ergebnis = erg+tr+ergebnis
        num /= 1000
        gruppe += 1
    if ergebnis=='':
        ergebnis='null'
    elif ergebnis=='ein':
        ergebnis='eins'
    return ergebnis

kardinal={'ins':'rs','rei':'rit','ben':'b','cht':'ch','zig':'zigs','ert':'erts','end':'ends','ion':'ions','nen':'ns','rde':'rds','den':'ds'}
def kardinalzahl(num, endung='en'):
    ergebnis=zahlwort(num)
    if ergebnis[-3:] in kardinal:
        ergebnis = ergebnis[:-3]+kardinal[ergebnis[-3:]]
    return ergebnis+'t'+endung

summe = 0
for num in count(1):
    preis = raw_input("Bitte geben Sie den {} Preis ein: ".format(kardinalzahl(num)))
    if preis in ('', 'x'):
        break
    try:
        summe += float(preis)
    except ValueError:
        print "Keine Zahl!"

[Nat]

Vielen Dank zu allen für eure Hilfe! Ihre Lösungsvorschläge sind z.T. zu fortgeschritten für mein aktuelles Niveau, aber es ist für mich trotzdem sehr interessant zu sehen, was man alles mit Python machen kann.

@Sirius3: Ich hatte eben gedacht, dass es eine solche Lösung geben sollte, aber natürlich wäre ich nie dazu gekommen! Es gibt auch Zeichen, die ich bisher noch nicht gelernt habe. Aber das motiviert mich, mit Python weiterzugehen! Was die Funktionsname betrifft, hast du Recht: ich habe ihn gleich geändert. Deine weiteren Hinweise habe mir erlaubt, einen weiteren Fehler zu beheben!

@/me: Nein, ich mit Listen noch nicht gearbeitet, aber dank deiner Erklärung verstehe ich die Funktionsweise deines Programms. Was ich auch nicht kannte, ist das "append" und das "try". Nochmals danke für deine Erläuterungen diesbezüglich, ich habe viel gelernt!

@BlackJack: Ich hatte das Problem nicht so betrachtet! Klar ist es die einfachste Weise, die Summe zu berechnen. Jetzt habe ich in sie in die Schleife eingebaut. Jetzt werde ich versuchen, mein Programm mit deinen weiteren Bemerkungen zu verbessern. Vielen Dank für deine Erläuterungen!

@Pixewakb: Nach der Erklärung von /me verstehe ich dein Programm! Ich hatte nicht daran gedacht, am Anfang einfach eingabe="" zu schreiben, aber das muss ich auf jeden Fall tun! Ich sehe, dass du "float" statt "int" verwendest, um die String-Eingabe in eine Zahl umzuwandeln. Mir ist aber unklar, was der Unterschied zwischen den beiden ist; ich werde mit meinem Programm experimentieren!

Nochmals vielen Dank an euch alle, ihr habt mir riesig geholfen!

[/me]

Ich sehe, dass du "float" statt "int" verwendest, um die String-Eingabe in eine Zahl umzuwandeln. Mir ist aber unklar, was der Unterschied zwischen den beiden ist; ich werde mit meinem Programm experimentieren!

int steht für eine Integer-Zahl, also eine Zahl ohne Nachkommastellen. float ist eine Fließkommazahl, also eine Zahl bei der Nachkommastellen möglich sind.

Bei floats muss man allerdings ein wenig aufpassen wenn man exakte Präzision erwartet. (edit: BlackJack hat ja sooo recht. Vergesst dieses Beispiel, weiter unten kommt was Neues)

Code: Alles auswählen

>>> 0.9 + 0.1 == 1.0
True
>>> 3.0 + 3.0 + 1.0 == 10.0
False

Das ist kein Python-Problem sondern prinzipiell schon durch die Prozessorarchitektur und deren interner Kodierung einer Fließkommazahl bedingt.

[BlackJack]

@/me: Ich frage mich jetzt gerade was die Beispiele zeigen sollen, denn bei denen tritt ja gar kein überraschendes Ergebnis auf.

[/me]

@/me: Ich frage mich jetzt gerade was die Beispiele zeigen sollen, denn bei denen tritt ja gar kein überraschendes Ergebnis auf.

Aber nur weil 3.0 + 3.0 + 1.0 wirklich nicht 10.0 ist. Sorry, ich bin ein wenig übermüdet und stehe gerade schwer unter Medikamenten.

Zeigen wir es halt so:

Code: Alles auswählen

>>> x = sum(0.1 for _ in range(10))
>>> x
0.9999999999999999

[pixewakb]

Sagen wir einmal, dass ich mit Gleitkommawerten rechnen muss und eine "normale" Genauigkeit benötige, wie kann ich das denn dann machen???

[BlackJack]

@pixewakb: Das kommt drauf an was Du mit „normal” meinst. Entweder reicht es die Werte mit zwei Nachkommastellen auszugeben und keine absoluten Vergleiche zu machen, oder Du kannst keine Gleitkommazahlen verwenden die der Prozessor verwendet, sondern ”selbst” programmierte wie die aus dem `decimal`-Modul in der Standardbibliothek.

[jbs]

Mein Gott, ich habe auf das Avatar geschaut und den Post als Zynismus Cofis gedeutet.

[cofi]

Bin ich in meinen Posts so zynisch, dass du die gewaltigen Unterschiede im Bildchen uebersiehst? :O

Zur Genauigkeit sei vielleicht nochmal darauf verwiesen, dass die reellen Zahlen unendlich und nicht aufzaehlbar sind. Dem gegenueber kann man die sehr endliche Menge an Speicher eines Computers stellen. Und das gilt natuerlich nicht fuer die ganze Menge an Zahlen, sondern schon fuer eine einzige, beispielsweise π oder e und wenns ganz profan sein darf: 1/3.

[BlackJack]

Mal ein Ansatz von mir:

Code: Alles auswählen

#!/usr/bin/env python
from decimal import Decimal


def main():
    total = 0
    i = 1
    try:
        while True:
            response = raw_input('Bitte den {0}. Preis eingeben: '.format(i))
            if response.lower() == 'x':
                break
            try:
                price = Decimal(response)
            except ValueError:
                print 'Fehler: Eingabe {0!r} war keine Zahl.'.format(response)
            else:
                total += price
                i += 1
    except (KeyboardInterrupt, EOFError):
        print
    
    for limit, percentage in [(100, 0), (1000, 5), (float('+inf'), 10)]:
        if total < limit:
            break

    total = total - total / 100 * percentage
    
    print '{0} Rabatt.  Gesamtpreis: {1:.2f}'.format(
        '{0}%'.format(percentage) if percentage else 'Kein', total
    )


if __name__ == '__main__':
    main()

[Leonidas]

Mein Gott, ich habe auf das Avatar geschaut und den Post als Zynismus Cofis gedeutet.

Ging mir auch exakt so Hab dann erst gemerkt als @pixelwakb in BlackJacks Post vorkam.