elektronische Geldbeutel speichert Kundendaten und Finanzoperationen

[Lini]

Hallo,

ich löse jetzt eine Aufgabe auf Python:

Zu einer abstrakten Internet-Seite kommt bald eine neue Dienst/Service hinzu: der electronische Geldbeutel. Das heißt, das System speichert Daten
über ihre Kunden und ihre Finanztransaktionen/Operationen.

Schreiben Sie ein Programm welches (eingegebene??) Daten verarbeitet,
und an der Ausgabe an die Konsole erhalten Sie Folgendes: Kunde "John Swenson". Guthaben: 100 Euro.

Zuerst wollte ich auf algorithmischen Ebene klären, was hier ablaufen soll. Ich stelle es grob so vor:
1. zuerst fragt das System nach Name des Kundes.
2. Der Kunde trägt seine Name ein.
3. Name soll gespeichert werden.

4. Dann sollte ich die Operationen modellieren, als ob dieser Kunde etwas (Service oder Ware) bestellt.
4a. Was Kunde bestellen kann (Services oder Waren) - denke ich heraus?? Z.B.: ein Paar Varianten von Waren und Services und von deren Preisen?
5. Falls Kunde ein Service/Ware bestellt - kommt das dann in den Warenkorb (optional mit Anzahl... aber zuerst ohne Anzahl) mit Name von Ware.
6. Im Warenkorb soll auch das aktuelle Gesamtpreis von bestellten waren indiziert werden. Dabei soll der Preis von jeder neuen Bestellung addiert werden....

Ja, das sind die ersten Gedanken. Ich bitte Sie um Tipps und Korrekturen.
Nach dem Erarbeiten des passenden Algorithmes werde wollte ich das Algorithm mit Python-Code realisieren - hier werde ich auch Ihre Hilfe benötigen.

[Sirius3]

Du hast also keinen Geldbeutel. Denn der speichert nicht die Historie, sondern enthält nur den aufsummierten Betrag.
Deine Hausaufgabe hört sich nach einem typischen Bankkonto an.
Dazu fehlen aber noch viele Angaben. Wie sollen die Daten gespeichert werden? Datenbank? Welche Daten sollen gespeichert werden? Betrag, Sender, Empfänger, Datum, Verwendungszweck?
Welche Operation sollen unterstützt werden?

Deine Planung hört sich dagegen mehr nach einem Warenkorb und ein Bestellprozess an. Ergibt sich diese andere Interpretation aus Hintergrundinformationen, die Du hier nicht verraten hast?

[Lini]

Danke für die Antwort.
Da sind noch welche Informationen, die ich zu diese Aufgabe bekommen konnte. Mehr Info werde ich kaum bekommen.

Ich habe die gleich Fragen wie in diesem Thread oben gestellt. Die Antwort, welche ich bekommen habe:

"ihre Gedanken ( Algorithmus u.a.) sind richtig. Die Aufgabe und code ist zu lösen nach Analogie zu der vorher gemachte Aufgabe"

Die vorherige Aufgabe bestand darin, aus verschiedene Anymals, die Katzen (m and f) auszufiltern und auszugeben.
Die vorherige Aufgabe platziere ich als Auskunft/Muster:

Code: Alles auswählen

# FileName:   Constructor_Class_Cat
class Cat:
    def __init__(self, name="", gender="", age=0):
        self.name = name
        self.gender = gender
        self.age = age

    def init_from_dict(self, cat_dict):
        self.name = cat_dict.get("name")
        self.gender = cat_dict.get("gender")
        self.age = cat_dict.get("age")

Code: Alles auswählen

#FileName: output_select_cats_from anymals
from Constructor_Class_Cat import Cat

cats = [{"name": "King", "gender": "male", "age": 2},
        {"name": "Jacklin", "gender": "female", "age": 1}]

for cat in cats:
        obj_cat = Cat()  # creating object    obj_cat    from the class Cat
        obj_cat.init_from_dict(cat)
        print("name cat", obj_cat.name)
        print("gender cat", obj_cat.gender)
        print("age cat", obj_cat.age)
        print('\n')

"Hier geht es um einen kreativen Lernprozess (Programmieren lernen), daher gibt es keine harte Bedingungen/ Vorschriften. Sie machen alles nach Ihrem Ermessen.
Man muss nichts modellieren.
Am Ende soll das Programm folgendes indizieren: "Kunde "John Swenson". EndBetrag: 100 Euro"

[Lini]

ich schlage es vor, dass ich zuerst die Liste der zu bearbeitender Daten kreiere. Diese Liste könnte m.M.n. folgende Daten enthalten: Name_des_Verantwortlichen, Tätigkeit (Service oder Kauf), Kosten_der_Tätigkeit.

Nach obigen Muster könnte die Liste so aussehen:

