Mein erstes kleines Programm...

[EyDu]

Hallo mutetella, ich habe mir eben die Mühe gemacht, und deine Replace-Funktion getestet, leider ohne Erfolg. hier mein Code:

Dann vergleiche noch einmal deinen Code mit dem von mutetella. Kleiner Tipp: Achte mal auf den Namen der Funktion von mutetella und die Reihenfolge der Operationen: Einlesen, Ersetzen, Umwandeln.

[Sophus]

Das "Hauptprogramm" ist auch noch deutlich zu unpythonisch.

Namen nummeriert man nicht! ``Feature1`` usw. zeigt, dass Du da eine Liste o.ä. nutzen willst. (Später packst Du die Strings ja sogar in ein Dictionary!)

Für das Menü (und den Lerneffekt) empfehle ich mal vollkommen unbefangen folgendes: Tutorial für Textmenüs

Du solltest *keinen* Code auf Modulebene stehen haben. Nutze den folgenden Trick:

Code: Alles auswählen

def main():
    # hier steht dann Dein Einstiegscode, der beim Starten ausgeführt werden soll

if __name__ == "__main__":
    main()

Die ganzen Metainformationen verpackt man besser in die dafür vorgesehenen Strukturen. Zum einen sind das Docstrings, die nach dem Sphinx Standard geschrieben sind, zum anderen spezielle Attribute von Modulen.

Hallo Hyperion, ich habe eben deinen Rat gefolgt, und dies versucht wie folgt umzusetzen. Ich will noch anmerken, dass ich mich an diesen Tipp https://github.com/Lysander/snippets/bl ... UTORIAL.md gehalten habe, was das Erstellen von Text-Menue betrifft.

Code: Alles auswählen

# Anwender soll sich einFeatur (Methode) aussuchen
def handle_menu(menu):
    while True:
        for index, item in enumerate(menu, 1):
            print("{}  {}".format(index, item[0]))
        choice = int(input("Ihre Wahl? ")) - 1
        if 0 <= choice < len(menu):
            menu[choice][1]()
        else:
            print("Bitte nur Zahlen im Bereich 1 - {} eingeben".format(
                                                                    len(menu)))

    handle_menu(menu)

def main():
    menu = [
        ["Beschaffungskalkulation(Vorwaerts)", BKV],
        ["Beschaffungskalkulation(Rueckwaerts)", BKVR],
        ["Differenzkalkulation", DK],
        ["Absatzkalkulation", AK],
        ["Beenden", quit]
    ]
    handle_menu(menu) # Aufruf der Funktion handle_menu() mit dem Argument menu, 
                                 # welcher hier in der Funktion als Objekt (oder doch Variable?) dient.

Der Code funktioniert zwar, aber nicht was funktioniert muss mit der Richtigkeit gleichbedeutend sein, richtig? Ich wollte nur wissen, ob ich hier richtig gehandelt habe oder etwas untypisch oder gar falsch ist?

[Sophus]

Hallo mutetella, ich habe mir eben die Mühe gemacht, und deine Replace-Funktion getestet, leider ohne Erfolg. hier mein Code:

Dann vergleiche noch einmal deinen Code mit dem von mutetella. Kleiner Tipp: Achte mal auf den Namen der Funktion von mutetella und die Reihenfolge der Operationen: Einlesen, Ersetzen, Umwandeln.

Hallo EyDu,

ich habe nochmal überprüft, es kommt natürlich keine Fehlermeldung, aber wirklich richtig arbeiten tut die Funktion auch nicht. Hier mein veränderter Code:

Code: Alles auswählen

def float_input(prompt):
    #KSK = float(raw_input("Eine Zahl mit Komma bitte: "))
    f = raw_input(prompt).replace(',', '.')
    try:
        return float(f)
    except ValueError:
        raise ValueError('Please give me a decimal!')

def main():
    Zahl = '100,00'
    float_input(Zahl)


