Frage bezüglich if-statement Verschachtelung (PEP8)

[CrisBee]

Achso, also ein Operator, aber diesen auf alle Operanden anwenden. Da biete sich wohl eine Iteration an!^^

[BlackJack]

@CrisBee: Die Funktionen sind auf jeden Fall unflexibel verkettet. So machen sie nicht das was der Name vermuten lässt. `show_result()` sollte eine Funktion sein die ein Ergebnis anzeigt. Deine Funktion wertet aber erst die Kommandozeilenargumente aus und berechnet das Ergebnis dann. Die Berechnungsfunktion berechnet nicht nur, sondern wertet vorher die Kommandozeilenargumente aus. Einzig die Funktion zur Auswertung der Kommandozeilenargumente macht tatsächlich nur genau das. Bis auf diese Funktion kann man die anderen nicht einzeln testen.

Die Kommentare sind in der Tat zu viel des guten. Kommentare sollten einen Mehrwert zum Code bieten, also etwas enthalten was man nicht schon ganz einfach am Code sehen kann. In der Regel kommentiert man eher *warum* man etwas so macht wie man es im Code macht, und nicht *was* der Code macht. Das sollte aus dem Code selbst ersichtlich sein.

[EyDu]

Achso, also ein Operator, aber diesen auf alle Operanden anwenden. Da biete sich wohl eine Iteration an!^^

Das greift noch nicht weit genug. Wiederholte Anwendung eines ist nur ein Sonderfall. Ein unärer Operator nimmt einen Operanden entgegen, zum Beispiel "cos", "sin", "tan", etc. Ein binärer Operator nimmt zwei Operanden entgegen, wie Addition, Subtraktion, etc. Ternäre Operatoren drei Operanden und n-äre Operatoren haben n Operanden. Letzteres bedeutet aber nicht, dass die selbe Operation immer und immer wieder angewendet wird. Du könntest dir zum Beispiel selber einen Operator definieren:

Code: Alles auswählen

def poly(d, c, b, a):
    return d*x**3 + c*x**2 + b*x + d

[CrisBee]

Danke BlackJack, klingt einleuchtend wie du es sagst.
Bin jetzt leider nicht mehr am PC, werde es morgen überarbeiten und nochmal posten.

@EyDu Das werde ich mir morgen auch nochmal genauer anschauen. Für heute ist das zu hoch für mich! XD

Ich wünsche euch eine angenehme Nacht! =)

[CrisBee]

Guten Morgen liebe Pythonianer!

Habe gedit direkt angeschmissen und den Code nochmal verändert. Meinungen?

Code: Alles auswählen

#!/usr/bin/env python
 
import argparse
import operator

#Using a dictionary to avoid using to many if-statements
OPERATORS = {
    "add": operator.add,
    "sub": operator.sub,
    "mul": operator.mul,
    "div": operator.div}
 
def get_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument("operator", choices=OPERATORS.keys())
    parser.add_argument("op1", type=int)
    parser.add_argument("op2", type=int)
   
    return parser.parse_args()
 
def main():
    args = get_arguments()
    print OPERATORS[args.operator](args.op1, args.op2)
   
if __name__ == "__main__":
    main()

[Hyperion]

Jetzt ist es "zu kurz". Nee, sieht fast gut aus... Du müsstest nur noch das Dispatching in eine Funktion packen, die man aufrufen kann. Denn ansonsten kann ich das ganze auch nur umständlich testen, indem ich wirklich die ``main``-Methode inklusive der Kommandozeilenparameter aufrufe.

Dir fehlt also ein ``def calc(operator, op1, op2)``!

[Sirius3]

Hier das ganze nochmal für n-äre Operatoren:

Code: Alles auswählen

#!/usr/bin/env python
import argparse
import operator

#Using a dictionary to avoid using to many if-statements
OPERATORS = {
    "add": operator.add,
    "sub": operator.sub,
    "mul": operator.mul,
    "div": operator.div,
    "neg": operator.neg,
}

def get_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument("operator", choices=OPERATORS.keys())
    parser.add_argument("operands", type=int, nargs='*')
    return parser.parse_args()

def calculate(operator, operands):
    return OPERATORS[operator](*operands)

def main():
    args = get_arguments()
    print calculate(args.operator, args.operands)

if __name__ == "__main__":
    main()

[CrisBee]

Danke Sirius3, mein Code sieht jetzt so aus. Werde mal die Anpassung mit den n-ären Operanden vornehmen und das "neg" mit reinpacken!

[CrisBee]

Hier nochmal mein Code ohne die n-ären Operanden.

Code: Alles auswählen

#!/usr/bin/env python
 
import argparse
import operator

#Using a dictionary to avoid using too many if-statements
OPERATORS = {
    "add": operator.add,
    "sub": operator.sub,
    "mul": operator.mul,
    "div": operator.div
    }
 
def get_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument("operator", choices=OPERATORS.keys())
    parser.add_argument("op1", type=int)
    parser.add_argument("op2", type=int)
   
    return parser.parse_args()
    
def calc(operator, op1, op2):
    return OPERATORS[operator](op1, op2)
 
def main():
    args = get_arguments()
    print "The result is: " + str(calc(args.operator, args.op1, args.op2))
   
if __name__ == "__main__":
    main()

Habe deinen Code auch mal getestet Sirius. Das funktioniert so nicht. Oder habe ich was falsch gemacht und hätte noch mehr Anpassungen vornehmen müssen? Wenn ich mehr als zwei Zahlen per Kommandozeile übergebe, dann schimpft Python, dass mehr Argumente übergeben wurden, als erwartet wurden. Habe an das 'nargs' aber gedacht.

[Sirius3]

Ein binärer Operator erwartet eben zwei Werte. Wenn Du mehr angibst, meckert Python natürlich. Ein Nicht-Python-Programmierer kann mit dem Fehler wahrscheinlich wenig anfangen. Es wäre also Deine Aufgabe, daraus eine sprechendere Meldung zu machen.

[CrisBee]

Dann gab es wohl ein Missverständnis bei mir. Ich dachte (sollte ich mir wohl mal abgewöhnen), dass es dabei um das operieren mit x Zahlen handelt! Jajaaaa, ich muss noch viel viel viel viel lernen...