Mein erstes kleines Programm...

[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.

[Sophus]

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

Hallo, pillmuncher,

ich werde mir deinen Vorschlag morgen genauer anschauen. Auf dem ersten Blick wirkt es auf einen Anfänger sehr erschlagend Aber eine Frage mal zwischendurch: Wieso habt ihr immer den Drang auf englisch zu schreiben bzw. die Funktionen englische Namen zu geben? Dies ist für mich insofern befremdlich, weil wir hier nicht international "arbeiten". Ich finde es ja schön, dass man sein Englisch immer ein Bisschen auffrischen will, aber für meinen Geschmack wirkt es überzogen

[pillmuncher]

Wieso habt ihr immer den Drang auf englisch zu schreiben bzw. die Funktionen englische Namen zu geben? Dies ist für mich insofern befremdlich, weil wir hier nicht international "arbeiten". Ich finde es ja schön, dass man sein Englisch immer ein Bisschen auffrischen will, aber für meinen Geschmack wirkt es überzogen

• Englisch ist die lingua franca der Informatik.
• Englisch ist meist kürzer und prägnanter.
• So gut wie alle Dokumentation ist in Englisch. Wenn ich Dokumentation lese und das gelesene auf meinen Code anwenden will, dann habe ich, wenn ich dabei die Sprache in der ich denke wechsle, auch einen Kontextwechsel. Das erzeugt unnützen mentalen Reibungswiderstand.
• Die Namen der Schlüsselworte der allermeisten Programmiersprachen sind englische Worte. Ebenso die ihrer Standardfunktionen. Ebenso die der allermeisten Bibliotheken. Auch hier gilt, was ich zu Kontextwechsel geschrieben habe.
• Außerdem, if ich read einen source, der two Sprachen mixed, finde I das very irritierend. Dann lieber gleich alles auf Deutsch:

Code: Alles auswählen

aus __zukunft__ importiere teilung, druck_funktion
 
aus dezimal importiere Dezimal, ABRUNDEN
 
 
def geld_betrag(dezimal):
    gib_zurück dezimal.quantisiere(Dezimal('.01'), runden=ABRUNDEN)
 
 
def addiere_prozent(betrag, prozent):
    gib_zurück geld_betrag(betrag + betrag * prozent)
 
 
def subtrahiere_prozent(betrag, prozent):
    gib_zurück geld_betrag(betrag - betrag * prozent)
 
 
def frage_nach_geld_betrag(eingabeaufforderung):
    gib_zurück geld_betrag(Dezimal(rohe_eingabe(eingabeaufforderung + ': ').ersetze(',', '.')))

Ist halt dann kein Python mehr.

Auch lustig:

Code: Alles auswählen

क = 1;
कुल = 0;
जब तक क छोटा है 10 से  {
    कुल += क;
}
छापो कुल

कार्य खाली मुख्य ( )      अंक समय       लिखें "Enter current time"    
     पढें समय        अगर [ समय < 12 ]    
        लिखें "Good Morning"    
  वरनाअगर [ समय >= 12 और समय < 16 ]    
           लिखें "Good Afternoon"    
  वरना              लिखें "Good Evening"    
  खत्म अगर    
खत्म कार्य

[Hyperion]

@Sophus: Das mit dem Menü sieht gut aus - ich hoffe Du hast das auch an sich verstanden

[BlackJack]

Es gab ja mal die deutsche Programmiersprache Teuton die eine Art Präprozessor für Python ist.

Ein weiterer praktischer Grund für Englisch ist die Namensvergabe für Exemplare von Datencontainer-Typen wie Listen & Co: Wenn man für die Bezeichnung die Mehrzahl von dem nimmt wie man ein einzelnes Element nennen würde, dann funktioniert das im Englischen so gut wie immer problemlos, während es im Deutschen doch relativ viele Fälle gibt wo Einzahl und Mehrzahl die gleiche Bezeichnung haben.

Ebenfalls problematisch ist die Möglichkeit für zwei verschiedene Dinge die gleiche Bezeichnung in zwei verschiedenen Sprachen im gleichen Namensraum zu haben. Das finde ich sehr verwirrend.

[Sophus]

@Sophus: Das mit dem Menü sieht gut aus - ich hoffe Du hast das auch an sich verstanden

Hallo Hyperion, das mit dem Menu habe ich relativ gut aufgenommen. Vielen Dank dafür.

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

• Englisch ist die lingua franca der Informatik.
• Englisch ist meist kürzer und prägnanter.
• So gut wie alle Dokumentation ist in Englisch. Wenn ich Dokumentation lese und das gelesene auf meinen Code anwenden will, dann habe ich, wenn ich dabei die Sprache in der ich denke wechsle, auch einen Kontextwechsel. Das erzeugt unnützen mentalen Reibungswiderstand.
• Die Namen der Schlüsselworte der allermeisten Programmiersprachen sind englische Worte. Ebenso die ihrer Standardfunktionen. Ebenso die der allermeisten Bibliotheken. Auch hier gilt, was ich zu Kontextwechsel geschrieben habe.
• Außerdem, if ich read einen source, der two Sprachen mixed, finde I das very irritierend. Dann lieber gleich alles auf Deutsch:

Hallo pillmuncher, das Englisch mittlerweile eine Weltsprache ist, ist mir durchaus einleuchtend An sich habe ich auch nichts dagegen. Aber ich denke mir folgendes: Ich bin in einem deutschen Forum, unterhalte mich hier mit deutschen Bürgern, wieso also das "krampfhafte" Englisch? Wenn ich ein Programm schreiben würde, an welcher Menschen aus aller Welt arbeiten, sehe ich das vollkommen ein, dass man sich sowohl in der Programmiersprache (englische Variablen, englische Namensgebungen) als auch außerhalb der Programmierwelt (Kommentare, Besprechungen) auf Englisch verständigt. Aber lasst uns nicht darauf aufhalten. Ich musste nur etwas schmunzeln.