ZeroDivisionError: float division by zero - Rechner gibt Fehler aus

[johann1976]

Moin Leute ich bin neu im Forum und arbeite Hobbymässig seid einigen Monaten mit Python.
Leider hänge ich an einer Kleinigkeit fest...
Und zwar betreibe ich Webentwicklung mit HTML und CSS und implementiere da ich aus dem Elektrotechnischen Bereich komme einen Motoreffizienzrechner(Gegenüberstellung von Asynchron- und Synchron-Reluktanzmotoren).

In meinem Rechner sind folgende Eckdaten wichtig:

Zugeführte Wirkleistung bei
100%
75%
50%
25%

Anzahl Motoren

Energiepreis

und die Betriebsstundenzahlen bei den jeweiligen Lastbereichen.

So der Rechner funktioniert mittlerweile gut. Die Berechnungen passen, der Rechner akzeptiert wenn ein Eingabefeld leer bleibt, der Rechner akzeptiert float zahlen auch mit Komma. Außer und jetzt kommt das Problem : Wenn die Leistungen bei 100% und 75% beides Float zahlen sind, gibt er die oben genannte Fehlermeldung aus.
Alle anderen Kombinationen von Float sind ok und er berechnet sie auch.
Bin echt überfragt und hoffe das eventuell jemand den Bock sieht den ich geschossen habe ...

Es folgt nun der Relevante Part des Codes

Code: Alles auswählen

@app.route('/eigenmessung',methods=['POST','GET'])

def eigenmessung():

    leistung = request.form.to_dict()
    p_ = leistung['KW']
    KW = locale.atof(p_)

    pr = request.form.to_dict()
    pr_ = pr['Preis']
    Preis = locale.atof(pr_)

    az = request.form.to_dict()
    az_=az['anzahl']
    anzahl = int(az_)

    b100x = request.form.to_dict()
    b100_ = b100x['_100_']
    if b100_.isdigit():
        int(b100_)
        b100_ = b100x['_100_']
    else:
        b100_ = '0' 
    _100_ = locale.atof(b100_)

    b75x = request.form.to_dict()
    b75_ = b75x['_75_']
    if b75_.isdigit():
        int(b75_)
        b75_ = b75x['_75_']
    else:
        b75_ = '0' 
    _75_ = locale.atof(b75_)


    b50x = request.form.to_dict()
    b50_ = b50x['_50_']
    if b50_.isdigit():
        int(b50_)
        b50_ = b50x['_50_']
    else:
        b50_ = '0' 
    _50_ = locale.atof(b50_)

    b25x = request.form.to_dict()
    b25_ = b25x['_25_']
    if b25_.isdigit():
        int(b25_)
        b25_ = b25x['_25_']
    else:
        b25_ = '0' 
    _25_ = locale.atof(b25_)



    p100 = request.form.to_dict()
    p100_ = p100['pzu100']
    if p100_.isdigit():
        int(p100_)
        p100_ = p100['pzu100']
    else:
        p100_ = '0' 
    pzu100 = locale.atof(p100_)



    p75 = request.form.to_dict()
    p75_ = p75['pzu75']
    if p75_.isdigit():
        int(p75_)
        p75_ = p75['pzu75']
    else:
        p75_ = '0' 
    pzu75 = locale.atof(p75_)



    p50 = request.form.to_dict()
    p50_ = p50['pzu50']
    if p50_.isdigit():
        int(p50_)
        p50_ = p50['pzu50']
    else:
        p50_ = '0' 
    pzu50 = locale.atof(p50_)

    p25 = request.form.to_dict()
    p25_ = p25['pzu25']
    if p25_.isdigit():
        int(p25_)
        p25_ = p25['pzu25']
    else:
        p25_ ='0' 
    pzu25 = locale.atof(p25_)


asy_verbrauch = round(Preis*anzahl * ((pzu100 * _100_) + (pzu75 * _75_) + (pzu50 * _50_) + (pzu25 * _25_)),2)

prozent =  round((100 - (100/asy_verbrauch * synrm_verbrauch)),2)   #Hier soll der Fehler sein

_100_ : dies sind die Betriebsstundenzahlen

pzu : Zugeführte Wirkleistungen

Ich bedanke mich schonmal für jeden Tipp.

Liebe Grüße
Johann

[__deets__]

Der allereste Tipp: statt dutzend male request.form.to_dict() aufzurufen, macht man das *einmal*, und holt sich dann alle gewuenschten Werte aus dem Woerterbuch. Und bindet die dann an die richtigen Namen, statt einen Zwischennamen, der dann nochmal mit _ andekoriert wird. Ein statement wie

Code: Alles auswählen

        int(b75_)

ist voellig wirkungslos, du musst das Ergebnis dieser Wandlung schon einem Namen zuweisen. Das ganze repetitive geteste, ob sich die Eingabe in eine Zahl wandeln laess, wiederholt man nicht fuer jede Groesse, sondern packt das *einmal* in eine Funktion, und ruft die auf. Auch dadurch spart man sich ein dutzend verwirrender Namen ein.

Zu guter letzt zu deiner eigentlichen Frage: du hast das doch so programmiert, das alle moeglichen Groessen auch einfach 0 sind, wenn sie falsch eingegeben werden. Und das passiert da offensichtlich, und damit kommt als Ergebnis auch 0 als Divisor raus.

[Sirius3]

Du prüfst, ob die Eingabe nur aus Ziffern besteht, was bei Kommazahlen nicht der Fall ist. Und sonst nimmst Du 0 an, ohne eine Fehlermeldung zurückzuliefern. Das solltest Du nicht tun. Wenn das keine Zahl ist, dann sollte der Nutzer erfahren, dass er was falsches eingegeben hat.

Statt Code duzende male zu kopieren, benutzt man Funktionen und Schleifen.
Die Variablennamen sind zum Großteil wirklich schlecht. Was sollen die Unterstriche? Variablennamen schreibt man generell komplett klein. Benutze keine kryptischen Abkürzungen, was soll asy sein und was synrm? Was kann man sich unter pzu vorstellen und was unter _?
Gerundet wird ein Ergebnis bei der Ausgabe, und nicht schon bei der Rechnung.
Hier wird einfach eine Exception geworfen, die kann man dann noch bei Bedarf in eine schönere Fehlermeldung umwandeln:

Code: Alles auswählen

def to_float(parameter, key):
    if parameter.get(key, '').strip():
        return locale.atof(parameter[key])
    else:
        return 0

def eigenmessung(request):
    parameters = request.form.to_dict()
    leistung = to_float(parameters, 'KW')
    preis = to_float(parameters, 'Preis')
    anzahl = int(parameters['anzahl'])

    irgendwas = {}
    pzu = {}
    for prozent in [100, 75, 50, 25]:
        irgendwas[prozent] = to_float(parameters, f'_{prozent}_')
        pzu[prozent] = to_float(parameters, f'pzu{prozent}')

    asy_verbrauch = preis * anzahl * sum(pzu[prozent] * irgendwas[prozent] for prozent in [100, 75, 50, 25])
    prozent = 100 - (100 / asy_verbrauch * synrm_verbrauch)

[johann1976]

Vielen Dank Leute, ich werde versuchen es mir anzueignen