ganze_Gesamtheit = [{"name": "Max Musterann", "Service": "Software development 1", "Kosten": 100},
{"name": "Peter Beispielmann", "Service": "Software development 1", "Kosten": 95}
{"name": "Jacky Sparrowson", "Service": "Erstellen Testaufträge", "Kosten": 70}
{"name": "Antonia Tirolsenia", "Service": "Software Testing area 1", "Kosten": 85}
{"name": "Antony Tirolsen", "Service": "Software Testing area 2", "Kosten": 80}
{"name": "Mister A", "Kauf Arbeitsmittel": "Arbeitsmittel Gruppe A", "Kosten": 35}
{"name": "Mister X", "Kauf Arbeitsmittel": "Arbeitsmittel Gruppe X", "Kosten": 35}
{"name": "Mister Y", "Kauf Arbeitsmittel": "Arbeitsmittel Gruppe Y", "Kosten": 30}
{"name": "Mister Z", "Kauf Arbeitsmittel": "Arbeitsmittel Gruppe Z", "Kosten": 25}]

Mein Vorschlag wäre, nach einer Logik (Schleife oder Bedingung) "Services" und "Kauf Arbeitsmittel" zu kombinieren und am output alle beteiligten Namen und aufsummierte gesammtKosten auszugeben.

Logik z.B.: Tätigkeiten (Service oder Kauf) Nr.:0 & ungerade Tätigkeiten aufeinander zu addieren

[__blackjack__]

@Lini: Anmerkungen zu dem Katzenbeispiel: `Constructor_Class_Cat` entspricht von der Schreibweise her nicht den Konventionen für Modulnamen und auch inhaltlich ist der Name nicht gut. Das wäre einfach nur `cat` wenn da genau eine Klasse `Cat` drin steckt. Allerdings sollte nicht eine Klasse alleine in einem Modul stecken, schon gar nicht so eine triviale.

In dem anderen Modul der Code sollte nicht einfach so auf Modulebene stehen, sondern in einer Funktion.

Eingerückt wird mit vier Leerzeichen pro Ebene. Nicht mit 8 wie bei der ``for``-Schleife.

Es ist sehr unüblich ein Objekt erst komplett mit später gar nicht benutzten Dummywerten zu belegen und die alle in einer Methode mit den tatsächlichen Werten zu ersetzen. Ist hier auch überhaupt gar nicht nötig, weil die Argumentnamen der `__init__()` mit den Schlüsseln aus den Wörterbüchern übereinstimmen. Da kann man beim Erstellen einfach ``**`` beim Aufruf benutzen.

`obj_cat` ist ein komischer Name weil in Python alles ein Objekt ist, und damit der Namenszusatz `obj` selten Sinn macht. Denn `cat` ist auch ein Objekt. Also fragt sich der Leser was denn der Unterschied zwischen `cat` und `obj_cat` ist. Und da würde man eher das momentane `cat` und in der Folge dann auch `cats` anders benennen, denn `cat` enthält keine ”komplette” Katze mit Daten und Verhalten, sondern nur die Daten um eine Katze zu erstellen. `obj_cat` steht zumindest potentiell für mehr als nur die Daten, denn man hat bei einer Klasse in der Regel ja nicht nur die Datenattribute, sondern auch Methoden die das verhalten von dem Objekt modellieren.

Das sähe dann also eher so aus:

Code: Alles auswählen

#!/usr/bin/env python3


class Cat:
    def __init__(self, name, gender, age):
        self.name = name
        self.gender = gender
        self.age = age


def main():
    cats_data = [
        {"name": "King", "gender": "male", "age": 2},
        {"name": "Jacklin", "gender": "female", "age": 1},
    ]
    for cat_data in cats_data:
        cat = Cat(**cat_data)
        print("  name:", cat.name)
        print("gender:", cat.gender)
        print("   age:", cat.age)
        print()


if __name__ == "__main__":
    main()

Wobei das alles ziemlich sinnlos ist und man den Zwischenschritt mit der Klasse hier einfach weglassen kann, ohne dass das Programm dadurch wirklich schlechter wird:

Code: Alles auswählen

#!/usr/bin/env python3


def main():
    cats = [
        {"name": "King", "gender": "male", "age": 2},
        {"name": "Jacklin", "gender": "female", "age": 1},
    ]
    for cat in cats:
        print("  name:", cat["name"])
        print("gender:", cat["gender"])
        print("   age:", cat["age"])
        print()


if __name__ == "__main__":
    main()

[Lini]