if __name__ == "__main__":
    main()

Übergebe ich der Funktion float_input() die Variable (hier 100,00), so gibt die Funktion float_input() als Ergebis 100,00 aus. Es wird nicht ersetzt. Irgendwas mache ich falsch, oder?

[EyDu]

In "Zahl" wird nichts auf magische Weise ersetzt, Schon gar nicht vor dem Aufruf der Umwandlungsfunktion. Das wäre ja total verrücktes Verhalten. Versuche mal zu verstehen was "float_input" macht. Zerleg sie in Einzelschritte, lass dir die Zwischenergebnisse dazu ausgeben und zusätzlich dazu den Typ.

[Sophus]

In "Zahl" wird nichts auf magische Weise ersetzt, Schon gar nicht vor dem Aufruf der Umwandlungsfunktion. Das wäre ja total verrücktes Verhalten. Versuche mal zu verstehen was "float_input" macht. Zerleg sie in Einzelschritte, lass dir die Zwischenergebnisse dazu ausgeben und zusätzlich dazu den Typ.

Ich weiß zwar nicht, was du mit "[...]vor dem Aufruf der Umwandlungsfunktion", meinst, denn die Funktion main() wird hierbei zuerst aufgerufen, udn später die Funktion float_input, soweit ich das verstanden habe. Aber ich zerlege mal den Code mit Kommentaren, so wie ich sie verstehe:

Code: Alles auswählen

def float_input(prompt): # Funktion für die Umwandlung von Komma in Punkt

    f = raw_input(prompt).replace(',', '.') # f wird hier zum Objekt gemacht, damit man damit später arbeiten kann.
                                            # In der Eingabe (promt) wird nach bestimmten Zeichen durchsucht.
                                            # Wurde ein Komma gefunden, soll es durch einen Punkt ersetzt werden.
    try: # Ist eine Art Ausnahmebehandlung 
        return float(f) # Der Wert f soll als Float an die Funktion zurückgegeben werden
    except ValueError: # Bei einem Fehler wird ValueError rausgeworfen.
        raise ValueError('Please give me a decimal!')

def main(): # Damit kein Code auf der Modulebene steht. Sobald das Modul als Hauptprogramm gestartet wird, wird diese Funktion zuerst aufgerufen.
    
    Zahl = '100,00' # Die Variable mit einer Zahl füllen
    float_input(Zahl) # Funktion aufrufen, und die gefüllte Variable als ein Argument an die Funktion übergeben

if __name__ == "__main__":
    main()

[Sirius3]

@Sophus: der erste Kommentar ist schonmal komplett falsch. Die Funktion"float_input" ließt eine Zahl ein, die sowohl mit '.' als auch mit ',' geschrieben sein kann. Wo landet der Parameter "Zahl" aus Zeile 14 und was machst Du mit dem Rückgabewert?

[Sophus]

@Sophus: der erste Kommentar ist schonmal komplett falsch. Die Funktion"float_input" ließt eine Zahl ein, die sowohl mit '.' als auch mit ',' geschrieben sein kann. Wo landet der Parameter "Zahl" aus Zeile 14 und was machst Du mit dem Rückgabewert?

Hallo Sirius3, erstens, mag ich es nicht, wenn man so negativ wirkt, in dem man so theatralisch behauptet, der erste Kommentar sei sooooo falsch, sooo komplett falsch. Das raubt einem die Hoffnung, eben weil du so künstlich einen draufsetzt, und zweitens, welcher Kommentar ist falsch? Du schreibst "der erste Kommentar" sei falsch, demnach wäre es # Funktion für die Umwandlung von Komma in Punkt. Ist also def float_input keine Funktion/Methode, die dafür sorgt, dass bestimmte Zeichen (Kommata) durch einen Punkt ersetzt werden? Klär mich auf, anstatt nur zu sagen "dies und das sei falsch", aber keine Tatsache richtig stellen.

