Mein erstes kleines Programm...

[Sophus]

Modul: Kalkulationsformeln.py

Code: Alles auswählen

[...]
def Ersetzer(*Zahl): # beliebig viele Parameter
    f =  Zahl.replace(",", ".") 
    try:
        return float(f)
    except ValueError:
        raise ValueError('Dezimalzahlen bitte!')
[...]

Meine Idee war, beliebig viele Parameter entgegen zu nehmen. Es kann ja sein, dass ich a priori nicht weiß, wie viele Parameter es werden wird.

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.Ersetzer(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"
[...]

Fehlermeldung

Traceback (most recent call last):
File "D:\Dan\Python\Übung\Calc\Kalkulation.py", line 165, in <module>
main()
File "D:\Dan\Python\Übung\Calc\Kalkulation.py", line 161, in main
handle_menu(menu)
File "D:\Dan\Python\Übung\Calc\Kalkulation.py", line 145, in handle_menu
menu[choice][1]()
File "D:\Dan\Python\Übung\Calc\Kalkulation.py", line 30, in BKV
Wert = Kalkulationsformeln.Replacer(LP, LR)
File "D:\Dan\Python\Übung\Calc\Kalkulationsformeln.py", line 7, in Replacer
f = Zahl.replace(",", ".") # Ausgabe: Das ist kein Text.
AttributeError: 'tuple' object has no attribute 'replace'

Wie ich also sehe, hat Tuple ein Problem mit dem Attribut "Replace". Wäre auch zu schön gewesen, wenn es mal auf Anhieb klappt Gibt es in Python eine Art "Collection"? In VB6 kann man sehr gut mit "Collection" arbeiten. Dort sammelt man alle Daten und verarbeitet sie. So wollte ich das auch in der Funktion Ersetzer machen.

[Üpsilon]

du suchst das sprachmittel der list-comprehension. damit kannst du auf alle elemente einer liste eine funktion anwenden. https://docs.python.org/2/tutorial/data ... rehensions

Ersetzer ist übrigens ein komischer name. nenn es string_to_float oder so.

[BlackJack]

@Sophus: Ergänzend zum Namen: Funktionen und Methoden bekommen üblicherweise Tätigkeiten als Namen weil die etwas tun. Bezeichnungen von ”Dingen” im weitesten Sinne sind für Klassennamen. Und nur Klassennamen und Konstantennamen fangen mit einem Grossbuchstaben an, bei Konstanten geht's komplett in Grossbuchstaben weiter. Alles andere `keinbuchstaben_mit_unterstrichen_als_trenner`.

Wie schon gesagt werden Container in der Regel in der Mehrzahl benannt. Deshalb ist `zahl` für etwas das keine Zahl ist, sondern eine Sequenz von Zahlen, ein schlechter Name.

Mit ``*``-Magie bei Funktionargumenten sollte man sparsam umgehen. Das verbaut einem Möglichkeiten die API zu ändern/zu erweitern, und man kann die Funktion ohne ``*`` beim Aufruf nur manuell mit einzelnen Argumenten füttern. Wenn das dazu führt das man im Regelfall bei der Funktionsdefinition *und* beim Aufruf ein ``*`` braucht, dann kann man es auch gleich bei beiden Stellen weglassen und der Funktion an der Stelle einfach eine Liste oder etwas anderes in der Richtung übergeben.

In diesem speziellen Fall halte ich das auch für keine gute Schnittstelle. Denn wenn man diese Funktion für *einen* Wert schreibt, lässt der sich trivial mit der schon erwähnten „list comprehension”, oder mit der `map()`- oder `itertools.imap()`-Funktion auf Sequenzen von Werten anwenden.

[pillmuncher]

@snafu: Berachte meinen Code als Instanz von Uncle Bob's Clean Architecture.

Im Zentrum sind die Entities, das sind hier einfach Dezimalzahlen und Funktionen darauf (calculate_*()). Diese Funktionen werden mithilfe von Hilfsfunktionen implementiert, die bestimmte Regeln der Geschäftslogik aufrechterhalten, zB. dass Geldbeträge immer auf zwei Kommastellen gerundet werden, dass das Runden immer ein Abrunden ist, dass als Ergebnis einer Prozentrechnung ein Geldbetrag herauskommt, wenn diese auf einen Geldbetrag angewendet wird, und dass dabei entsprechend der o.g. Regeln gerundet wird. Sollte eine Regel geändert werden müssen, dann braucht man nicht den gesammten Code zu durchsuchen um alle Implementierungen der Regel zu ändern, sondern es gibt nur genau eine Stelle, die man ändern muss und der gesammte Code verwendet dann die geänderte Regel.

Dazu gibt es in der Präsentationsschicht Hilfsfunktionen, die Werte ausspucken, die direkt von den darunterliegenden Schichten verwendet werden können, ohne dass dort Konversionen oder Validierungen vorgenommen werden müssten. Auch die o.g. Regeln werden dort gleich auf die eingegebenen Werte angewendet.

Zwischen der allgemeinen Geschäftslogik (calculate_*()) und der Präsentationsschicht (ask_*(), show()) gibt es die Schicht der Use Cases. Das sind Funktionen wie beschaffungskalkulation(). Diese Schicht beschreibt anwendungsbezogene Geschäftsregeln, kommuniziert mit der darunterliegenden allgemeinen Geschäftslogik und sorgt dafür, dass Ein- und Ausgaben angestoßen werden (unter Zuhilfenahme der Funktionen der Präsentationsschicht).

Als Ergebnis bekommt man ein System, in dem Entities sich nicht um IO kümmern müssen, eine Präsentationsschicht, die nur ein paar sehr allgemeine Regeln beachten muss (zB. beim Runden) und eine Schicht von Use Cases, die nur über genau definierte Interfaces mit den anderen Schichten kommuniziert. An jeder Stelle können Implementierungen geändert werden, ohne dass dies die Klienten der Module interessieren müsste.

Interessant ist dabei auch, dass der IO soz. "umgestülpt" wird. IO findet nicht irgendwo in den Tiefen der allgemeinen Geschäftslogik statt, sondern auf der Ebene der Use Cases, wo es hingehört ("um ... zu berechnen, gibt der Benutzer die Werte ... und ... ein und erhält als Ergebnis ...").

Um die Implementierungen der Use Cases noch stärker von der Präsentationsschicht zu trennen, könnte man die IO-Funktionen als Callbacks übergeben:

Code: Alles auswählen

def beschaffungskalkulation(ask_for_money_amount, ask_for_percentage, show):
 
    zieleinkaufspreis = calculate_zieleinkaufspreis(
        listenpreis=ask_for_money_amount('Listenpreis'),
        lieferanten_rabatt=ask_for_percentage('Lieferantenrabatt'),
    )
    show('Zieleinkaufspreis', zieleinkaufspreis)
    ...

Oder als Objekt mit entsprechenden Methoden. Wenn man auf diese Weise die Trennung der Schichten vornimmt, dann kann man zB. auch eine GUI darüberlegen. Die ask_*() und show() Funktionen würden in diesem Fall einfach bestimmte Felder der GUI auslesen bzw. aktualisieren. Oder man könnte verschiedene Szenarien aus einem Spreadsheet generieren[*]:

Code: Alles auswählen

column_map = {
    'Listenpreis': 'A',
    'Lieferantenrabatt': 'B',
    'Zieleinkaufspreis': 'C',
    ...
}

def get_money_value(sheet, row, fieldname):
    return money_amount(sheet.get(row=row, column=column_map[fieldname]))

def get_percent_value(sheet, row, fieldname):
    return float(sheet.get(row=row, column=column_map[fieldname]))

def set_value(sheet, row, fieldname, value):
    sheet.set(row=row, column=column_map[fieldname], value=value)

from functools import partial

for row in spreadsheet.rows():
    beschaffungskalkulation(
        ask_for_money_amount=partial(get_money_value, spreadsheet, row),
        ask_for_percentage=partial(get_percent_value, spreadsheet, row),
        show=partial(set_value, spreadsheet, row),
    )

Praktisch, oder?

[*] Ja, ich weiß, dass Excel das auch ohne Python kann. Mir geht es darum, den Sinn dieser Architektur zu illustrieren.

[Sophus]

du suchst das sprachmittel der list-comprehension. damit kannst du auf alle elemente einer liste eine funktion anwenden. https://docs.python.org/2/tutorial/data ... rehensions

Ersetzer ist übrigens ein komischer name. nenn es string_to_float oder so.

Hallo Üpsilon, im Hinblick auf die sogenannte List-Comprehension habe ich mir folgendes überelgt:
Beispiel:

Code: Alles auswählen

def Umwandlung(*Parameter):
    Liste = []
    [Liste.append(Elemente)
     for Elemente in Parameter
     if not Liste.count(Elemente)]
    return Elemente 
    
def main():
    Zahl = [
    "5,2",
    "7,0",
    "8.0",
    "2,6"
    ]
    
    Ergebnis = Umwandlung(Zahl)
    print Ergebnis # Ausgabe [['5,2', '7,0', '8.0', '2,6']]

if __name__ == "__main__":
    main()

Nun dachte ich mir, da er mir prima all meine Parameter in Form einer Liste zurückgibt, könnte man nun den Inhalt der Liste einlesen und die entsprechenden Zeichen ersetzen. Die einzelnen Objekte in der Liste habe ich dann "Elemente" genannt. Also sieht mein Code wie folgt aus:

Code: Alles auswählen

# -*- coding: cp1252 -*-
def Umwandlung(*Parameter):
     Liste = []
     for Elemente in Parameter:
         f =  Elemente.replace(",", ".") 
         if not Liste.count(Elemente):
             Liste.append(Elemente)
     return float(f)
    
def main():

    Zahl = [
    "5,2",
    "7,0",
    "8.0",
    "2,6"
    ]
    
    Ergebnis = Umwandlung(Zahl)
    print Ergebnis

if __name__ == "__main__":
    main()

Ich habe das "Replace" also in eine For-Schleife gepackt. Aber irgendwie mag die Liste Replace auch nicht. Hier die Fehlermeldung:

Traceback (most recent call last):
File "D:\Dan\Python\Übung\Calc\Neues Textdokument.py", line 26, in <module>
main()
File "D:\Dan\Python\Übung\Calc\Neues Textdokument.py", line 22, in main
Ergebnis = colapse(Zahl)
File "D:\Dan\Python\Übung\Calc\Neues Textdokument.py", line 6, in colapse
f = Element.replace(",", ".") # Ausgabe: Das ist kein Text.
AttributeError: 'list' object has no attribute 'replace'

[Üpsilon]

Code: Alles auswählen

    [Liste.append(Elemente)
     for Elemente in Zahlen
     if not Liste.count(Elemente)]

Da biste durcheinandergekommen. In der LC muss man eben *kein* append machen.

Ich meinte eher Folgendes: nimm wieder deine alte Umwandlungsfunktion ohne den *, und wenn du eine Liste von Strings zu Zahlen machen willst, tust du folgendes:

Code: Alles auswählen

[umwandlung(zahl) for zahl in zahlen]

So ähnlich solltest du die Variablennamen auch vergeben, wie Bj schon schrieb.

Edit: Kann es sein, dass du denkst, LCs wären ein eigener Datentyp? Das ist nicht der Fall, LCs sind ne Technik zum Erstellen normaler Listen.

[Sophus]

Code: Alles auswählen

    [Liste.append(Elemente)
     for Elemente in Zahlen
     if not Liste.count(Elemente)]

Da biste durcheinandergekommen. In der LC muss man eben *kein* append machen.

Ich meinte eher Folgendes: nimm wieder deine alte Umwandlungsfunktion ohne den *, und wenn du eine Liste von Strings zu Zahlen machen willst, tust du folgendes:

Code: Alles auswählen

[umwandlung(zahl) for zahl in zahlen]

So ähnlich solltest du die Variablennamen auch vergeben, wie Bj schon schrieb.

Edit: Kann es sein, dass du denkst, LCs wären ein eigener Datentyp? Das ist nicht der Fall, LCs sind ne Technik zum Erstellen normaler Listen.

In VB6 gibt es eine Art Container, und die nennen wir Collection. Dort kann man alle Objekte hinlegen, und diese dann direkt ansprechen. Und da ich den LC wie einen Container betrachte, dachte ich, kann man auf die einzelnen Daten/Objekte innerhalb dieses Containers zugreifen. Demzufolge wollte ich die Objekte in diesem Container einlesen und die entsprechenden Zeichen ersetzen.

Nun zu dir, ich will meine Liste von Strings nicht zu Zahlen machen, sondern, die Zeichenketten einlesen und die entsprechenden Zeichen ersetzen. Ich habe gehofft, dass ich mir diesen Zwischenschritt sparen könnte. Ist ein direkter Weg nicht möglich? Müssen die Strings erst in Zahlen "umgewandelt" werden, ehe man bestimmte Zeichen in einem String durch andere Zeichen ersetzen kann?

[pillmuncher]

Code: Alles auswählen

def Umwandlung(*Parameter):
    Liste = []
    [Liste.append(Elemente)
     for Elemente in Zahlen
     if not Liste.count(Elemente)]
    return Liste 
    
def main():
    Zahl = [
    "5,2",
    "7,0",
    "8.0",
    "2,6"
    ]
    
    Ergebnis = Umwandlung(Zahl)
    print Ergebnis # Ausgabe [['5,2', '7,0', '8.0', '2,6']]

if __name__ == "__main__":
    main()

Einen Paramter Parameter zu nennen ist nicht sinnvoll. Dass es ein Parameter ist, sehe ich daran, dass er syntaktisch an einer Stelle steht, die ihn zum Parameter macht. Wenn ich Code lese will ich aber wissen, was der Parameter im Programm für eine Bedeutung hat. Ein Parameter, der eine Zahl beinhaltet, repräsentiert dann zB. das Alter einer Person. Dann sollte man ihn alter nennen, aber nicht parameter. Übrigens sollte man ihn auch nicht zahl nennen. Denn wenn ich das lese, weiß ich nur den Typ des Parameters, aber nicht, was die Zahl bedeutet. Das Alter? Die Größer einer Person in cm? Den mittleren Abstand der Person von Betelgeuze?

Und der * vor Parameter ... warum steht der da? Das x in def f(*x): beinhaltet ein Tupel, dass die übergebenen Argumente als Elemente hat. In deinem Fall also ein Tupel, dass als erstes (und einziges) Element eine Liste von Strings besitzt. Also das hier:

Code: Alles auswählen

(["5,2", "7,0", "8.0", "2,6"],)

Wenn ich auf das dritte Element der Liste zugreifen möchte, muss ich das folglich so tun:

Code: Alles auswählen

x = Parameter[0][2]

Das Ergebnis ist dann "8.0". Auch das ist übrigens keine Zahl, sondern ein String, der Buchstaben enthält, aus denen zB. die Funktion float() eine Zahl erzeugen kann:

Code: Alles auswählen

>>> type("8.0")
<type 'str'>
>>> float("8.0")
8.0
>>> type(float("8.0"))
<type 'float'>

Als nächstes die List Comprehension (LC). Eine LC benötigt kein append(). Hier zum Vergleich ohne LC:

Code: Alles auswählen

>>> zahl_strings = ["5.2", "7.0", "8.0", "2.6"]
>>> zahlen = []
>>> for each in zahl_strings:
...     print each, ':', type(each)
...
5.2 : <type 'str'>
7.0 : <type 'str'>
8.0 : <type 'str'>
2.6 : <type 'str'>
>>> for each in zahl_strings:
...     zahlen.append(float(each))
...
>>> for each in zahlen:
...     print each, ':', type(each)
...
5.2 : <type 'float'>
7.0 : <type 'float'>
8.0 : <type 'float'>
2.6 : <type 'float'>

Und hier mit LC:

Code: Alles auswählen

>>> zahlen = [float(each) for each in zahl_strings]
>>> for each in zahlen:
...     print each, ':', type(each)
...
5.2 : <type 'float'>
7.0 : <type 'float'>
8.0 : <type 'float'>
2.6 : <type 'float'>

Wenn du die Kommata in den Strings zu Dezimalpunkten umwandeln und danach aus dem Ergebnis eine Zahl zu erzeugenmöchtest, dann kannst du das einfach so machen:

Code: Alles auswählen

>>> zahl_strings = ["5,2", "7,0", "8.0", "2,6"]
>>> zahlen = [float(each.replace(',', '.')) for each in zahl_strings]
>>> for each in zahlen:
...     print each, ':', type(each)
...
5.2 : <type 'float'>
7.0 : <type 'float'>
8.0 : <type 'float'>
2.6 : <type 'float'>

[Sophus]

Hallo pillmuncher, ich habe mich an deinem Beispiel gehalten und es wie folgt umgesetzt (ignorieren wir jetzt mal die sinnlosen Namensgebungen):

Code: Alles auswählen

# -*- coding: cp1252 -*-
def umandeln(Parameter):
    f = [float(Elemente.replace(',', '.')) for Elemente in Parameter]
    for Elemente in f:
          return Elemente

def main():
    Zahlen = [
    "5,2",
    "7,0",
    "8.0",
    "2,6"
    ]
    n = len(Zahlen) # Anzahl der Einträge aus der Liste Zahlen erfahren
    
    Ergebnis = umandeln(Zahlen) # An die Funktion die Zahlen aus der Liste Zahlen übergeben
    Rueckgabe = umandeln(Ergebnis[0-n])   # Da ich nicht nur einen bestimmten Eintrag zurückhaben will,
                                        # sondern so viele, wie in der Liste waren, also benutze ich hier n (hier: 0-4 Einträge - also alle Einträge)
    print Rueckgabe
    
if __name__ == "__main__":
    main()

Fehlermeldungen:

Traceback (most recent call last):
File "D:\Dan\Python\Übung\Calc\Neues Textdokument.py", line 22, in <module>
main()
File "D:\Dan\Python\Übung\Calc\Neues Textdokument.py", line 17, in main
Rueckgabe = umandeln(Ergebnis[n]) # Da ich nicht nur einen bestimmten Eintrag zurückhaben will,
TypeError: 'float' object has no attribute '__getitem__'

[Üpsilon]

Du erinnerst mich an jemanden, der mal mit mir im Informatik-Wahlfach war. Der war auch so n Kandidat, ey..

Wenn in einer Funktion return gemacht wird, dann ist die Funktion fertig gelaufen. Das, was du hier probierst, macht man afaik mit yield. Aber egal. In Wirklichkeit willst du doch die ganze Liste zurückgeben!

liste[0-n] macht übrigens etwas völlig anderes, als du denkst. Auch hier willst du die ganze Liste übergeben.

Lies meine Signatur!

[Sophus]

Du erinnerst mich an jemanden, der mal mit mir im Informatik-Wahlfach war. Der war auch so n Kandidat, ey..

Wenn in einer Funktion return gemacht wird, dann ist die Funktion fertig gelaufen. Das, was du hier probierst, macht man afaik mit yield. Aber egal. In Wirklichkeit willst du doch die ganze Liste zurückgeben!

liste[0-n] macht übrigens etwas völlig anderes, als du denkst. Auch hier willst du die ganze Liste übergeben.

Verdammt, ich sehe schon was du meinst. Das ich quasi zwei Mal eine Rückgabe erwarte, obwohl die Funktion schon längst fertig ist.

Aber meine Modifkation macht es trotzdem nicht leichter:

Code: Alles auswählen

# -*- coding: cp1252 -*-
def umandeln(Parameter):
    f = [float(Elemente.replace(',', '.')) for Elemente in Parameter]
    for Elemente in f:
          return Elemente

def main():
    Zahlen = [
    "5,2",
    "7,0",
    "8.0",
    "2,6"
    ]
    n = len(Zahlen) # Anzahl der Einträge aus der Liste Zahlen erfahren
    
    Ergebnis = umandeln(Zahlen[0-n])-1        # An die Funktion die Zahlen aus der Liste übergeben
                                              # Da ich nicht nur einen bestimmten Eintrag zurückhaben will,
                                              # sondern so viele, wie in der Liste waren, benutze ich hier n
                                              # Da man in der Liste wie folgt Zählt: 0, 1, 2 etc. also mit der
                                              # Zahl Null beginnt, muss ich 1 von n abziehen.
    print Ergebnis
    
if __name__ == "__main__":
    main()

Fehlermeldung:

Traceback (most recent call last):
File "D:\Dan\Python\Übung\Calc\Neues Textdokument.py", line 24, in <module>
main()
File "D:\Dan\Python\Übung\Calc\Neues Textdokument.py", line 16, in main
Ergebnis = umandeln(Zahlen[0-n])-1 # An die Funktion die Zahlen aus der Liste übergeben
File "D:\Dan\Python\Übung\Calc\Neues Textdokument.py", line 3, in umandeln
f = [float(Elemente.replace(',', '.')) for Elemente in Parameter]
ValueError: could not convert string to float: .

[pillmuncher]

ignorieren wir jetzt mal die sinnlosen Namensgebungen

Lieber nicht. Elemente sind zB. keine Elemente, sondern nur ein einziges Element. Zur Veranschaulichung: "Guten Tag, darf ich Ihnen meine Frauen vorstellen? Ihre Namen sind Christine". "Meine Autos habe ich vor der Tür geparkt. Es sind VWs." - "Wieviele Autos haben sie denn?" - "Na eines!".

Namen sind in der Programmierung nicht Schall und Rauch. Guckstu:

Code: Alles auswählen

def a(b):
    c = [float(d.replace(',', '.')) for d in b]
    for e in c:
          return e

Oder:

Code: Alles auswählen

def giesskannen(albatross):
    schlafanzug = [float(liebe_und_gesetze.replace(',', '.')) for liebe_und_gesetze in albatross]
    for genesungswuensche in schlafanzug:
          return genesungswünsche

Ein Klassiker der informatischen Aphorismen ist dieser von Phil Karlton:

There are only two hard things in Computer Science: cache invalidation and naming things.

Die richtige Benennung von Dingen ist nicht etwas nebensächliches, oder kosmetisches, was man hinterher anflanschen könnte sobald alles läuft. Die richtige Benennung von Dingen ist die Basis dafür, etwas überhaupt richtig programmieren zu können. Und es betrifft eben nicht in erster Linie andere Personen, die deinen Source Code verstehen wollen, sonder dich selber. Wenn du etwas nicht vernünftig benennen kannst, ist das ein starkes Indiz dafür, dass du es nicht verstanden hast, und dann kannst duch auch nichts richtiges damit programmieren. Solange du dir dein Leben selber so schwer machst, kann ich dir nicht helfen.

Aber dieser Hinweis noch: zurecht hast du festgestellt, dass das return im for-Loop nicht das Ergebnis liefert, das du zunächst erwartet hast. Dann aber eine neue Version zu programmieren, die genau denselben Fehler wieder beinhaltet, erinnert mich an den Betrunkenen, der Nachts unter einer Straßenlaterne seinen Schlüssel sucht. Auf die Frage eines Passanen, wo er in denn verloren habe, antwortet er: "Da drüben im Dunkeln". Aber warum er denn dann hier suche? "Na, hier sieht man wenigstens etwas".

[Sophus]

Ein Klassiker der informatischen Aphorismen ist dieser von Phil Karlton:

There are only two hard things in Computer Science: cache invalidation and naming things.

Die richtige Benennung von Dingen ist nicht etwas nebensächliches, oder kosmetisches, was man hinterher anflanschen könnte sobald alles läuft. Die richtige Benennung von Dingen ist die Basis dafür, etwas überhaupt richtig programmieren zu können. Und es betrifft eben nicht in erster Linie andere Personen, die deinen Source Code verstehen wollen, sonder dich selber. Wenn du etwas nicht vernünftig benennen kannst, ist das ein starkes Indiz dafür, dass du es nicht verstanden hast, und dann kannst duch auch nichts richtiges damit programmieren. Solange du dir dein Leben selber so schwer machst, kann ich dir nicht helfen.

Aber dieser Hinweis noch: zurecht hast du festgestellt, dass das return im for-Loop nicht das Ergebnis liefert, das du zunächst erwartet hast. Dann aber eine neue Version zu programmieren, die genau denselben Fehler wieder beinhaltet, erinnert mich an den Betrunkenen, der Nachts unter einer Straßenlaterne seinen Schlüssel sucht. Auf die Frage eines Passanen, wo er in denn verloren habe, antwortet er: "Da drüben im Dunkeln". Aber warum er denn dann hier suche? "Na, hier sieht man wenigstens etwas".

Verzeih, wenn ich euch zu Nahe gekommen bin oder euch das Gefühl vermittel, dass ich Python nicht ernst nehme. Ich habe es wie folgt betrachtet: Wir besprechen hier einen minimalen Schnipsel, welcher zum einen völlig aus dem Kontext gezogen worden ist und zum anderen sehr übersichtlich ist. Aus diesem Grund sah ich mich nicht dazu veranlasst um die sinnvollen Namensgebung zu kümmern. Durchaus weiß ich aber, dass bei Projekten, welche man ernsthaft angehen will, die Namensgebungen eine wichtige Rolle spielen. Denn dieses Grundelement ist in allen Sprachen gleich.

Um es mal bildlich zu sprechen: Wenn ich in der Werkstatt bin und mir einen Prototypen von irgendetwas basteln möchte, achte ich zunächst nicht auf den Feinschliff, zum Beispiel alle Bauteile die gleiche Farbe haben oder die Bauteile "hübsch" aussehen. Beim Prototyp möchte ich zunächst einmal "grob" basteln, später, wenn alles so läuft wie ich es mir vorstelle, kann ich dann all die anderen Dinge berücksichtigen.

Aber zu meinem Anliegen: Wie bekomme ich all die Werte zurück? Bis jetzt habe ich immer nur einen Wert zurück bekommen.

[Üpsilon]

Code: Alles auswählen

def giesskannen(albatross):
    schlafanzug = [float(liebe_und_gesetze.replace(',', '.')) for liebe_und_gesetze in albatross]
    for genesungswuensche in schlafanzug:
          return genesungswünsche

Wo issen der Like-Knopf?

Edit:

Aber zu meinem Anliegen: Wie bekomme ich all die Werte zurück? Bis jetzt habe ich immer nur einen Wert zurück bekommen.

Hab ich doch oben schon geschrieben. Jetzt machst du erstmal ein Schläfchen, und morgen nach dem Frühstück schaust du dir diesen Thread nochmal durch. Wenn du es dann nicht hinkriegst, ist Programmieren (zumindest mit Erwachsenen-Sprachen wie Python) wohl nix für dich (Sorry).
Gute Nacht von Mister Y.

[EyDu]

Ich habe es wie folgt betrachtet: Wir besprechen hier einen minimalen Schnipsel, welcher zum einen völlig aus dem Kontext gezogen worden ist und zum anderen sehr übersichtlich ist. Aus diesem Grund sah ich mich nicht dazu veranlasst um die sinnvollen Namensgebung zu kümmern.

Dann drehen wir die Sache einfach mal um: Du hast keine Lust Dinge vernünftig zu benennen, wir sollen aber den Code verstehen können um dir zu helfen. Du machst es den Helfenden also mit Absicht schwer es zu verstehen und vergibst zusätzlich noch irreführende Namen. Jetzt stellt sich mir natürlich die Frage warum man dir noch helfen sollte, wenn du gemütlich alle sinnvollen Ratschläge ignorierst und einfach weiter rätst statt strukturiert an das Problem zu gehen. Die meisten der Helfenden hier im Thread verdienen ihr Geld mit dem Kram und wissen sehr genau was sie tun. Wenn du die Ratschläge nicht annehmen willst, dann ist das deine Sache. Dann musst du aber damit rechnen, dass du bald gar keine Ratschläge mehr bekommst.

[Sophus]

Hallo EyDu,

du hast Recht. Man sollte sich von Anfang an diszipliniert verhalten. Ich habe mich nochmal hingesetzt, und die Namengebungen nach meinem Stil gestaltet:

Code: Alles auswählen

# -*- coding: cp1252 -*-
def zeichen_umwandeln(str_zahlen):
     zeichen_ersetzt = [float(eintraege.replace(',', '.')) for eintraege in str_zahlen]
     for gleitkommazahl in zeichen_ersetzt:
          return gleitkommazahl

def main():
    str_liste_kommazahl = [
    "5,2",
    "7,0",
    "8.0",
    "2,6"
    ]

    ergebnis= zeichen_umwandeln(str_liste_kommazahl)       # Der Funktion die Zahlen aus der Liste übergeben.
    print ergebnis # Ausgabe: 5.2
    
if __name__ == "__main__":
    main()

Entschuldigt, wenn ich keine englischen Begriffe verwende. Ich bin ein Verfechter der "Sprachen-Trennung". Solange es nicht nötig ist, englisch zu sprechen bzw. zu schreiben, kommuniziere ich auch in meiner Muttersprache. Jedoch mache ich in der Pflege meiner Muttersprache eine Ausnahme, und zwar bei der Formatierung der Umlaute. Eigentlich sind sie in dieser Schreibweise gänzlich falsch. Grund für diese Ausnahme:Es handelt sich hierbei um Variablen. Das Kürzel str benutze ich immer stellvertretend für den Typus String.

Zurück zum Problem: Er gibt mir nur einen Eintrag aus der Liste zurück. Wie ist es möglich alle Einträge zu bekommen?

[mutetella]

Wie ist es möglich alle Einträge zu bekommen?

Indem Du alle Einträge zurückgibst... Jetzt überleg' doch mal selbst: Über die Schleife greifst Du Element für Element auf alle Einträge zu. Und wo sind alle Einträge?

mutetella

[Sophus]

Wie ist es möglich alle Einträge zu bekommen?

Indem Du alle Einträge zurückgibst... Jetzt überleg' doch mal selbst: Über die Schleife greifst Du Element für Element auf alle Einträge zu. Und wo sind alle Einträge?

mutetella

Alter Falter, wieso komme ich nicht selbst darauf? Besten Dank.

Code: Alles auswählen

# -*- coding: cp1252 -*-
def zeichen_umwandeln(str_zahlen):
     zeichen_ersetzt = [float(eintraege.replace(',', '.')) for eintraege in str_zahlen]
     for gleitkommazahl in zeichen_ersetzt:
          return zeichen_ersetzt

def main():
    str_liste_kommazahl = [
    "5,2",
    "7,0",
    "8.0",
    "2,6"
    ]

    resultat = zeichen_umwandeln(str_liste_kommazahl)       # An die Funktion die Zahlen aus der Liste übergeben.
    print resultat
    
if __name__ == "__main__":
    main()

[EyDu]

Entschuldigt, wenn ich keine englischen Begriffe verwende. Ich bin ein Verfechter der "Sprachen-Trennung". Solange es nicht nötig ist, englisch zu sprechen bzw. zu schreiben, kommuniziere ich auch in meiner Muttersprache. Jedoch mache ich in der Pflege meiner Muttersprache eine Ausnahme, und zwar bei der Formatierung der Umlaute. Eigentlich sind sie in dieser Schreibweise gänzlich falsch.

So lange du da konsequent bist und nicht englische und deutsche Namen vermischt ist das auch eher ein kleines Problem.

Grund für diese Ausnahme:Es handelt sich hierbei um Variablen. Das Kürzel str benutze ich immer stellvertretend für den Typus String.

Diese Notation solltest du dir gleich wieder abgewöhnen, das macht man schon seit den Neunzigern nicht mehr. Viel zu unleserlich und unpraktisch. Es ändert sich doch häufiger mal der Typ. Gerade in dynamischen Sprachen mit Duck Typing, da ist das sogar explizit vorgesehen. Dann stehen da entweder falsche Typinformationen oder du musst alles ändern. Und letzteres geht häufig gar nicht, da sich dann die Schnittstelle ändert. Das führt alles nur zu Problemen.

Nutze die Pluralform: Eine Sequenz von Tieren nennst du einfach "tiere" und nicht "liste_tier".

[EyDu]

Und nun denkst du noch einmal über die Sinnhaftigkeit der for-Schleife in deinem letzten Beitrag nach. Du hast schon wieder so lange geändert, bis es irgendwie funktioniert hat. Du musst schon verstehen, *warum* das so funktioniert und was an der Schleife falsch ist.