Vielen Dank für so eine aufmerksame Antwort. Ihre Bemerkungen werde ich aufnehmen und berücksichtigen, aber auf ein Mal wäre alles zu neu zu implementieren - bisschen viel Info.
Ich bin momentan auf der Phase, damit es überhaupt funktionierte und daher wollte ich wenn möglich von dem mir in der Übung gegebenen Beispiel nicht zu weit das Struktur ändern. Jetziges Ziel ist erst : ähnlich machen damit es funktioniert. Das Perfektionieren kommt danach.
Ja, es gibt ein Kontrargument: Lernen muss man vom Anfang korrekt auch stylistisch.
Für mich ist noch Herausforderung - zuerst so zu verstehen und Paar Mal nach Art und Weise üben wie es strukturell ist.

Optimierungsbedarf akzeptiere ich, z.B. Vereinfachung der Modulnamen, aber meine Bitte: nicht alles auf ein Mal wegen Aufnahmefähigkeit von Informationsmenge. Ich bin noch nicht ausreichend geübt. Schritt für Schritt.

[Lini]

Ich habe zuerst den ursprünglichen Beispiel/Aufgabe bisschen geändert und bitte um Ihre Hilfe zuerst die so ins Laufen zu bringen, da es nicht ganz ohne Fehler abläuft.

Code: Alles auswählen

# FileName 'Constructor_Class_workPackage.py'
# creating class Work

class Work:
    def __init__(self, name="", activity="", costs=0):
        self.name = name
        self.activity = activity
        self.costs = costs

    def init_from_dict(self, works_dict):
        self.name = works_dict.get("name")
        self.gender = works_dict.get("activity")
        self.age = works_dict.get("costs")

Code: Alles auswählen

# FileName 'output_choosed_Workpackage.py'
from Constructor_Class_workPackage import Work

works = [{"name": "Max Musterann", "activity": "Software development 1", "costs": 100},
         {"name": "Peter Beispielmann", "activity": "Software development 1", "costs": 95},
         {"name": "Jacky Sparrowson", "activity": "Erstellen Testaufträge", "costs": 70},
         {"name": "Antonia Tirolsenia", "activity": "Software Testing area 1", "costs": 85},
         {"name": "Antony Tirolsen", "activity": "Software Testing area 2", "costs": 80},
         {"name": "Mister A", "activity": "Arbeitsmittel Gruppe A", "costs": 35},
         {"name": "Mister X", "activity": "Arbeitsmittel Gruppe X", "costs": 35},
         {"name": "Mister Y", "activity": "Arbeitsmittel Gruppe Y", "costs": 30},
         {"name": "Mister Z", "activity": "Arbeitsmittel Gruppe Z", "costs": 25}]

for work in works:
    obj_work = Work()    # creating object  obj_work from the class Work
    obj_work.init_from_dict(work)
    # print(works(range(1, 3)))              ???  hier wollte ich zuerst Elemente Nr.1 bis Nr.3
                                             # der Liste 'works' ausdrucken, aber dadurch -> error...
                                             # bitte um Korrektur an der Stelle / Wie wäre das zu realisieren?
    print("name work:", obj_work.name)
    print("activity work:", obj_work.activity)
    print("costs work:", obj_work.costs)
    print('\n')

[Lini]

In diesem Code-Zustand bekomme beim Ausführen von File 'output_choosed_Workpackage.py' folgende Ergebnis:

Code: Alles auswählen

C:\Users\Onri\PycharmProjects\........Praktikum\venv\Scripts\python.exe C:/Users/Onri/PycharmProjects/........Praktikum/output_choosed_Workpackage.py
name work: Max Musterann
activity work: 
costs work: 0

name work: Peter Beispielmann
activity work: 
costs work: 0

name work: Jacky Sparrowson
activity work: 
costs work: 0

name work: Antonia Tirolsenia
activity work: 
costs work: 0

name work: Antony Tirolsen
activity work: 
costs work: 0

name work: Mister A
activity work: 
costs work: 0

name work: Mister X
activity work: 
costs work: 0

name work: Mister Y
activity work: 
costs work: 0

name work: Mister Z
activity work: 
costs work: 0

Process finished with exit code 0

[Lini]

Zur letzten Code-Variante hätte ich Paar Fragen:

1.
Das Parameter "costs" der Liste 'works' war am Anfang beim Kreieren der Klasse auf Wert '0" gesetzt, aber danach in der Liste 'works' war der Parameter 'costs' für jeden Schritt vorgegeben. Ich ging davon aus, dass beim Durchlaufen in der FOR-Schleife werden alle Werte nacheinander ausgegeben werden: wie es beim Paramener 'Name' geschah. Meine Erwartung ist aber noch nicht die Realität.
Bitte um Tipps / Korrektur.

2.
Parameter "activity" der Liste 'works' ist überhaupt nach der Ausführung - leer. Die str-Wetre aus der 'works'-Liste waren auch nicht übernommen, trotzt Einsatz der FOR-Schleife.
Bitte um Tipps / Korrektur.