Aber nun zu deiner Frage: Da die Variable Zahl als Argument an die Funktion def float_input übergeben wird, landet sie (nach meiner Logik) bei prompt. Und prompt wird dann für die Verarbeitung weitergereicht, indem sie eingelesen bzw. durchsucht wird, und prompt wird dann als Wert zurückgegeben. Da aber der Name f an diesen replace gebunden ist, wird hierbei f als Wert zurückgegeben. Und dieser Wert landet dann nun im Objekt Wert, den ich jetzt im neuen Code eingebaut habe:

Code: Alles auswählen

def float_input(prompt):
    f = raw_input(prompt).replace(',', '.')
    try:
        return float(f)
    except ValueError:
        raise ValueError('Please give me a decimal!')

def main():
    Zahl = '100,00'
    Wert = float_input(Zahl) # Im Objekt Wert soll die Zahl landen
    print Wert # Ausgabe des Wertes
    
if __name__ == "__main__":
    main()

[BlackJack]

@Sophus: Schau Dir noch mal genau an was mit `prompt` gemacht wird. Das wird als Argument an `raw_input()` übergeben. Der Wert wird ansonsten in keinster Weise irgendwo weiterverarbeitet. Lies die Dokumentation von `raw_input()`, probier die Funktion gegebenfalls mal in einer Python-Shell aus mit verschiedenen Argumenten, und schlag die Übersetzung von `prompt` nach, insbesondere im Kontext von Computern.

[Sophus]

@Sophus: Schau Dir noch mal genau an was mit `prompt` gemacht wird. Das wird als Argument an `raw_input()` übergeben. Der Wert wird ansonsten in keinster Weise irgendwo weiterverarbeitet. Lies die Dokumentation von `raw_input()`, probier die Funktion gegebenfalls mal in einer Python-Shell aus mit verschiedenen Argumenten, und schlag die Übersetzung von `prompt` nach, insbesondere im Kontext von Computern.

Es ist ein Forum, richtig? Und es ist immer wieder erstauntlich zu lesen, wenn einem gesagt wird "geh mal auf diese und jene Seite" oder ähnliches liest. Man ist hier, weil man nicht weiterkommt. Und was ich hier sehr stark beobachte, ist, dass man nicht direkt auf mein Anliegen eingeht, sondern nur leichte Andeutungen macht und dann links liegen gelassen wird - am besten dann mit den bekanntesten Abwimmel-Antworten "Lies dir die Dokumentationen".

Nun, prompt landet in raw_input(), soweit bin ich ja schon weit am Anfang gekommen. Das ist nichts Neues für mich. Jedoch dachte ich, dass durch .replace jetzt in prompt nach Komma gesucht und die gesuchte Zeichen durch einen Punkt ersetzt werden. Sprechen wir doch mal ganz bildlich, ich habe hier einen Buchstaben A, und will diesen Buchstaben durch B ersetzen. Ich will am Ende nicht A sondern B, richtig?

Aber entschuldigt, dass ich gefragt habe, und nicht gleich die komplette Dokumentationen gelesen habe. Wie dumm von mir.

[EyDu]

Es ist ein Forum, richtig? Und es ist immer wieder erstauntlich zu lesen, wenn einem gesagt wird "geh mal auf diese und jene Seite" oder ähnliches liest. Man ist hier, weil man nicht weiterkommt. Und was ich hier sehr stark beobachte, ist, dass man nicht direkt auf mein Anliegen eingeht, sondern nur leichte Andeutungen macht und dann links liegen gelassen wird - am besten dann mit den bekanntesten Abwimmel-Antworten "Lies dir die Dokumentationen".

