Daten zwischen Klassen austauschen - guter Programmierstil ?

[owR2K]

Hallo,

in meinem Programm sind die Funktionen in zwei Klassen aufgeteilt, wie:

Code: Alles auswählen

#!/usr/bin/python3
SYSTEM = "1234"
SYSTEM_VAR = ""
class DatenSammeln:
    def __init__(self):
        self.system_variable()
    @staticmethod
    def system_variable():
        global SYSTEM_VAR
        SYSTEM_VAR = "xyz"
        # ...
    @staticmethod
    def daten_neu_abfragen():
        my_data = "bekomme Daten ..."
        # ...
        return my_data
class DatenAuswerten:
    def __init__(self):
        self.daten_auswerten()
    def auswerten_von_xy(self, my_data):
        x = my_data
        # ...
        return x
    def daten_auswerten(self):
        my_data = DatenSammeln.daten_neu_abfragen()
        ...
        if ("... wenn Daten-Aktualisierung benötigt ..."):
            data = DatenSammeln.daten_neu_abfragen()
        # ...
        self.auswerten_von_xy(my_data)
        # ...
if __name__ == '__main__':
    DatenSammeln()
    DatenAuswerten()

Danach könnten allerdings alle Funktionen static sein, ist das noch ein guter Programmierstil?

Sonst müsste ich DatenSammeln als Objekt in DatenAuswerten anlegen?
Alle Daten, vom DatenSammeln Objekt dort sammeln und DatenAuswerten müsste es über das DatenSammeln-Objekt jedes mal Daten/Funktionen abrufen.

Aber ich fürchte das verkompliziert nur die ganze Angelegenheit?

MfG

[Sirius3]

Allein schon Deine Klassennamen sollten ein Alarmsignal sein. `Daten sammeln` und `Daten auswerten` sind Tätigkeiten, keine Zustand. Klassen aber speichern Zustand. Du hast also keine Klassen.
Vergiss gleich wieder, dass es `global` gibt, und vor allem, dass man KONSTANTEN konstant sein sollten, sonst sind das nämlich keine Konstanten.
Schreibe also ein Programm, das aus Funktionen besteht, also wirklichen Funktionen, die alles, was sie brauchen über ihre Argumente bekommen und Rückgabewerte haben.

[owR2K]

Danke, die Kassennamen sind vielleicht nicht gut gewählt, es sollte meine Frage/Problem darstellen.

Mein Gedanke war, alle Funktionen zum Daten verarbeiten und zum Daten auswerten in separaten Klassen zu halten, damit es übersichtlicher bleibt. Insgesamt bin ich momentan bei ungefähr 35 Funktionen, welche dann ohne Klassen in einem Python Skript verbleiben. Die Funktionen benötigen zum Teil Variablen, welche Konstant sind oder bei Initialisierung festgelegt werden. Teilweise werden die Variablen erst in der dritten Ebene benötigt, die alle Durchschleusen halte ich auch nicht für effektiv, deswegen hatte ich global gewählt.

Das meinte ich mit dritter Ebene:

Code: Alles auswählen

def daten_auswerten(variable_xy): # Ebene 1
# data ....
auswerten_von_xy(data,  typ_x, typ_y)

def auswerten_von_xy(data, typ_x,typ_y ):  # Ebene 2
#...
auswerten_x(typ_x)
auswerten_y(typ_y)

def auswerten_x(typ_x):  # Ebene 3
# hier wird typ_x benötigt

def auswerten_y(typ_y):  # Ebene 3
# hier wird typ_y benötigt

[sparrow]

Klassen sind keine Container für Funktionen. Dein Gedanke ist also falsch.

Globale Variablen sind immer eine schlechte Idee. Funktionen bekommen alles, was sie benötigen, als Parameter und gibt ein Ergebnis per return zurück.
Ich verstehe deine Not auch nicht, dennd ein Beispielcode zeigt doch, dass es da keine Durchschleusen gibt. Überhaupt verstehe ich nicht, wo du da Komplexität siehst.
Du übergibst doch "auswerten_x" typ_x. Es ist also da.

Code: Alles auswählen

def daten_auswerten(variable_xy): # Ebene 1
# data ....
auswerten_von_xy(data,  typ_x, typ_y)

def auswerten_von_xy(data, typ_x,typ_y ):  # Ebene 2
#...
auswerten_x(typ_x)
auswerten_y(typ_y)

def auswerten_x(typ_x):  # Ebene 3
# hier wird typ_x benötigt

def auswerten_y(typ_y):  # Ebene 3
# hier wird typ_y benötigt