3.
in der Zeilen 17-19 habe ich die Frage auch rauskommentiert: ich wollte damit (für den Anfang) nur die Elemente Nr.1, Nr.2, Nr.3 der Liste 'works' ausgegeben wäre, aber wenn ich das Befehl
# print(works(range(1, 3)))
aktiviere (ohne # am Anfang) , dann bekomme ich folgende Fehlermeldung:

Code: Alles auswählen

C:\Users\Onri\PycharmProjects\..........Praktikum\venv\Scripts\python.exe C:/Users/Onri/PycharmProjects/............Praktikum/output_choosed_Workpackage.py
  File "C:/Users/Onri/PycharmProjects/............Praktikum/output_choosed_Workpackage.py", line 17
    print(works(range(1, 3)))              ???  hier wollte ich zuerst Elemente Nr.1 bis Nr.3
                                           ^
SyntaxError: invalid syntax

Process finished with exit code 1

Auch hier bitte ich um Tipps / Korrektur

[__blackjack__]

@Lini: Es macht keinen Sinn so weiter zu machen ohne die Probleme anzugehen die angesprochen wurden. Modulnamen mit `Constructor_Class_*`-Präfixen sind unsinnig. Überhaupt einzelne Klassen in eigene Module zu stecken macht keinen Sinn. Module sind dazu da zusammengehörende Konstanten, Funktionen, und Klassen zusammenzufassen. Wenn man jede Klasse in ein eigenes Modul steckt, verwendet man Module falsch.

Nach der `__init__()` sollte ein Objekt in einem benutzbaren Zustand sein, und nicht noch einen `init_from_dict()`-Aufruf brauchen damit sinnvolle Daten enthalten sind. Das ist fehleranfällig weil zwischen dem Erstellen des Objekts und der tatsächlichen Initialisierung Code stehen könnte. Oder man macht Fehler wie hier, die dazu führen, das `activity` und `cost` gar nicht richtig gesetzt werden. Wo denkst Du denn wo genau das passieren würde in dem Code?

Und dann haben wir wieder das Muster wie bei den Katzen, das die Daten für ein `Work`-Objekt als Wörterbuch existieren und dann ein `Work`-Objekt daraus erstellt wird, das aber dann zu nichts wirklich wichtigem verwendet wird. Warum überhaupt dieser Umweg über Wörterbücher?

Und was verstehst Du an dem Syntaxfehler nicht? Du siehst schon wo das "^"-Zeichen in der Fehlermeldung hin zeigt? Was denkst Du denn was diese Fragezeichen da für Python bedeuten sollen?

[Lini]

Sie haben Recht... und ich in dem Fall - weniger.
ich kehre zum CodeBeispiel und Ihre Kommentare (Mittwoch 22. Dezember 2021, 08:48) mit Klasse Cat und Funktion def main(): und arbeite Ihre Bemerkungen durch.
Die Probleme versuche ich so anzugehen.

[Lini]

@Lini:

Es ist sehr unüblich ein Objekt erst komplett mit später gar nicht benutzten Dummywerten zu belegen und die alle in einer Methode mit den tatsächlichen Werten zu ersetzen. Ist hier auch überhaupt gar nicht nötig, weil die Argumentnamen der `__init__()` mit den Schlüsseln aus den Wörterbüchern übereinstimmen. Da kann man beim Erstellen einfach ``**`` beim Aufruf benutzen.

Sie erklären mir sehr gut mit mit Begriffen ... und meine Ausgangslage (unabhängig von meinem Wunsch jetzt): ich schaue den Ausgangsmuster an, versuche es die Logik und Zusammenhänge zu verstehen, dann mache ich Paar Ableitungsvarianten durch. Ich komme von dem Praxis-Code zu den Begriffen... und nicht von Begriffen zu Praxis-Code.
Retrospektivenwechsel - ja gerne... aber bei mir geht es auch um Timing jetzt - das ist die Sache. Sonst hätte ich nicht weiterkommen wollen, bis ich alles ausführlich verstehe.
Manches versteht auch danach... und was nicht - dann kehrt man bei Gelegenheit dazu zurück.

Daher, meine jetzige Bitte wäre zu konkretisieren:

a)
Sie schreiben: " ...unüblich ein Objekt erst komplett..."
Meinen Sie Object hier in der Zeile 15 bei mir: obj_work = Work() ?

b)
"mit später gar nicht benutzten D....werten zu belegen"
Bitte: wo passiert die Belegung und wo sind die genannte D...Werten ?

c)
Sie schreiben: "...und die alle in einer Methode mit den tatsächlichen Werten zu ersetzen..."
Meinen Sie hier die Methode .init_from_dict(work) bei mir in der Zeile 16 ?
Und als tatsächliche Werten meinen Sie die Weten aus der Liste 'works'?

Die aufgeführte Code verstehe ich noch nicht ausführlich. Ich nehme eine einfachere und versuche es by doing zu verstehen. Ich lerne u.a. auch durch Nachmachen und Ableiten.