Nein, das verstehst du falsch. Wir möchten gerne, dass du dich mit deinem Code befasst und selbst lernst in der Dokumentation nachzulesen. Sonst lernst du dabei doch nichts. Außer vielleicht, dass du nicht mehr selber lesen musst, sonder einfach hier fragst. Wenn du Programmieren willst, dann musst du auch mit den dazugehörigen Werkzeugen klarkommen. Das lesen der Dokumentation ist dabei ein elementarer Bestandteil. Was meinst du, woher wir die Dinge wissen? Sicher nicht durch Fragen in einem Forum, das ist für so viel Information viel zu ineffektiv.

Ein weiterer Punkt ist, dass du Code einfach mal ausprobieren musst. Hier mal etwas ändern, da mal etwas ändern und schauen, ob das Verhalten mit den Erwartungen übereinstimmt. Und wenn nicht, warum nicht. Das machst du viel zu wenig. Deshalb habe ich ja oben extra geschrieben, dass du mal alles in kleine Schritte zerlegen sollst. Dann siehst du selbst, wo etwas nicht funktioniert. Wenn du etwas lernen willst, dann gehört das dazu. Wir sind hier ja keine billige Informationsquelle für dich, die du nach belieben anzapfen kannst und investieren hier unsere Freizeit. Und die ist sicher besser investiert wenn wir dir nicht alles vorkauen, sondern die entscheidenden Hinweise geben. Sonst könnten wir das Programm auch gleich für dich schreiben. Dann ist die eine Frage sicher schnell beantwortet, dafür kommst du dann mit zwei billigen hinterher, die du dir sonst hättest selbst leicht beantworten können.

Nun, prompt landet in raw_input(), soweit bin ich ja schon weit am Anfang gekommen. Das ist nichts Neues für mich. Jedoch dachte ich, dass durch .replace jetzt in prompt nach Komma gesucht und die gesuchte Zeichen durch einen Punkt ersetzt werden.

Nein, so ist es eben nicht. Gehe doch einfach mal in den interaktiven Interpreter und *benutze* raw_input dort, statt darüber zu spekulieren. Was gibt es aus, was passiert mit der Eingabe?

[Sophus]

Nein, so ist es eben nicht. Gehe doch einfach mal in den interaktiven Interpreter und *benutze* raw_input dort, statt darüber zu spekulieren. Was gibt es aus, was passiert mit der Eingabe?

Gut, fangen wir nochmal ganz grundlegend an. Mit raw_input() ist man dem input() etwas voraus. Denn mit dem bloßen input() würde man die Gefahr laufen, dass der Anwender nahezu beliebige Python-Code ausführen kann, da die Eingabe von seiten des Anwenders durchaus als Pyhton-Code gedeutet bzw. ausgewertet werden kann. Aus diesem Grunde - zumindest glaube ich das - nimmt man seit Python 2 raw_input(). Und mit float([x]) werden die eingegebenen Zeichenketten in Gleitkommazahlen umgewandelt.

So, und wie doll habe ich wieder einen Bock geschossen bzw. wie komplett falsch liege ich diesmal?

Ich habe das ganze mal anders versucht zu lösen, da die Lösung von mudella scheinbar nicht funktioniert: Kann man diesen Code so übernehmen, oder wären da noch Kritikpunkte anzuwenden?

Code: Alles auswählen

def float_input(KSK):
    f =  KSK.replace(",", ".") # Ausgabe: 100.00
    try:
        return float(f)
    except ValueError:
        raise ValueError('Please give me a decimal!')

def main():
    Zahl = '100,00'
    Wert = float_input(Zahl)
    print Wert

if __name__ == "__main__":
    main()

[BlackJack]

@Sophus: Warum heisst die Funktion `float_input()` wenn gar keine Eingabe darin vorkommt. Der Sinn war doch eigentlich eine Funktion zu haben die den Benutzer auffordert eine Gleitkommazahl einzugeben und diese dann zurück gibt.

[Sophus]

@Sophus: Warum heisst die Funktion `float_input()` wenn gar keine Eingabe darin vorkommt. Der Sinn war doch eigentlich eine Funktion zu haben die den Benutzer auffordert eine Gleitkommazahl einzugeben und diese dann zurück gibt.

Hallo BlackJack,

ich habe das ganze wie folgt gelöst, zumindest nach meinem Erkenntnisstand.

Modul: Kalkulationsformeln.py (Sammlung von Formeln und Funktionen)

Code: Alles auswählen

[...]
def float_input(Zahl):
    f =  Zahl.replace(",", ".") # Ausgabe: Das ist kein Text.
    try:
        return float(f)
    except ValueError:
        raise ValueError('Please give me a decimal!')

Hauptprogramm: Kalkulation.py

Code: Alles auswählen

import Kalkulationsformeln
[...]
def BKV():# Beschaffungskalkulation(Vorwaerts)
    print ""
    print " Die Beschaffungskalkulation(Vorwaerts) wurde gestartet."
    print ""
    LP = raw_input(" Listenpreis: ")
    LR = raw_input(" - Lieferantenrabatt (%): ")
    LP_f = Kalkulationsformeln.float_input(LP) # an die Funktion float_input() übergeben
    LR_f = Kalkulationsformeln.float_input(LR) # an die Funktion float_input() übergeben
    ZKP = Kalkulationsformeln.Zieleinkaufspreis(LP_f, LR_f) # nachdem die Werte eingelesen und die Zeichen ersetzt wurden
                                                                                 # diese dann für die Weiterverarbeitung benutzen.
    print " = Zieleinkaufspreis: ", str(ZKP) + " Euro"
    print "-----------------------"
[...]

Hier werden die Werte, die in der Funktion float_input() eingelesen, und die entsprechenden Zeichen ersetzt werden, für die Weiterverarbeitung benutzt. Hier in meinem Code werden also die Werte LP_f und LR_f für meine Berechnungen verarbeitet. Sieht ein Bisschen komisch aus, wenn ich die eingegenen Zeichenketten erst einmal durch die Funktion float_input(), und die Rückgabewerte anschließend durch die Funktion Zieleinkaufspreis() jage. Aber so kann ich die float_input()-Funktion an anderen Stellen benutzen. Na komm, sag schon, habe ich mal wieder blöd und unsauber und tooootaaaaaaaaal und gaaaaaanz und gaaaaar falsch gelöst Mach es so wie Sirius3

[EyDu]

Schau doch mal auf deine Zeilen 7 bis 10. Du machst zwei Abfragen und wandelst zweimal mit float_input um. Du machst also identische Dinge, das solltest du zusammenfassen. Jetzt wirst du noch einmal einen Blick auf den Funktionsnamen: float_input. float_input. float_input. float_input. Nun wirfst du einen Blick in die Funktion. Was fehlt?

[Sophus]

Schau doch mal auf deine Zeilen 7 bis 10. Du machst zwei Abfragen und wandelst zweimal mit float_input um. Du machst also identische Dinge, das solltest du zusammenfassen. Jetzt wirst du noch einmal einen Blick auf den Funktionsnamen: float_input. float_input. float_input. float_input. Nun wirfst du einen Blick in die Funktion. Was fehlt?

Willst du mir sagen, dass die Namensgebung der Funktion unangebracht ist, weil dort Input steht?

[Sophus]

Schau doch mal auf deine Zeilen 7 bis 10. Du machst zwei Abfragen und wandelst zweimal mit float_input um. Du machst also identische Dinge, das solltest du zusammenfassen.

Zum Thema "zusammenfassen" habe ich mir folgendes überlegt und mir ist dabei was aufgefallen:
Modul: Kalkulationsformeln.py

Code: Alles auswählen

[...]
def Replacer(prompt):
    f =  prompt.replace(",", ".") # Ausgabe: Das ist kein Text.
    try:
        return float(f)
    except ValueError:
        raise ValueError('Please give me a decimal!')
    
def Replacer1(Zahl, Zahl1):
    f1 =  Zahl.replace(",", ".")
    f2 =  Zahl1.replace(",", ".")
    try:
        return float(f1), float(f2)
    except ValueError:
        raise ValueError('Please give me a decimal!')
[...]

Es gibt in der Kalkulation Stellen, da muss man nur eine, und Stellen, da muss man mehrere Eingaben machen. Demzufolge muss ich zwei Funktionen schreiben, einmal eine Funktion mit einem Rückgabewert, und eine Funktion mit mehreren Rückgabewerten. Bläht sich dadurch das Modul nicht unnötig auf?

Hauptprogramm: Kalkulation.py

Code: Alles auswählen

import Kalkulationsformeln
[...]
def BKV():# Beschaffungskalkulation(Vorwaerts)
    print ""
    print " Die Beschaffungskalkulation(Vorwaerts) wurde gestartet."
    print ""
    LP = raw_input(" Listenpreis: ")
    LR = raw_input(" - Lieferantenrabatt (%): ")
    Wert = Kalkulationsformeln.Replacer1(LP, LR) # Übergabe mehrerer Werte
    ZKP = Kalkulationsformeln.Zieleinkaufspreis(Wert[0], Wert[1]) # Die beiden Rückgabewerte [0] und [1] verarbeiten
    print " = Zieleinkaufspreis: ", str(ZKP) + " Euro"
[...]

[EyDu]

Naja, falsch zusammengefasst In "Replacer1" wiederholst du dich wieder. Zu ersetzt an zwei Stellen das Komma durch einen Punkt und wandelst an zwei Stellen den Wert in einen float um. Was würdest du bei 100000 Zahlen machen? Zusätzlich hast du jetzt auch noch an zwei Stellen die Eingaben. mutetella hat dir auf Seite 1 ja bereits die Musterlösung gezeigt.

[Sophus]

Naja, falsch zusammengefasst In "Replacer1" wiederholst du dich wieder. Zu ersetzt an zwei Stellen das Komma durch einen Punkt und wandelst an zwei Stellen den Wert in einen float um. Was würdest du bei 100000 Zahlen machen? Zusätzlich hast du jetzt auch noch an zwei Stellen die Eingaben. mutetella hat dir auf Seite 1 ja bereits die Musterlösung gezeigt.

Also mit mutetellas Musterlösung möchte ich erst einmal nicht arbeiten, weil ich erst einmal meinen Code auf die Reihe kriegen will Und das ich mich in "Replacer1" wiederhole, ist mir auch aufgefallen, jedoch muss ich das ja auch tun. Immerhin gibt es ja unterschiedliche Anzahlen von Rückgabewerten? Mhmh?

[pillmuncher]

@sophus: schau dir mal das hier an: http://www.python-forum.de/pastebin.php?mode=view&s=414

[snafu]

@sophus: schau dir mal das hier an: http://www.python-forum.de/pastebin.php?mode=view&s=414

Das Definieren der Hilfsfunktionen ist eine gute Idee. Die einzelnen Kalkulationen hätte ich aber wohl eher mit einer abstrakten Funktion verwirklicht, die als Parameter den gewünschten Prompt und eine Berechnungsfunktion erwartet. Für letzteres kann man prima Pythons `lambda`-Schlüsselwort einsetzen.

Die abstrakte Funktion würde sich dann um die Abfrage und Aufbereitung der Benutzereingabe sowie um die Anwendung der übergebenen Berechnungsfunktion auf diese Eingabe kümmern und das Ergebnis der Berechnung ausspucken. Um die Formatierung der Rückgabe hätte sich der Aufrufer zu kümmern.

Mit diesem Vorschlag möchte ich übrigens nicht behaupten, dass dein Ansatz völlig falsch sei. Dein Code fühlt sich im Hinblick auf den Anwendungsfall aber doch ziemlich "noisy" an. Ich würde eine etwas direktere Herangehensweise bevorzugen, anstatt die Zwischenschicht durch die `calculate_*`-Funktionen zu haben.